Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 3768 miembros registrados.
El último usuario registrado es lMac.

Nuestros miembros han publicado un total de 85831 mensajes en 12224 argumentos.

[XP] Wecoc's Interpreter Bugfixes

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP] Wecoc's Interpreter Bugfixes

Mensaje por Wecoc el 2017-02-25, 21:31

La clase Interpreter del RPG maker XP sin duda está mejor que la del VX y Ace pero aún así tiene algunas peculiaridades que a veces pueden resultar molestas.

Éste script para solucionar esos bugs reescribe varios métodos que pongo a continuación:
- initialize
- clear
- update
- command_117
- command_210

Como veis son los típicos más command_117 que corresponde al comando "Llamar a Evento Común".
Esa reescritura no usa alias así que puede que tenga problemas de compatibilidad con otros scripts, deberéis tener cuidado. Ahora pongo lo que cambia.

1. Cada Interpreter soporta múltiples child interpreters. La llamada a eventos comunes funciona como siempre, pero además puede hacerse escribiendo en Llamar Script esto:
call_common_event(ID del evento común)

Eso tiene dos mejoras. La primera es que usando la llamada de siempre si se ponen dos a la vez para hacer el segundo esperará a que el primero haya terminado, mientras que en éste caso no. Lo mismo para continuar con el intérprete principal; no lo continúa hasta que termina el evento común, pero a veces interesa que sí lo haga. La segunda es que se puede definir qué evento usar como propio en el evento común:
call_common_event(ID del evento común, ID del evento)

Por defecto usa el evento que efectuó la llamada, es lo habitual, pero en algunos casos viene bien tener la opción de controlarlo. Si se quiere recuperar la opción de esperar a que termine el evento común antes de continuar el evento pese a usar la llamada por script, se puede poner detrás de esa llamada esto:
@common_event_waiting = true

2. El método update ahora está fragmentado en 9 submétodos distintos, lo que hace más fácil aplicarle cambios sin tener que reescribirlo todo

3. A parte del “Esperar a Finalizar Movimiento” de siempre, ahora también existe una variación que se usa con el código:
wait_self_move

La diferencia es que ésta solo tiene en cuenta los movimientos aplicados en el mismo evento, no todos (a veces algunos engines tienen bugs por culpa de considerar todos los movimientos a la vez con ese comando).

Edit:
Con la versión 1.1 ahora puedes definir que el comando "Esperar a Finalizar Movimiento" directamente funcione con éste nuevo parche, solo tienes que buscar la línea WAIT_SELF_MODE = false y lo cambias por WAIT_SELF_MODE = true.

Entonces si en algún punto se quiere usar el esperar que viene por defecto en vez del nuevo se puede usar el código:
wait_move

4. Si llamas a un evento común, desde éste puedes obtener el intérprete principal del que efectuó esa llamada, usando en llamar script:
self.ancestor

Script:

Código:
#==============================================================================
# ** [XP] Wecoc's Interpreter Bugfixes v1.1
#------------------------------------------------------------------------------
# Reescritura de algunos métodos de la clase Interpreter para solucionar
# algunos bugs internos.
#==============================================================================

class Interpreter
 
  # Poner que por defecto "Esperar a finalizar evento" solo afecte al ev. actual
  WAIT_SELF_MODE = false
 
  attr_accessor :ancestor # Intérprete principal
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(depth = 0, main = false)
    @depth = depth
    @main = main
    @ancestor = nil
    @child_interpreters = {}
    clear
  end
  #--------------------------------------------------------------------------
  # * Clear
  #--------------------------------------------------------------------------
  def clear
    @map_id = 0
    @event_id = 0
    @message_waiting = false
    @move_route_waiting = false
    @move_route_wait_self = false
    @button_input_variable_id = 0
    @wait_count = 0
    @branch = {}
  end
  #--------------------------------------------------------------------------
  # * Clear Child Interpreters
  #--------------------------------------------------------------------------
  def clear_child_interpreters
    @child_interpreters.clear
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    @loop_count = 0
    @stop_loop = false
    loop do
      @loop_count += 1
      if @loop_count > 100
        Graphics.update
        @loop_count = 0
      end
      update_loop
      if @stop_loop == true
        return
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Loop
  #--------------------------------------------------------------------------
  def update_loop
    # Update Map
    if $game_map.map_id != @map_id
      @event_id = 0
    end
    # Update Child Interpreters
    update_child_interpreters
    return if @stop_loop == true
    # Update Message Waiting
    update_message_waiting
    return if @stop_loop == true
    # Update Route Waiting
    update_route_waiting
    return if @stop_loop == true
    # Update Input Button
    update_input_button
    return if @stop_loop == true
    # Update Wait Count
    update_wait_count
    return if @stop_loop == true
    # Update Battler Forcing
    if $game_temp.forcing_battler != nil
      return
    end
    # Update Game Temp Callers
    update_game_temp
    return if @stop_loop == true
    # Update List
    update_list
    return if @stop_loop == true
    # Next Command if available
    if execute_command == false
      @stop_loop = true
      return
    end
    @index += 1
  end
  #--------------------------------------------------------------------------
  # * Update Child Interpreters
  #--------------------------------------------------------------------------
  def update_child_interpreters
    if @common_event_waiting == true
      @stop_loop = true
      if !@child_interpreters.values.any? {|child| child != nil}
        @common_event_waiting = false
        return
      end
    end
    if @child_interpreters.values.any? {|child| child != nil}
      @child_interpreters.each_pair do |id, child|
        next if child == nil
        child.update
        unless child.running?
          @child_interpreters[id] = nil
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Update Message Waiting
  #--------------------------------------------------------------------------
  def update_message_waiting
    if @message_waiting
      @stop_loop = true
    end
  end
  #--------------------------------------------------------------------------
  # * Update Route Waiting
  #--------------------------------------------------------------------------
  def update_route_waiting
    if @move_route_wait_self
      event = $game_map.events[@event_id]
      if event.move_route_forcing
        @stop_loop = true
        return
      end
      @move_route_wait_self = false
    end
    if @move_route_waiting
      if $game_player.move_route_forcing
        return
      end
      for event in $game_map.events.values
        if event.move_route_forcing
          @stop_loop = true
          return
        end
      end
      @move_route_waiting = false
    end
  end
  #--------------------------------------------------------------------------
  # * Update Input Button
  #--------------------------------------------------------------------------
  def update_input_button
    if @button_input_variable_id > 0
      input_button
      @stop_loop = true
    end
  end
  #--------------------------------------------------------------------------
  # * Update Wait Count
  #--------------------------------------------------------------------------
  def update_wait_count
    if @wait_count > 0
      @wait_count -= 1
      @stop_loop = true
    end
  end
  #--------------------------------------------------------------------------
  # * Update Game Temp
  #--------------------------------------------------------------------------
  def update_game_temp
    if $game_temp.battle_calling or
      $game_temp.shop_calling or
      $game_temp.name_calling or
      $game_temp.menu_calling or
      $game_temp.save_calling or
      $game_temp.gameover
      @stop_loop = true
    end
  end
  #--------------------------------------------------------------------------
  # * Update List
  #--------------------------------------------------------------------------
  def update_list
    if @list == nil
      if @main
        setup_starting_event
      end
      if @list == nil
        @stop_loop = true
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Call Common Event
  #--------------------------------------------------------------------------
  def command_117
    call_common_event(@parameters[0])
    @common_event_waiting = true
    return true
  end
  #--------------------------------------------------------------------------
  # * Wait for Move's Completion
  #--------------------------------------------------------------------------
  def command_210
    unless $game_temp.in_battle
      if WAIT_SELF_MODE
        @move_route_wait_self = true
      else
        @move_route_waiting = true
      end
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Llamar a evento común definiendo el ID de Evento
  #--------------------------------------------------------------------------
  def call_common_event(common_event_id, event_id = @event_id)
    return if @child_interpreters[common_event_id] != nil
    common_event = $data_common_events[common_event_id]
    event = $game_map.events[event_id]
    if common_event != nil and event != nil
      interpreter = Interpreter.new(@depth + 1)
      interpreter.setup(common_event.list, event_id)
      interpreter.ancestor = self
      @child_interpreters[common_event_id] = interpreter
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Obtener evento actual. Equivale a usar get_character(0)
  #--------------------------------------------------------------------------
  def self_event
    $game_map.events[@event_id]
  end
  #--------------------------------------------------------------------------
  # * Esperar a finalizar movimiento
  #--------------------------------------------------------------------------
  def wait_move
    @move_route_waiting = true
  end
  #--------------------------------------------------------------------------
  # * Esperar a finalizar movimiento (versión interna)
  #--------------------------------------------------------------------------
  def wait_self_move
    @move_route_wait_self = true
  end
end

Créditos opcionales.
Nota: Es compatible con éste, que es conveniente usarlo siempre: Interpreter Script Call Fix
avatar
Wecoc
Administrador
Administrador



Créditos 12083

Gracias : 519

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.