Mudar o evento para outro mapa

[Crewyvern]

Bom dia pessoas! Estou tentando mudar um evento para outro mapa, quero utilizar o mesmo evento em todos os mapas, eu preciso usar o mesmo pq estou criando um sistema de arma e esse evento vazio seria as balas, se eu criar um evento diferente em cada mapa o sistema vai ficar enorme, até o momento só consegui fazer isso na opção "posição do evento" na parte de "mudar posição com outro evento", em partes funciona, mas quando mudo de mapa o primeiro tiro buga e sai na direção errada, se alguém souber uma maneira de fazer isso de forma mais fácil ajudaria bastante, agradeço quem puder me dar uma luz, se não tiver como o jeito será criar um evento em cada mapa mesmo.

[Brandt]

Que eu saiba, nenhum RM tem essa opção por eventos.

Por outro lado, a menos que você esteja no 2k/3, com scripts você resolve facinho:

RPG Maker MV: Orange Custom Events, do Hudell

RPG Maker VX Ace: Copy Events, do Fomar0153

Pro XP deve ter também, mas eu tive preguiça de procurar hahaha
Na dúvida, pesquisando por "RPG Maker <...> clone events" no Google você acha.

Uma outra alternativa é fazer o sistema de arma com scripts, que vai dar menos trabalho e mais liberdade pra customizar as coisas. Isso sem contar a legibilidade do sistema depois; sistemas por evento são um inferno de depurar e manter.

[Crewyvern]

Que eu saiba, nenhum RM tem essa opção por eventos.

Por outro lado, a menos que você esteja no 2k/3, com scripts você resolve facinho:

RPG Maker MV: Orange Custom Events, do Hudell

RPG Maker VX Ace: Copy Events, do Fomar0153

Pro XP deve ter também, mas eu tive preguiça de procurar hahaha
Na dúvida, pesquisando por "RPG Maker <...> clone events" no Google você acha.

Uma outra alternativa é fazer o sistema de arma com scripts, que vai dar menos trabalho e mais liberdade pra customizar as coisas. Isso sem contar a legibilidade do sistema depois; sistemas por evento são um inferno de depurar e manter.

Essa parte de usar o mesmo evento em todos os mapas foi burrice minha, era só criar um evento em outro mapa com o mesmo número de id, eu não tinha percebido isso ;-;
Porém você me ajudou muito agora, o que eu precisava servia só pra usar esse evento da bala, mas o dos inimigos não deu certo, esse script de copiar eventos vai me ajudar muito, obrigado pela força de vdd
E sobre a alternativa que você sugeriu de criar com scripts é difícil pra mim, ainda estou aprendendo e o que eu sei não da nem pro começo, infelizmente o jeito é por eventos.

E mais uma vez obrigado, ajudou muito mesmo

[Jorge_Maker]

Primeiramente, eu peço que considere a sábia sugestão do Sr. Masked. Scripts são muito melhores que eventos para o desenvolvimento de sistemas. >.>
Você não especificou qual versão do Maker está usando, mas espero que seja algum que use Ruby, pois são os únicos que posso lhe ajudar em algo. auhuhe'
O script que o Brandt passou para o VXAce é útil mas ele não considera algumas coisas e não tem a performance mais agradável. Nesse script, sempre que um evento é criado, o Sprite de todos os outros personagens (incluindo o jogador e até mesmo os veículos) é apagado e criado novamente, isso, se usado com frequência em mapas cheios de eventos pode culminar numa brusca queda de fps sem necessidade alguma. Além disso, se você copia muitos eventos para um mapa, alguma hora vai surgir a necessidade de apaga-los, certo? Pensando nisso, fiz esse script procê: o/

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de 
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Adiciona temporariamente um evento no Mapa
  #--------------------------------------------------------------------------
  #(mapid, eventid, x, y)
  #(mapid, eventid, x, y, direction)
  #(mapid, eventid, anchor_character)
  #--------------------------------------------------------------------------
  def add_event(*args)
    map           = load_data(sprintf("Data/Map%03d.rvdata2", args[0]))
    event_data    = map.events[args[1]]
    event_data.id = valid_event_id
    if args[2].is_a?(Game_CharacterBase)
      event_data.x  = args[2].x
      event_data.y  = args[2].y
      game_event = Game_Event.new(@map_id, event_data)
      d = args[2].direction; game_event.set_direction(d)
    else
      event_data.x  = args[2]
      event_data.y  = args[3]
      game_event = Game_Event.new(@map_id, event_data)
      d = args[4] || game_event.direction; game_event.set_direction(d)
    end
    Spriteset_Map.instance.create_single_character(game_event)
    @events[game_event.id] = game_event
  end
  #--------------------------------------------------------------------------
  # * Apaga, temporariamente, eventos do Mapa
  #--------------------------------------------------------------------------
  def erase_events(*ids)
    ids.each do |id|
      next unless @events[id]
      Spriteset_Map.instance.dispose_single_character(@events[id])
      @events.delete(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Retorna uma ID válida para um próximo evento
  #--------------------------------------------------------------------------
  def valid_event_id
    return 1 if @events.keys.size == 0
    id_list = @events.keys
    valid_ids = [*1..id_list.max] - id_list
      next_id = valid_ids.size > 0 ? valid_ids[0] : id_list.max + 1
    return next_id
  end
  #--------------------------------------------------------------------------
  # * Atualizar Eventos
  # ** Método Reescrito
  #--------------------------------------------------------------------------
  def update_events
    @events.values.each {|event| event.update }
    @common_events.each {|event| event.update }
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é
# usada internamente pela classe Scene_Map. 
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  @@__instance = nil
  def self.instance
    return @@__instance
  end
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
    @@__instance = self
    copy_events_initialize__
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def create_single_character(character)
    @character_sprites.push(Sprite_Character.new(@viewport1, character))
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def dispose_single_character(character)
    @character_sprites.each do |sprite|
      if sprite.character == character
        sprite.dispose; @character_sprites.delete(sprite); break
      end
    end
  end
end

Você pode usar ele das seguintes formas:
Especificando o mapa, a id e as novas coordenadas:
$game_map.add_event(id_do_mapa, id_do_evento, x, y)
Pode também especificar alguma direção para o evento:
$game_map.add_event(id_do_mapa, id_do_evento, x, y, direção)
Adicionar um evento nas coordenas e na mesma direção de algum personagem:
$game_map.add_event(id_do_mapa, id_do_evento, $game_player)
$game_map.add_event(id_do_mapa, id_do_evento, $game_map.events[2])
E apagar eventos:
$game_map.erase_events(id1)
$game_map.erase_events(id1, id2, id3..idn)

Qualquer dúvida ou bug, só avisar.

[Crewyvern]

Primeiramente, eu peço que considere a sábia sugestão do Sr. Masked. Scripts são muito melhores que eventos para o desenvolvimento de sistemas. >.>
Você não especificou qual versão do Maker está usando, mas espero que seja algum que use Ruby, pois são os únicos que posso lhe ajudar em algo. auhuhe'
O script que o Brandt passou para o VXAce é útil mas ele não considera algumas coisas e não tem a performance mais agradável. Nesse script, sempre que um evento é criado, o Sprite de todos os outros personagens (incluindo o jogador e até mesmo os veículos) é apagado e criado novamente, isso, se usado com frequência em mapas cheios de eventos pode culminar numa brusca queda de fps sem necessidade alguma. Além disso, se você copia muitos eventos para um mapa, alguma hora vai surgir a necessidade de apaga-los, certo? Pensando nisso, fiz esse script procê: o/

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de 
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Adiciona temporariamente um evento no Mapa
  #--------------------------------------------------------------------------
  #(mapid, eventid, x, y)
  #(mapid, eventid, x, y, direction)
  #(mapid, eventid, anchor_character)
  #--------------------------------------------------------------------------
  def add_event(*args)
    map           = load_data(sprintf("Data/Map%03d.rvdata2", args[0]))
    event_data    = map.events[args[1]]
    event_data.id = valid_event_id
    if args[2].is_a?(Game_CharacterBase)
      event_data.x  = args[2].x
      event_data.y  = args[2].y
      game_event = Game_Event.new(@map_id, event_data)
      d = args[2].direction; game_event.set_direction(d)
    else
      event_data.x  = args[2]
      event_data.y  = args[3]
      game_event = Game_Event.new(@map_id, event_data)
      d = args[4] || game_event.direction; game_event.set_direction(d)
    end
    Spriteset_Map.instance.create_single_character(game_event)
    @events[game_event.id] = game_event
  end
  #--------------------------------------------------------------------------
  # * Apaga, temporariamente, eventos do Mapa
  #--------------------------------------------------------------------------
  def erase_events(*ids)
    ids.each do |id|
      next unless @events[id]
      Spriteset_Map.instance.dispose_single_character(@events[id])
      @events.delete(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Retorna uma ID válida para um próximo evento
  #--------------------------------------------------------------------------
  def valid_event_id
    return 1 if @events.keys.size == 0
    id_list = @events.keys
    valid_ids = [*1..id_list.max] - id_list
      next_id = valid_ids.size > 0 ? valid_ids[0] : id_list.max + 1
    return next_id
  end
  #--------------------------------------------------------------------------
  # * Atualizar Eventos
  # ** Método Reescrito
  #--------------------------------------------------------------------------
  def update_events
    @events.values.each {|event| event.update }
    @common_events.each {|event| event.update }
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é
# usada internamente pela classe Scene_Map. 
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  @@__instance = nil
  def self.instance
    return @@__instance
  end
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
    @@__instance = self
    copy_events_initialize__
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def create_single_character(character)
    @character_sprites.push(Sprite_Character.new(@viewport1, character))
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def dispose_single_character(character)
    @character_sprites.each do |sprite|
      if sprite.character == character
        sprite.dispose; @character_sprites.delete(sprite); break
      end
    end
  end
end

Você pode usar ele das seguintes formas:
Especificando o mapa, a id e as novas coordenadas:
$game_map.add_event(id_do_mapa, id_do_evento, x, y)
Pode também especificar alguma direção para o evento:
$game_map.add_event(id_do_mapa, id_do_evento, x, y, direção)
Adicionar um evento nas coordenas e na mesma direção de algum personagem:
$game_map.add_event(id_do_mapa, id_do_evento, $game_player)
$game_map.add_event(id_do_mapa, id_do_evento, $game_map.events[2])
E apagar eventos:
$game_map.erase_events(id1)
$game_map.erase_events(id1, id2, id3..idn)

Qualquer dúvida ou bug, só avisar.

Eu sei que é muito melhor por scripts, mas eu sou limitado demais nessa parte, então eu acabo ficando com medo de me arriscar.
A versão é o ace.
E obrigado  por esse criar esse script, deve ter dado trabalho pra ti, mas eu não estou conseguindo usar, tenho quase certeza que sou burro, eu já tentei chamar o script assim $game_map.add_event(2, 3, $game_player), $game_map.add_event(id2, id3, $game_player) e de outras formas, mas sempre da erro no "game interpreter na linha 1414", perdoai por minha burrice.

[Jorge_Maker]

O modo correto de usar seria esse mesmo: $game_map.add_event(2, 3, $game_player)
Pode tirar print do erro? Ele pode estar ocorrendo pois não existe mapa com essa id, ou não existe evento naquele mapa com esta id.

[Crewyvern]

Primeiramente, eu peço que considere a sábia sugestão do Sr. Masked. Scripts são muito melhores que eventos para o desenvolvimento de sistemas. >.>
Você não especificou qual versão do Maker está usando, mas espero que seja algum que use Ruby, pois são os únicos que posso lhe ajudar em algo. auhuhe'
O script que o Brandt passou para o VXAce é útil mas ele não considera algumas coisas e não tem a performance mais agradável. Nesse script, sempre que um evento é criado, o Sprite de todos os outros personagens (incluindo o jogador e até mesmo os veículos) é apagado e criado novamente, isso, se usado com frequência em mapas cheios de eventos pode culminar numa brusca queda de fps sem necessidade alguma. Além disso, se você copia muitos eventos para um mapa, alguma hora vai surgir a necessidade de apaga-los, certo? Pensando nisso, fiz esse script procê: o/

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de 
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Adiciona temporariamente um evento no Mapa
  #--------------------------------------------------------------------------
  #(mapid, eventid, x, y)
  #(mapid, eventid, x, y, direction)
  #(mapid, eventid, anchor_character)
  #--------------------------------------------------------------------------
  def add_event(*args)
    map           = load_data(sprintf("Data/Map%03d.rvdata2", args[0]))
    event_data    = map.events[args[1]]
    event_data.id = valid_event_id
    if args[2].is_a?(Game_CharacterBase)
      event_data.x  = args[2].x
      event_data.y  = args[2].y
      game_event = Game_Event.new(@map_id, event_data)
      d = args[2].direction; game_event.set_direction(d)
    else
      event_data.x  = args[2]
      event_data.y  = args[3]
      game_event = Game_Event.new(@map_id, event_data)
      d = args[4] || game_event.direction; game_event.set_direction(d)
    end
    Spriteset_Map.instance.create_single_character(game_event)
    @events[game_event.id] = game_event
  end
  #--------------------------------------------------------------------------
  # * Apaga, temporariamente, eventos do Mapa
  #--------------------------------------------------------------------------
  def erase_events(*ids)
    ids.each do |id|
      next unless @events[id]
      Spriteset_Map.instance.dispose_single_character(@events[id])
      @events.delete(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Retorna uma ID válida para um próximo evento
  #--------------------------------------------------------------------------
  def valid_event_id
    return 1 if @events.keys.size == 0
    id_list = @events.keys
    valid_ids = [*1..id_list.max] - id_list
      next_id = valid_ids.size > 0 ? valid_ids[0] : id_list.max + 1
    return next_id
  end
  #--------------------------------------------------------------------------
  # * Atualizar Eventos
  # ** Método Reescrito
  #--------------------------------------------------------------------------
  def update_events
    @events.values.each {|event| event.update }
    @common_events.each {|event| event.update }
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é
# usada internamente pela classe Scene_Map. 
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  @@__instance = nil
  def self.instance
    return @@__instance
  end
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
    @@__instance = self
    copy_events_initialize__
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def create_single_character(character)
    @character_sprites.push(Sprite_Character.new(@viewport1, character))
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def dispose_single_character(character)
    @character_sprites.each do |sprite|
      if sprite.character == character
        sprite.dispose; @character_sprites.delete(sprite); break
      end
    end
  end
end

Você pode usar ele das seguintes formas:
Especificando o mapa, a id e as novas coordenadas:
$game_map.add_event(id_do_mapa, id_do_evento, x, y)
Pode também especificar alguma direção para o evento:
$game_map.add_event(id_do_mapa, id_do_evento, x, y, direção)
Adicionar um evento nas coordenas e na mesma direção de algum personagem:
$game_map.add_event(id_do_mapa, id_do_evento, $game_player)
$game_map.add_event(id_do_mapa, id_do_evento, $game_map.events[2])
E apagar eventos:
$game_map.erase_events(id1)
$game_map.erase_events(id1, id2, id3..idn)

Qualquer dúvida ou bug, só avisar.

Desculpa pela burrice, acabei conseguindo usar e entendendo como funciona eu acho, achei que era só criar um evento qualquer e colocar o comando pra chamar outro evento pro mapa, mas quando chamei no mesmo evento deu certo, obrigado mais uma vez e desculpa por esse meu erro

Eu fiz assim e funcionou

Antes eu estava fazendo assim, achando que daria pra chamar em outro mapa

[Jorge_Maker]

...

Os dois modos que você usou estão corretos, Helcurt. Não entendi o porquê do erro.
Aliás, o que o script faz é apenas criar um evento idêntico a outro evento de um outro mapa qualquer. Era isso que você queria ou estou enganado? Só pra ter certeza uaheuahe'
Fiz algumas pequenas modificações no script, acho que agora esteja melhor para você usar:

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de 
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Adiciona temporariamente um evento no Mapa
  #--------------------------------------------------------------------------
  #(mapid, eventid, x, y)
  #(mapid, eventid, x, y, direction)
  #(mapid, eventid, anchor_character)
  #--------------------------------------------------------------------------
  def add_event(*args)
    map           = load_data(sprintf("Data/Map%03d.rvdata2", args[0])) rescue nil
    unless map
      raise ScriptError.new(
      "O Mapa de ID #{args[0]} não existe no banco de dados")
    end
    event_data    = map.events[args[1]]
    unless event_data
      raise ScriptError.new(
      "O Evento de ID #{args[1]} não existe no mapa de ID #{args[0]}")
    end
    event_data.id = valid_event_id
    if args[2].is_a?(Game_CharacterBase)
      event_data.x  = args[2].x
      event_data.y  = args[2].y
      game_event = Game_Event.new(@map_id, event_data)
      d = args[2].direction; game_event.set_direction(d)
    else
      event_data.x  = args[2]
      event_data.y  = args[3]
      game_event = Game_Event.new(@map_id, event_data)
      d = args[4] || game_event.direction; game_event.set_direction(d)
    end
    Spriteset_Map.instance.create_single_character(game_event)
    @events[game_event.id] = game_event
  end
  #--------------------------------------------------------------------------
  # * Apaga, temporariamente, eventos do Mapa
  #--------------------------------------------------------------------------
  def erase_events(*ids)
    ids.each do |id|
      next unless @events[id]
      Spriteset_Map.instance.dispose_single_character(@events[id])
      @events.delete(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Retorna uma ID válida para um próximo evento
  #--------------------------------------------------------------------------
  def valid_event_id
    return 1 if @events.keys.size == 0
    id_list = @events.keys
    valid_ids = [*1..id_list.max] - id_list
      next_id = valid_ids.size > 0 ? valid_ids[0] : id_list.max + 1
    return next_id
  end
  #--------------------------------------------------------------------------
  # * Atualizar Eventos
  # ** Método Reescrito
  #--------------------------------------------------------------------------
  def update_events
    @events.values.each {|event| event.update }
    @common_events.each {|event| event.update }
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  Esta classe gerencia os eventos. Ela controla funções incluindo a mudança
# de páginas de event por condições determinadas, e processos paralelos.
# Esta classe é usada internamente pela classe Game_Map. 
#==============================================================================

class Game_Event < Game_Character
  def delete
    $game_map.erase_events(@id)
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é
# usada internamente pela classe Scene_Map. 
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  @@__instance = nil
  def self.instance
    return @@__instance
  end
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
    @@__instance = self
    copy_events_initialize__
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def create_single_character(character)
    @character_sprites.push(Sprite_Character.new(@viewport1, character))
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def dispose_single_character(character)
    @character_sprites.each do |sprite|
      if sprite.character == character
        sprite.dispose; @character_sprites.delete(sprite); break
      end
    end
  end
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Um interpretador para executar os comandos de evento. Esta classe é usada
# internamente pelas classes Game_Map, Game_Troop e Game_Event.
#==============================================================================

class Game_Interpreter
  def add_event(*args)
    $game_map.add_event(*args)
  end
  def erase_events(*args)
    $game_map.erase_events(*args)
  end
  def erase_this_event
    $game_map.erase_events(@event_id)
  end
end

Como usar:

add_event(2,1,30,17) #=> Cria o evento de id 1 do mapa 2 nas coordenas (30,17)
add_event(4,3,2,8,8) #=> Cria o evento de id 3 do mapa 4 nas coordenas (2,8) e olhando para cima
add_event(1,2,$game_player) #=> Cria o evento de id 2 do mapa 1 nas mesmas coordenadas e direção que o jogador
add_event(1,2,$game_map.events[4]) #=> Cria o evento de id 2 do mapa 1 nas mesmas coordenadas e direção que evento de ID 4
erase_events(1) #=> Apaga o evento de ID 1
erase_events(2,3,4,5) #=> Apaga o eventos de ID 2, 3, 4 e 5
erase_this_event #=> Apaga este evento

Espero ter ajudado.
No caso de qualquer erro, mande print do erro, por favor. auheauhe (o/

[Crewyvern]

Os dois modos que você usou estão corretos, Helcurt. Não entendi o porquê do erro.
Aliás, o que o script faz é apenas criar um evento idêntico a outro evento de um outro mapa qualquer. Era isso que você queria ou estou enganado? Só pra ter certeza uaheuahe'
Fiz algumas pequenas modificações no script, acho que agora esteja melhor para você usar:

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de 
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Adiciona temporariamente um evento no Mapa
  #--------------------------------------------------------------------------
  #(mapid, eventid, x, y)
  #(mapid, eventid, x, y, direction)
  #(mapid, eventid, anchor_character)
  #--------------------------------------------------------------------------
  def add_event(*args)
    map           = load_data(sprintf("Data/Map%03d.rvdata2", args[0])) rescue nil
    unless map
      raise ScriptError.new(
      "O Mapa de ID #{args[0]} não existe no banco de dados")
    end
    event_data    = map.events[args[1]]
    unless event_data
      raise ScriptError.new(
      "O Evento de ID #{args[1]} não existe no mapa de ID #{args[0]}")
    end
    event_data.id = valid_event_id
    if args[2].is_a?(Game_CharacterBase)
      event_data.x  = args[2].x
      event_data.y  = args[2].y
      game_event = Game_Event.new(@map_id, event_data)
      d = args[2].direction; game_event.set_direction(d)
    else
      event_data.x  = args[2]
      event_data.y  = args[3]
      game_event = Game_Event.new(@map_id, event_data)
      d = args[4] || game_event.direction; game_event.set_direction(d)
    end
    Spriteset_Map.instance.create_single_character(game_event)
    @events[game_event.id] = game_event
  end
  #--------------------------------------------------------------------------
  # * Apaga, temporariamente, eventos do Mapa
  #--------------------------------------------------------------------------
  def erase_events(*ids)
    ids.each do |id|
      next unless @events[id]
      Spriteset_Map.instance.dispose_single_character(@events[id])
      @events.delete(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Retorna uma ID válida para um próximo evento
  #--------------------------------------------------------------------------
  def valid_event_id
    return 1 if @events.keys.size == 0
    id_list = @events.keys
    valid_ids = [*1..id_list.max] - id_list
      next_id = valid_ids.size > 0 ? valid_ids[0] : id_list.max + 1
    return next_id
  end
  #--------------------------------------------------------------------------
  # * Atualizar Eventos
  # ** Método Reescrito
  #--------------------------------------------------------------------------
  def update_events
    @events.values.each {|event| event.update }
    @common_events.each {|event| event.update }
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  Esta classe gerencia os eventos. Ela controla funções incluindo a mudança
# de páginas de event por condições determinadas, e processos paralelos.
# Esta classe é usada internamente pela classe Game_Map. 
#==============================================================================

class Game_Event < Game_Character
  def delete
    $game_map.erase_events(@id)
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é
# usada internamente pela classe Scene_Map. 
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  @@__instance = nil
  def self.instance
    return @@__instance
  end
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
    @@__instance = self
    copy_events_initialize__
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def create_single_character(character)
    @character_sprites.push(Sprite_Character.new(@viewport1, character))
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def dispose_single_character(character)
    @character_sprites.each do |sprite|
      if sprite.character == character
        sprite.dispose; @character_sprites.delete(sprite); break
      end
    end
  end
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Um interpretador para executar os comandos de evento. Esta classe é usada
# internamente pelas classes Game_Map, Game_Troop e Game_Event.
#==============================================================================

class Game_Interpreter
  def add_event(*args)
    $game_map.add_event(*args)
  end
  def erase_events(*args)
    $game_map.erase_events(*args)
  end
  def erase_this_event
    $game_map.erase_events(@event_id)
  end
end

Como usar:

add_event(2,1,30,17) #=> Cria o evento de id 1 do mapa 2 nas coordenas (30,17)
add_event(4,3,2,8,8) #=> Cria o evento de id 3 do mapa 4 nas coordenas (2,8) e olhando para cima
add_event(1,2,$game_player) #=> Cria o evento de id 2 do mapa 1 nas mesmas coordenadas e direção que o jogador
add_event(1,2,$game_map.events[4]) #=> Cria o evento de id 2 do mapa 1 nas mesmas coordenadas e direção que evento de ID 4
erase_events(1) #=> Apaga o evento de ID 1
erase_events(2,3,4,5) #=> Apaga o eventos de ID 2, 3, 4 e 5
erase_this_event #=> Apaga este evento

Espero ter ajudado.
No caso de qualquer erro, mande print do erro, por favor. auheauhe (o/

Opa moço Jorge, desculpa a demora pra responder, tinha saído pra correr

Aliás, o que o script faz é apenas criar um evento idêntico a outro evento de um outro mapa qualquer. Era isso que você queria ou estou enganado? Só pra ter certeza uaheuahe'

É isso mesmo ><
Eu testei aqui o script e ele funcionou no mesmo mapa, quando tentava criar um evento do mapa 1 para o mapa 2, aparecia o erro dizendo que o evento de id 3 não existia no mapa de id 2.
Aqui eu usei add_event(1,3,1,1) e funcionou normalmente

Depois eu coloquei add_event(2,3,1,1) e deu esse erro

Mas depois eu criei um evento de id 3 no segundo mapa, usei esse comando dnv add_event(2,3,1,1) e ele adicionou no mapa 1 ao invés de adicionar no mapa 2, do mesmo jeito que funcionou na primeira imagem.

Mas você já fez demais por mim cara, não precisa mais se incomodar, eu vou tentar fazer isso criando eventos no mapa msm, o seu script já vai ajudar demais com os inimigos, e mais uma vez muito obrigado, isso já é uma ajuda e tanto

[Jorge_Maker]

Fico feliz em ter ajudado. o/
Então, o erro que aconteceu com você é autoexplicativo. xD Pode verificar você mesmo, não deve existir nenhum evento de ID 3 no mapa de ID 2.
Essa também é outro limitação do Script, ele só cria eventos no mapa atual do jogador, se você estiver no Mapa 1, só será possível criar eventos no Mapa 1. Você vai precisar criar eventos em um mapa diferente do atual? Se sim, posso tentar fazer algo. uhaeuhae

[Crewyvern]

Fico feliz em ter ajudado. o/
Então, o erro que aconteceu com você é autoexplicativo. xD Pode verificar você mesmo, não deve existir nenhum evento de ID 3 no mapa de ID 2.
Essa também é outro limitação do Script, ele só cria eventos no mapa atual do jogador, se você estiver no Mapa 1, só será possível criar eventos no Mapa 1.Você vai precisar criar eventos em um mapa diferente do atual? Se sim, posso tentar fazer algo.uhaeuhae

Eu percebi isso quando estava testando, demorou mas consegui entender kkk lerdeza dms, mesmo assim é muito bom poder clonar o evento, só assim evita de configurar algumas coisas nos outros, pra mim já é ótimo.

Você vai precisar criar eventos em um mapa diferente do atual? Se sim, posso tentar fazer algo.

Caraca man kkkk precisa se incomodar tanto não slk, quero dar trabalho pra ti não, mas qualquer hora dessas eu apareço novamente com mais dúvidas chatas u.u vlw mesmo cara

[Jorge_Maker]

Pô, eu quase ia esquecendo, mas há algumas semanas eu acabei fazendo o sistema de spawnar eventos em outros mapas. Como não quero deixar ele empoeirando no HD (como todas as outras coisa que eu faço) e você parece estar interessado nesse tipo de mecânica, tó:

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de 
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader :maps_data
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :add_events_map_init__ :initialize
  def initialize
    add_events_map_init__
    @maps_data = Game_Maps_Data.new
  end
  #--------------------------------------------------------------------------
  # * Configuração
  #     map_id : ID do mapa
  #--------------------------------------------------------------------------
  alias :add_events_map_setup__ :setup
  def setup(map_id)
    add_events_map_setup__(map_id)
  end
  #--------------------------------------------------------------------------
  # * Configuração dos eventos
  #--------------------------------------------------------------------------
   alias :add_events_map_setup_events__ :setup_events
  def setup_events
    add_events_map_setup_events__
    if @maps_data.persistent_events[@map_id]
      @maps_data.persistent_events[@map_id].each { |event_data|
        new_id = valid_event_id
        ["A","B","C","D"].each { |switch|
          key = [@map_id, event_data.id, switch]
          last_value = $game_self_switches[key]
          $game_self_switches[key] = false
          key = [@map_id, new_id, switch]
          $game_self_switches[key] = last_value
        } if new_id != event_data.id
        event_data.id = new_id
        @events[event_data.id] = Game_Event.new(@map_id, event_data)
      }
    end
    refresh_tile_events
  end
  #--------------------------------------------------------------------------
  # * Adiciona um evento no Mapa
  #--------------------------------------------------------------------------
  #(mapid, eventid, x, y, persistent?)
  #(mapid, eventid, x, y, persistent?, update_data?)
  #(mapid, eventid, anchor_character, persistent?, update_data?)
  #--------------------------------------------------------------------------
  def add_event(*args)
    event_data = @maps_data.get_event_data(args[1], args[0])
    event_data.id = valid_event_id
    if args[2].is_a?(Game_CharacterBase)
      event_data.x  = args[2].x
      event_data.y  = args[2].y
      game_event = Game_Event.new(@map_id, event_data)
      d = args[2].direction; game_event.set_direction(d)
      persistent  = args[3]
      update_data = args[4]
    else
      event_data.x  = args[2]
      event_data.y  = args[3]
      game_event = Game_Event.new(@map_id, event_data)
      persistent  = args[4]
      update_data = args[5]
    end
    if persistent
      if update_data 
        matrix = {orginal_map: args[0], orginal_id: args[1]}
      end
      @maps_data.add_persistent_event(event_data, @map_id, matrix)
    end
    Spriteset_Map.instance.create_single_character(game_event)
    @events[game_event.id] = game_event
    return game_event.id
  end
  #--------------------------------------------------------------------------
  # * Adiciona um evento em outro mapa
  #--------------------------------------------------------------------------
  #(map1, eventid, to_map2, x, y)
  #(map1, eventid, to_map2, x, y, update_data?)
  #--------------------------------------------------------------------------
  def add_event_to_another_map(*args)
    if args[2] == @map_id
      return add_event(args[0], args[1], args[3], args[4], true, args[5])
    end
    event_data = @maps_data.get_event_data(args[1], args[0])
    event_data.x  = args[3]
    event_data.y  = args[4]
    if args[5] 
      matrix = {orginal_map: args[0], orginal_id: args[1]}
    end
    @maps_data.add_persistent_event(event_data, args[2], matrix)
  end
  #--------------------------------------------------------------------------
  # * Apaga, temporariamente, eventos do Mapa
  #--------------------------------------------------------------------------
  def erase_events(*ids)
    ids.each do |id|
      next unless @events[id]
      Spriteset_Map.instance.dispose_single_character(@events[id])
      @events.delete(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Apaga, permanentemente, eventos persistentes do Mapa
  #--------------------------------------------------------------------------
  def permanently_erase_events(*ids)
    return unless @maps_data.persistent_events[@map_id]
    ids.each do |id|
      next unless @events[id]
      #["A","B","C","D"].each { |switch|
      #  key = [@map_id, id, switch]
      #  $game_self_switches[key] = false
      #}
      event_data = @maps_data.persistent_events[@map_id].find { |event| event.id == id}
      @maps_data.erase_persistent_event(event_data, @map_id)
      erase_events(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Retorna uma ID válida para um próximo evento
  #--------------------------------------------------------------------------
  def valid_event_id
    return 1 if @events.keys.size == 0
    id_list = @events.keys
    valid_ids = [*1..id_list.max] - id_list
      next_id = valid_ids.size > 0 ? valid_ids[0] : id_list.max + 1
    return next_id
  end
  #--------------------------------------------------------------------------
  # * Atualizar Eventos
  # ** Método Reescrito
  #--------------------------------------------------------------------------
  def update_events
    @events.values.each {|event| event.update }
    @common_events.each {|event| event.update }
  end
end

#==============================================================================
# ** Game_Maps_Data
#------------------------------------------------------------------------------
#  Esta classe gerencia os dados dos mapas do jogo
#==============================================================================

class Game_Maps_Data
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :persistent_events
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    @data = []
    @persistent_events = {}
  end
  #--------------------------------------------------------------------------
  # * Aquisição dos dados do mapa a partir da ID
  #--------------------------------------------------------------------------
  def [](map_id)
    begin
      @data[map_id] ||= load_data(sprintf("Data/Map%03d.rvdata2", map_id))
    rescue
      raise LoadError.new(
      "O Mapa de ID #{map_id} não existe no banco de dados")
    end
    return @data[map_id]
  end
  #--------------------------------------------------------------------------
  # * Aquisição dos dados do evento a partir da sua ID e da ID do mapa 
  #  correspondente
  #--------------------------------------------------------------------------
  def get_event_data(event_id, map_id)
    event_data = self[map_id].events[event_id]
    if !event_data
      raise LoadError.new(
      "O Evento de ID #{event_id} não existe no mapa de ID #{map_id}")
    else
      cloned_event_data = Marshal.load(Marshal.dump(event_data))
      return cloned_event_data
    end
  end
  #--------------------------------------------------------------------------
  # * Adicionar evento persistente
  #--------------------------------------------------------------------------
  def add_persistent_event(event_data, map_id, update_data)
    event_data.update_data = update_data
    (@persistent_events[map_id] ||= []).push(event_data)
  end
  #--------------------------------------------------------------------------
  # * Apagar evento persistente
  #--------------------------------------------------------------------------
  def erase_persistent_event(event_data, map_id)
    (@persistent_events[map_id] ||= []).delete(event_data)
  end
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    @persistent_events.each do |map_id, event_array|
      event_array.size.times do |i|
        up_data = event_array[i].update_data
        if up_data
          begin
            updated_event = get_event_data(up_data[:orginal_id], up_data[:orginal_map])
          rescue LoadError
raise LoadError.new(
"O Evento Matriz (estabelecido no mapa de ID #{up_data[:orginal_map]} e 
de ID #{up_data[:orginal_id]}) não foi encontrado e precisa ser 
reestabelecido para que o evento adicionado no mapa de ID #{map_id} funcione corretamente")
          end
          updated_event.x = event_array[i].x
          updated_event.y = event_array[i].y
          updated_event.id = event_array[i].id
          updated_event.update_data = up_data.dup
          event_array.delete_at(i)
          event_array.insert(i, updated_event)
        end
      end
    end
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  Esta classe gerencia os eventos. Ela controla funções incluindo a mudança
# de páginas de event por condições determinadas, e processos paralelos.
# Esta classe é usada internamente pela classe Game_Map. 
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader   :event
  def delete
    $game_map.erase_events(@id)
  end
end

#==============================================================================
# ** RPG::Event
#------------------------------------------------------------------------------
#  A classe de dados para eventos
#==============================================================================

class RPG::Event
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :update_data
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
  copy_events_initialize__
  @update_data = nil
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é
# usada internamente pela classe Scene_Map. 
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  @@__instance = nil
  def self.instance
    return @@__instance
  end
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
    @@__instance = self
    copy_events_initialize__
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def create_single_character(character)
    @character_sprites.push(Sprite_Character.new(@viewport1, character))
  end
  #--------------------------------------------------------------------------
  # * Apaga o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def dispose_single_character(character)
    @character_sprites.each do |sprite|
      if sprite.character == character
        sprite.dispose; @character_sprites.delete(sprite); break
      end
    end
  end
end

#==============================================================================
# ** DataManager
#------------------------------------------------------------------------------
#  Este módulo gerencia o jogo e objetos do banco de dados utilizados no jogo.
# Quase todas as variáveis globais são inicializadas no módulo.
#==============================================================================

class << DataManager
  #--------------------------------------------------------------------------
  # * Extrair conteúdo salvo
  #--------------------------------------------------------------------------
  alias :spawn_events_map_extract_save_contents__ :extract_save_contents
  def extract_save_contents(contents)
    spawn_events_map_extract_save_contents__(contents)
    $game_map.maps_data.refresh
  end
  #--------------------------------------------------------------------------
  # * Carregamento do Jogo
  #     index : índice
  #--------------------------------------------------------------------------
  def load_game(index)
    load_game_without_rescue(index)
  end
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Um interpretador para executar os comandos de evento. Esta classe é usada
# internamente pelas classes Game_Map, Game_Troop e Game_Event.
#==============================================================================

class Game_Interpreter
  def add_event(*args)
    $game_map.add_event(*args)
  end
  def add_event_to_another_map(*args)
    $game_map.add_event_to_another_map(*args)
  end
  def erase_events(*args)
    $game_map.erase_events(*args)
  end
  def erase_this_event
    erase_events(@event_id)
  end
  def permanently_erase_this_event
    $game_map.permanently_erase_events(@event_id)
  end
end

As funções são as mesma da último script, mas com algumas adições e uma ligeira melhora na performance:

add_event(id_do_mapa, id_do_evento, x, y, evento_persistente?, atualizar_dados?)
add_event(id_do_mapa, id_do_evento, personagem, evento_persistente?, atualizar_dados?)

Ex:
add_event(1, 2, 4, 4, true, true)
add_event(1, 2, $game_player, false)

add_event_to_another_map(do_mapa_1, id_do_evento, para_o_mapa_2, x, y)
add_event_to_another_map(do_mapa_1, id_do_evento, para_o_mapa_2, x, y, atualizar_dados?)

Ex:
add_event_to_another_map(3, 2, 4, 20, 30)
add_event_to_another_map(1, 1, 2, 12, 22, true)

Eu não cheguei a testar o sistema tão bem, então é possível que existam bugs. Nesse caso, é só dar um toque.
Qualquer dúvida, já sabe. o/

[Crewyvern]

Pô, eu quase ia esquecendo, mas há algumas semanas eu acabei fazendo o sistema de spawnar eventos em outros mapas. Como não quero deixar ele empoeirando no HD (como todas as outras coisa que eu faço) e você parece estar interessado nesse tipo de mecânica, tó:

#==============================================================================
# ** Game_Map
#------------------------------------------------------------------------------
#  Esta classe gerencia o mapa. Inclui funções de rolagem e definição de 
# passagens. A instância desta classe é referenciada por $game_map.
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader :maps_data
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :add_events_map_init__ :initialize
  def initialize
    add_events_map_init__
    @maps_data = Game_Maps_Data.new
  end
  #--------------------------------------------------------------------------
  # * Configuração
  #     map_id : ID do mapa
  #--------------------------------------------------------------------------
  alias :add_events_map_setup__ :setup
  def setup(map_id)
    add_events_map_setup__(map_id)
  end
  #--------------------------------------------------------------------------
  # * Configuração dos eventos
  #--------------------------------------------------------------------------
   alias :add_events_map_setup_events__ :setup_events
  def setup_events
    add_events_map_setup_events__
    if @maps_data.persistent_events[@map_id]
      @maps_data.persistent_events[@map_id].each { |event_data|
        new_id = valid_event_id
        ["A","B","C","D"].each { |switch|
          key = [@map_id, event_data.id, switch]
          last_value = $game_self_switches[key]
          $game_self_switches[key] = false
          key = [@map_id, new_id, switch]
          $game_self_switches[key] = last_value
        } if new_id != event_data.id
        event_data.id = new_id
        @events[event_data.id] = Game_Event.new(@map_id, event_data)
      }
    end
    refresh_tile_events
  end
  #--------------------------------------------------------------------------
  # * Adiciona um evento no Mapa
  #--------------------------------------------------------------------------
  #(mapid, eventid, x, y, persistent?)
  #(mapid, eventid, x, y, persistent?, update_data?)
  #(mapid, eventid, anchor_character, persistent?, update_data?)
  #--------------------------------------------------------------------------
  def add_event(*args)
    event_data = @maps_data.get_event_data(args[1], args[0])
    event_data.id = valid_event_id
    if args[2].is_a?(Game_CharacterBase)
      event_data.x  = args[2].x
      event_data.y  = args[2].y
      game_event = Game_Event.new(@map_id, event_data)
      d = args[2].direction; game_event.set_direction(d)
      persistent  = args[3]
      update_data = args[4]
    else
      event_data.x  = args[2]
      event_data.y  = args[3]
      game_event = Game_Event.new(@map_id, event_data)
      persistent  = args[4]
      update_data = args[5]
    end
    if persistent
      if update_data 
        matrix = {orginal_map: args[0], orginal_id: args[1]}
      end
      @maps_data.add_persistent_event(event_data, @map_id, matrix)
    end
    Spriteset_Map.instance.create_single_character(game_event)
    @events[game_event.id] = game_event
    return game_event.id
  end
  #--------------------------------------------------------------------------
  # * Adiciona um evento em outro mapa
  #--------------------------------------------------------------------------
  #(map1, eventid, to_map2, x, y)
  #(map1, eventid, to_map2, x, y, update_data?)
  #--------------------------------------------------------------------------
  def add_event_to_another_map(*args)
    if args[2] == @map_id
      return add_event(args[0], args[1], args[3], args[4], true, args[5])
    end
    event_data = @maps_data.get_event_data(args[1], args[0])
    event_data.x  = args[3]
    event_data.y  = args[4]
    if args[5] 
      matrix = {orginal_map: args[0], orginal_id: args[1]}
    end
    @maps_data.add_persistent_event(event_data, args[2], matrix)
  end
  #--------------------------------------------------------------------------
  # * Apaga, temporariamente, eventos do Mapa
  #--------------------------------------------------------------------------
  def erase_events(*ids)
    ids.each do |id|
      next unless @events[id]
      Spriteset_Map.instance.dispose_single_character(@events[id])
      @events.delete(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Apaga, permanentemente, eventos persistentes do Mapa
  #--------------------------------------------------------------------------
  def permanently_erase_events(*ids)
    return unless @maps_data.persistent_events[@map_id]
    ids.each do |id|
      next unless @events[id]
      #["A","B","C","D"].each { |switch|
      #  key = [@map_id, id, switch]
      #  $game_self_switches[key] = false
      #}
      event_data = @maps_data.persistent_events[@map_id].find { |event| event.id == id}
      @maps_data.erase_persistent_event(event_data, @map_id)
      erase_events(id)
    end
  end
  #--------------------------------------------------------------------------
  # * Retorna uma ID válida para um próximo evento
  #--------------------------------------------------------------------------
  def valid_event_id
    return 1 if @events.keys.size == 0
    id_list = @events.keys
    valid_ids = [*1..id_list.max] - id_list
      next_id = valid_ids.size > 0 ? valid_ids[0] : id_list.max + 1
    return next_id
  end
  #--------------------------------------------------------------------------
  # * Atualizar Eventos
  # ** Método Reescrito
  #--------------------------------------------------------------------------
  def update_events
    @events.values.each {|event| event.update }
    @common_events.each {|event| event.update }
  end
end

#==============================================================================
# ** Game_Maps_Data
#------------------------------------------------------------------------------
#  Esta classe gerencia os dados dos mapas do jogo
#==============================================================================

class Game_Maps_Data
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :persistent_events
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    @data = []
    @persistent_events = {}
  end
  #--------------------------------------------------------------------------
  # * Aquisição dos dados do mapa a partir da ID
  #--------------------------------------------------------------------------
  def [](map_id)
    begin
      @data[map_id] ||= load_data(sprintf("Data/Map%03d.rvdata2", map_id))
    rescue
      raise LoadError.new(
      "O Mapa de ID #{map_id} não existe no banco de dados")
    end
    return @data[map_id]
  end
  #--------------------------------------------------------------------------
  # * Aquisição dos dados do evento a partir da sua ID e da ID do mapa 
  #  correspondente
  #--------------------------------------------------------------------------
  def get_event_data(event_id, map_id)
    event_data = self[map_id].events[event_id]
    if !event_data
      raise LoadError.new(
      "O Evento de ID #{event_id} não existe no mapa de ID #{map_id}")
    else
      cloned_event_data = Marshal.load(Marshal.dump(event_data))
      return cloned_event_data
    end
  end
  #--------------------------------------------------------------------------
  # * Adicionar evento persistente
  #--------------------------------------------------------------------------
  def add_persistent_event(event_data, map_id, update_data)
    event_data.update_data = update_data
    (@persistent_events[map_id] ||= []).push(event_data)
  end
  #--------------------------------------------------------------------------
  # * Apagar evento persistente
  #--------------------------------------------------------------------------
  def erase_persistent_event(event_data, map_id)
    (@persistent_events[map_id] ||= []).delete(event_data)
  end
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    @persistent_events.each do |map_id, event_array|
      event_array.size.times do |i|
        up_data = event_array[i].update_data
        if up_data
          begin
            updated_event = get_event_data(up_data[:orginal_id], up_data[:orginal_map])
          rescue LoadError
raise LoadError.new(
"O Evento Matriz (estabelecido no mapa de ID #{up_data[:orginal_map]} e 
de ID #{up_data[:orginal_id]}) não foi encontrado e precisa ser 
reestabelecido para que o evento adicionado no mapa de ID #{map_id} funcione corretamente")
          end
          updated_event.x = event_array[i].x
          updated_event.y = event_array[i].y
          updated_event.id = event_array[i].id
          updated_event.update_data = up_data.dup
          event_array.delete_at(i)
          event_array.insert(i, updated_event)
        end
      end
    end
  end
end

#==============================================================================
# ** Game_Event
#------------------------------------------------------------------------------
#  Esta classe gerencia os eventos. Ela controla funções incluindo a mudança
# de páginas de event por condições determinadas, e processos paralelos.
# Esta classe é usada internamente pela classe Game_Map. 
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader   :event
  def delete
    $game_map.erase_events(@id)
  end
end

#==============================================================================
# ** RPG::Event
#------------------------------------------------------------------------------
#  A classe de dados para eventos
#==============================================================================

class RPG::Event
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  attr_accessor :update_data
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
  copy_events_initialize__
  @update_data = nil
  end
end

#==============================================================================
# ** Spriteset_Map
#------------------------------------------------------------------------------
#  Esta classe reune os sprites da tela de mapa e tilesets. Esta classe é
# usada internamente pela classe Scene_Map. 
#==============================================================================

class Spriteset_Map
  #--------------------------------------------------------------------------
  # *  Variáveis públicas
  #--------------------------------------------------------------------------
  @@__instance = nil
  def self.instance
    return @@__instance
  end
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  alias :copy_events_initialize__ :initialize
  def initialize
    @@__instance = self
    copy_events_initialize__
  end
  #--------------------------------------------------------------------------
  # * Cria o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def create_single_character(character)
    @character_sprites.push(Sprite_Character.new(@viewport1, character))
  end
  #--------------------------------------------------------------------------
  # * Apaga o Sprite de um único personagem
  #--------------------------------------------------------------------------
  def dispose_single_character(character)
    @character_sprites.each do |sprite|
      if sprite.character == character
        sprite.dispose; @character_sprites.delete(sprite); break
      end
    end
  end
end

#==============================================================================
# ** DataManager
#------------------------------------------------------------------------------
#  Este módulo gerencia o jogo e objetos do banco de dados utilizados no jogo.
# Quase todas as variáveis globais são inicializadas no módulo.
#==============================================================================

class << DataManager
  #--------------------------------------------------------------------------
  # * Extrair conteúdo salvo
  #--------------------------------------------------------------------------
  alias :spawn_events_map_extract_save_contents__ :extract_save_contents
  def extract_save_contents(contents)
    spawn_events_map_extract_save_contents__(contents)
    $game_map.maps_data.refresh
  end
  #--------------------------------------------------------------------------
  # * Carregamento do Jogo
  #     index : índice
  #--------------------------------------------------------------------------
  def load_game(index)
    load_game_without_rescue(index)
  end
end

#==============================================================================
# ** Game_Interpreter
#------------------------------------------------------------------------------
#  Um interpretador para executar os comandos de evento. Esta classe é usada
# internamente pelas classes Game_Map, Game_Troop e Game_Event.
#==============================================================================

class Game_Interpreter
  def add_event(*args)
    $game_map.add_event(*args)
  end
  def add_event_to_another_map(*args)
    $game_map.add_event_to_another_map(*args)
  end
  def erase_events(*args)
    $game_map.erase_events(*args)
  end
  def erase_this_event
    erase_events(@event_id)
  end
  def permanently_erase_this_event
    $game_map.permanently_erase_events(@event_id)
  end
end

As funções são as mesma da último script, mas com algumas adições e uma ligeira melhora na performance:

add_event(id_do_mapa, id_do_evento, x, y, evento_persistente?, atualizar_dados?)
add_event(id_do_mapa, id_do_evento, personagem, evento_persistente?, atualizar_dados?)

Ex:
add_event(1, 2, 4, 4, true, true)
add_event(1, 2, $game_player, false)

add_event_to_another_map(do_mapa_1, id_do_evento, para_o_mapa_2, x, y)
add_event_to_another_map(do_mapa_1, id_do_evento, para_o_mapa_2, x, y, atualizar_dados?)

Ex:
add_event_to_another_map(3, 2, 4, 20, 30)
add_event_to_another_map(1, 1, 2, 12, 22, true)

Eu não cheguei a testar o sistema tão bem, então é possível que existam bugs. Nesse caso, é só dar um toque.
Qualquer dúvida, já sabe. o/

CARA, esse script está muito bom, ele não só cria no mesmo mapa como também no outro, era disso que eu estava precisando. Só imagino as novas possibilidades
Muito obrigado moço Jorge. Mano, quando eu vi o mesmo evento em outro mapa, fiquei tipo "OLOKO"

Eu não cheguei a testar o sistema tão bem, então é possível que existam bugs. Nesse caso, é só dar um toque.
Qualquer dúvida, já sabe. o/

Pó dexa u.u o script tá uma belezura, vai bugar nau.