Faire son menu en event

#===============================================================================
# *** EL : Menu
#-------------------------------------------------------------------------------
# Auteur  : 1.0
# Date    : 20/05/2008
#-------------------------------------------------------------------------------
# Cette commande Event Language permet à de remplacer le menu normal de RMXp par un
# menu gérer en event. Le système renvoit le joueur vers une map que vous choississez et
# qui vous  permet de gèrer votre menu en event
#===============================================================================

#===============================================================================
# ** EL : menu on (initialise la fonction menu)
# map "map_id"
# position x:"value" y:"value"
#===============================================================================
EventLanguage.add_command("menu on") { |args|
  map = args["map"].to_integer
  position = args["position"].to_category
  x = position["x"].to_integer
  y = position["y"].to_integer
  $game_temp.menu_on=true
  $game_temp.map_menu_id=map
  $game_temp.map_menu_x=x
  $game_temp.map_menu_y=y
}

#===============================================================================
# ** EL : menu off (désactive la fonction menu)
#===============================================================================
EventLanguage.add_command("menu off") { |args|
  $game_temp.menu_on=false
}

#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_Temp
  attr_accessor:save_player_x
  attr_accessor:save_player_y
  attr_accessor:save_player_map
  attr_accessor:save_player_map_id
  attr_accessor:menu_on
  attr_accessor:in_menu
  attr_accessor :map_calling
  attr_accessor :map_beep 
  attr_accessor :map_menu_id 
  attr_accessor :map_menu_x 
  attr_accessor :map_menu_y 
 
  alias alias_eventmenu_game_temp_initialize initialize
  def initialize
    alias_eventmenu_game_temp_initialize
    @save_player_x=0
    @save_player_y=0
    @save_player_map=0
    @save_player_map_id=0
    @in_menu=false
    @menu_on=false
    @map_calling=false
    @map_beep=false
    @map_menu_id=12
    @map_menu_x=0
    @map_menu_y=0
  end
end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs map screen processing.
#==============================================================================
class Scene_Map

  #--------------------------------------------------------------------------
  # * Menu Call
  #--------------------------------------------------------------------------
  def call_menu
    # Clear menu call flag
    $game_temp.menu_calling = false
    # If menu beep flag is set
    if $game_temp.menu_beep
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
      # Clear menu beep flag
      $game_temp.menu_beep = false
    end
    # Straighten player position
    $game_player.straighten
      if $game_temp.menu_on
      # Switch to menu screen
      if $game_temp.in_menu
        load_scene_map
      else
        save_scene_map
      end
    else
      $scene = Scene_Menu.new
    end
  end
 
  #--------------------------------------------------------------------------
  # * save_scene_map
  # Sauve les données pour retourner vers la partie
  #-------------------------------------------------------------------------- 
  def save_scene_map
    file = File.open("Menu", "wb")
    Marshal.dump($game_map, file)
    Marshal.dump($game_player, file)
    file.close
    $game_temp.player_new_map_id=$game_temp.map_menu_id
    $game_temp.player_new_x=$game_temp.map_menu_x
    $game_temp.player_new_y=$game_temp.map_menu_y
    $game_temp.save_player_x=$game_player.x
    $game_temp.save_player_y=$game_player.y
    $game_temp.save_player_map_id=$game_map.map_id
    transfer_player
    $game_temp.in_menu=true
  end
  #--------------------------------------------------------------------------
  # * load_scene_map
  # Recupère les données pour retourner vers la partie
  #-------------------------------------------------------------------------- 
  def load_scene_map
    $game_temp.player_new_map_id= $game_temp.save_player_map_id
    $game_temp.player_new_x= $game_temp.save_player_x
    $game_temp.player_new_y=$game_temp.save_player_y
    file = File.open("Menu", "r")
    $game_map= Marshal.load(file)
    $game_player= Marshal.load(file)
    file.close
    # Set up player position
    $game_player.moveto($game_temp.player_new_x, $game_temp.player_new_y)
    # Set player direction
    case $game_temp.player_new_direction
    when 2  # down
      $game_player.turn_down
    when 4  # left
      $game_player.turn_left
    when 6  # right
      $game_player.turn_right
    when 8  # up
      $game_player.turn_up
    end
    # Straighten player position
    $game_player.straighten
    # Update map (run parallel process event)
    $game_map.update
    # Remake sprite set
    @spriteset.dispose
    @spriteset = Spriteset_Map.new
    # If processing transition
    if $game_temp.transition_processing
      # Clear transition processing flag
      $game_temp.transition_processing = false
      # Execute transition
      Graphics.transition(20)
    end
    # Run automatic change for BGM and BGS set on the map
    $game_map.autoplay
    # Frame reset
    Graphics.frame_reset
    # Update input information
    Input.update
    $game_temp.in_menu=false
  end
end

#===============================================================================
# *** Event Language
#-------------------------------------------------------------------------------
# Auteur  : Åvygeil/Roys
# Version : 3.11
# Ajout de mots clés pour la transformation en entier afin de récupèrer les données
# de la base de données enemy
# Date    : 16/05/2008
#-------------------------------------------------------------------------------
# Ce script permet d'interpréter les scripts comme des commandes Event Language,
# et fournit les outils nécessaires à l'écriture des commandes.
#===============================================================================

#===============================================================================
# ** Interpreter
#===============================================================================
class Interpreter
 
  #=============================================================================
  # * eval
  #    script : le script à interpréter
  #-----------------------------------------------------------------------------
  # On modifie la méthode eval au sein de la classe Interpreter afin de pouvoir
  # interpréter les scripts Event Language.
  #=============================================================================
  alias el_eval eval
  def eval(script)
    if script =~ /^<el>/
      list = script.split("\n")
      EventLanguage.event_id = @event_id
      command_name = list[0].gsub("<el>", "").strip
      command = EventLanguage.commands[command_name]
      event = if @main
                $game_map.events[@event_id]
              else
                $data_common_events[@event_id]
              end
      args = {}
      for i in 1...list.size
        list[i] =~ /^\w+/
        args[$&] = ELObject.new($'.strip)
      end
      return command.call(args)
    else
      return el_eval(script)
    end
  end
 
  #=============================================================================
  # * command_355
  #-----------------------------------------------------------------------------
  # Correction de bug.
  #=============================================================================
  alias el_command_355 command_355
  def command_355
    el_command_355
    return true
  end
   
end

#===============================================================================
# ** EventLanguage
#-------------------------------------------------------------------------------
# Le module qui contient de quoi créer et stocker les commandes Event Language.
#===============================================================================
module EventLanguage
 
  class << self
   
    attr_reader :commands
    attr_accessor :event_id
    attr_accessor :last_condition
   
    #===========================================================================
    # * EventLanguage.add_command
    #    command_name  : nom de la nouvelle commande
    #    &block        : un bloc qui indique l'effet de la commande
    #---------------------------------------------------------------------------
    # Méthode de création de nouvelles commandes.
    #===========================================================================
    def add_command(command_name, &block)
      @commands ||= {}
      @commands[command_name.strip] = Proc.new { |args|
        block.call(args)
      }
    end
   
    #===========================================================================
    # * EventLanguage.add_condition
    #    command_name  : nom de la nouvelle commande
    #    &block        : un bloc qui indique l'effet de la commande
    #---------------------------------------------------------------------------
    # Méthode de création de nouvelles conditions.
    #===========================================================================
    def add_condition(command_name, &block)
      @commands ||= {}
      @commands[command_name.strip] = Proc.new { |args|
        EventLanguage.last_condition = block.call(args)
      }
    end
   
    #===========================================================================
    # * EventLanguage.optional
    #    *args  : liste des arguments optionels dépendant entre eux
    #    &block  : action à effectuer si tous les arguments sont donnés
    #---------------------------------------------------------------------------
    # Support pour les arguments optionels.
    #===========================================================================
    def optional(*args, &block)
      for arg in args
        return if arg == nil
      end
      block.call
    end
 
  end
 
  #-----------------------------------------------------------------------------
  # On ajoute la commande de base "last condition"
  # utilisable dans les conditions.
  #-----------------------------------------------------------------------------
  add_command("last condition") { |args|
    EventLanguage.last_condition
  }
 
end

#===============================================================================
# ** Game_Event
#===============================================================================
class Game_Event < Game_Character
 
  #=============================================================================
  # * name
  #-----------------------------------------------------------------------------
  # Renvoie le nom de l'event.
  #=============================================================================
  def name
    @event.name
  end
 
end

#===============================================================================
# ** ELObject
#-------------------------------------------------------------------------------
# Cette classe représentente les objets génériques Event Language.
# Elle possède des méthodes qui permettent de transformer ces objets génériques
# en objet plus spécifique.
#===============================================================================
class ELObject
 
  #=============================================================================
  # * initialize
  #    expr  : la représentation sous forme de String de l'objet EL
  #-----------------------------------------------------------------------------
  # Construit un objet EL de représentation expr.
  #=============================================================================
  def initialize(expr)
    @expr = expr
  end
 
  #=============================================================================
  # * to_integer
  #-----------------------------------------------------------------------------
  # \V[n] => $game_variables[n.to_int]
  # n    => n.to_i
  # \hp[n]=> Hpmax de l'enemy n
  # \sp[n]=> Spmax de l'enemy n
  # \str[n]=> force de l'enemy n
  # \dex[n]=> dexterité de l'enemy n
  # \agi[n]=> agilité de l'enemy n
  # \atk[n]=> attaque de l'enemy n
  # \pdef[n]=> valeur defensive physique de l'enemy n
  # \mdef[n]=> valeur defensive magique de l'enemy n
  # \eva[n]=> evasion de l'enemy n
  #=============================================================================
  def to_integer
    # Get data from variables
    if @expr =~ /\\[Vv]\[([0-9]+)\]/
      expr = @expr.gsub!(/\\[Vv]\[([0-9]+)\]/) { $game_variables[$1.to_i] }
      return ELObject.new(expr).to_integer
    end
    # Get data from Database/Enemy
    if @expr =~ /\\hp\[([0-9]+)\]/
      expr = @expr.gsub!(/\\hp\[([0-9]+)\]/) {return $data_enemies[$1.to_i].maxhp}
    end
    if @expr =~ /\\sp\[([0-9]+)\]/
      expr = @expr.gsub!(/\\sp\[([0-9]+)\]/) {return $data_enemies[$1.to_i].maxsp}
    end
    if @expr =~ /\\str\[([0-9]+)\]/
      expr = @expr.gsub!(/\\str\[([0-9]+)\]/) {return $data_enemies[$1.to_i].str}
    end
    if @expr =~ /\\dex\[([0-9]+)\]/
      expr = @expr.gsub!(/\\dex\[([0-9]+)\]/) {return $data_enemies[$1.to_i].dex}
    end
    if @expr =~ /\\agi\[([0-9]+)\]/
      expr = @expr.gsub!(/\\agi\[([0-9]+)\]/) {return $data_enemies[$1.to_i].agi}
    end
    if @expr =~ /\\int\[([0-9]+)\]/
      expr = @expr.gsub!(/\\int\[([0-9]+)\]/) {return $data_enemies[$1.to_i].int}
    end
    if @expr =~ /\\atk\[([0-9]+)\]/
      expr = @expr.gsub!(/\\atk\[([0-9]+)\]/) {return $data_enemies[$1.to_i].atk}
    end
    if @expr =~ /\\pdef\[([0-9]+)\]/
      expr = @expr.gsub!(/\\pdf\[([0-9]+)\]/) {return $data_enemies[$1.to_i].pdef}
    end
    if @expr =~ /\\mdef\[([0-9]+)\]/
      expr = @expr.gsub!(/\\mdef\[([0-9]+)\]/) {return $data_enemies[$1.to_i].mdef}
    end
    if @expr =~ /\\eva\[([0-9]+)\]/
      expr = @expr.gsub!(/\\eva\[([0-9]+)\]/) {return $data_enemies[$1.to_i].eva}
    end
    return eval(@expr).to_i
  end
 
  #=============================================================================
  # * to_string
  #-----------------------------------------------------------------------------
  # \V[n] => $game_variables[n.to_string]
  # \N[n] => $game_actors[n.to_string].name
  # n    => n.to_s
  #=============================================================================
  def to_string
    if @expr =~ /\\[Vv]\[([0-9]+)\]/
      expr = @expr.gsub!(/\\[Vv]\[([0-9]+)\]/) { $game_variables[$1.to_i] }
      return ELObject.new(expr).to_string
    end
    if @expr =~ /\\[Nn]\[([0-9]+)\]/
      expr = @expr.gsub!(/\\[Nn]\[([0-9]+)\]/) {
        $game_actors[$1.to_i] != nil ? $game_actors[$1.to_i].name : ""
      }
      return ELObject.new(expr).to_string
    end
    return eval(@expr).to_s
  end
 
  #=============================================================================
  # * to_category
  #-----------------------------------------------------------------------------
  # Retoune un hash représentant une catégorie d'arguments.
  #=============================================================================
  def to_category
    ret = {}
    args = @expr.scan(/\w+:\"[\w\s:\\\[\]]+\"/)
    for arg in args
      arg =~ /:/
      ret[$`] = ELObject.new($')
    end
    return ret
  end
 
  #=============================================================================
  # * to_character
  #-----------------------------------------------------------------------------
  # player            => le joueur
  # self              => l'event courant
  # any:event        => tous les events de la map
  # any:character    => tous les events de la map et le joueur
  # event_id:"id"    => l'event d'id "id"
  # event_name:"name" => l'event de nom "name"
  #=============================================================================
  def to_character
    case @expr
    when "\"self\""
      return $game_map.events[EventLanguage.event_id]
    when "\"player\""
      return $game_player
    when "\"any:event\""
      return $game_map.events.values
    when "\"any:character\""
      return ($game_map.events.values+[$game_player])
    else
      expr = @expr[1...@expr.size-1].split(":")
      if expr[0] == "event_id"
        return $game_map.events[ELObject.new(expr[1]).to_integer]
      end
      if expr[0] == "event_name"
        return $game_map.events.values.find { |event|
          event.name == ELObject.new(expr[1]).to_string
        }
      end
    end
  end
  #=============================================================================
  # * to_boolean
  #-----------------------------------------------------------------------------
  # Renvoi un boolean a partir d'une string/integer
  # true si expr = "true" ou 1, false sinon
  # \V[n] => renvoi true si $game_variables[n]==1
  #=============================================================================
  def to_boolean
    if @expr =~ /\\[Vv]\[([0-9]+)\]/
      expr = @expr.gsub!(/\\[Vv]\[([0-9]+)\]/) { $game_variables[$1.to_i] }
      return expr==1
    end
    expr=@expr.to_s.upcase
    return (expr=="TRUE" or expr=="1")
  end 
end