#==============================================================================#
#                                                                              #
#                                                                              #
#                              Light Effects VX 1.2                            #
#                                                                              #
#                                                                              #
#==============================================================================#
#Original par Kylock                                                          #
#revu par Vincentmhd                                                                    #
#http://vincentmhdmaker.canalblog.com/                                        #
#10/8/2010                                                                    #
#                                                                              #
#                                                                              #
#-------------------------------------NOTE-------------------------------------#
#                                                                              #
#  Ce script est une extention de celui de Kylock.                            #
#Il permet de placer des effets lumineux à partir d'une image et de commentaire#
#                                                                              #
#Il nécéssite une image  "le.png"                                              #
#                                                                              #
#                                                                              #
#                                                                              #
#--------------------------------EFFET LUMINEUX--------------------------------#
#                                                                              #
#Utilisation:                                                                  #
#                                                                              #
#Tout d'abord il existe plein de synthaxes possible donc je ne vais pas toutes les expliquer
#                                                                              #
#Le minimum, c'est le TYPE de lumière à savoir:                                #
#LIGHT    :Lumière blanche toute simple                                      #
#DARKNESS  :Ombre                                                              #
#FIRE      :Lumière vibrante                                                  #
#TORCH    :Lumière vibrante 2                                                #
#                                                                              #
#J'ai conservé les types de Kylock                                            #
#Juste le type dans un commentaire fonctione mais ce n'est pas l'intérêt du script.
#                                                                              #
#                                                                              #
#Il existe 4 paramètres sur lesquels la lumière peut varier:                  #
#Les proportions, la position, la teinte et l'état (allumée ou éteinte).      #
#Pour écrire les paramètres, voilà la synthaxe complète:                      #
#                                                                              #
#TYPE:[SIZE,COORDONNEES,TONE,STATE]                                            #
#exemple:  LIGHT:[64,5,ROUGE,false]                                            #
#dans l'exemple la lumière sera de 64 sur 64, centrée sur l'event 5, de couleur#
#rouge et éteinte à l'arrivée sur la map.                                      #
#                                                                              #
#ATTENTION pas d'espace, n'oubliez pas les : et []                            #
#                                                                              #
#Voyons les paramètres:                                                        #
#                                                                              #
#  - les proportions:                                                        #
#L'image de base reste la même mais ses proportions peuvent être modifiées en  #
#carré  ou en rectangle. En carré, un nombre suffit le script comprendra qu'il #
#s'agit d'un carrée. En rectangle, un tableau de nombre permet  de définir    #
#la largeur et la hauteur de l'effet: [a,b]                                    #
#ATTENTION pas d'espace...                                                    #
#                                                                              #
#  - Les coordonnées                                                          #
#Les coordonnées peuvent être de 3 natures:                                    #
#  + un tableau de 2 nombres [a,b]                                            #
#    => Elles indiqueront une position fixe sur la map.                        #
#  + un nombre                                                                #
#    => Il correspondra à l'id d'un event auquel il sera fixé.                #
#  + une chaine avec P au début P...                                          #
#    => Il permet d'attribuer un effet sur le player.                          #
#    Attention l'effet ne sera dispo que sur la map de l'event créateur.      #
#                                                                              #
#  - Le ton de l'image                                                        #
#Il peut être un mot-clé, correspondant à un ton dans le hash ligne 1321      #
#ou un tableau à 4 composantes: [r,b,g,a].                                    #
#                                                                              #
#  - L'état                                                                  #
#Ca peut paraitre étrange mais pour s'allumer ou s'éteindre un effet doit      #
#exister. Donc il se peut que vous ayez à déclarer des effets éteints pour    #
#pouvoir les allumer après.                                                    #
#                                                                              #
#                                                                              #
#Un mot sur l'ordre des paramètres:                                            #
#                                                                              #
#le ton et l'état peuvent être mis n'importe où.                              #
#Parcontre, les proportions doivent toujours être avant les coordonnées et    #
#si vous déclarez des coordonnées il faudra déclarer des proportions avant.    #
#Il existe une seule exception, si la coordonnée est une chaine pour le player.#
#                                                                              #
#Autre:                                                                        #
#Les effets sont répertoriés dans un hash dont les keys correspondent aux      #
#coordonnées des effets. Cela implique qu'un event ne peut avoir q'un effet qui#
#le suit, qu'une position fixe idem. Le player parcontre peut en avoir autant  #
#que voulu.                                                                    #
#                                                                              #
#Comment allumer ou éteindre une lumière:                                      #
#Il faut utiliser ces appels:                                                  #
#$game_light.map[COORDONNEES].on                                              #
#$game_light.map[COORDONNEES].off                                              #
#Ces transformations sont oubliées si vous changez de map.                    #
#Utilisez les pages et les interrupteurs locaux pour les rendre permanentes.  #
#                                                                              #
#$game_light.map_on                                                            #
#$game_light.map_off                                                          #
#Allume ou éteint toutes les lumières dépendantes de la map.                  #
#                                                                              #
#Vous pouvez redimensionner les lumières.                                      #
#$game_light.map[COORDONNEES].resize(SIZE [,frame])                            #
#                                                                              #
#                                                                              #
#------------------------------MAP SOMBRE ET GROTTE----------------------------#
#                                                                              #
#  Il est possible d'habiller l'écran d'un voile noir qui se révèle par        #
#compensation avec les effets lumineux. Ce voile peut être plus ou moins opaque#
#Les maps à voiler se trouvent ds un tableau DARK_MAP, ligne 214 il regroupe les
#identifiants des maps avec l'opacité correspondante.                          #
#                                                                              #
#Détail, les opacités des effets sont alignées sur cette opacity afin d'adapter#
#la compensation.                                                              #
#                                                                              #
#                                                                              #
#                                                                              #
#----------------------------------Influence des tons--------------------------#
#                                                                              #
#A vrai dire, je ne sais pas vraiment ce qui est le mieux. Un interrupteur    #
#permet d'aligner ou non le tone du viewport des effets sur celui de la map.  #
#                                                                              #
# TONE_INFLUENCE                                                              #
#                                                                              #
#Ligne 217                                                                    #
#                                                                              #
#------------------------Petit mot pour ceux qui en veulent plus---------------#
#                                                                              #
#  Dans le script tel quel il n'y a qu'une image de base, afin de limiter les  #
#dépence aux fichiers. Il est possible d'ajouter d'autres formes de base en    #
#ajoutant d'autre type d'effet.                                                #
#                                                                              #
#Cependant cela demande quelques connaissance en script mais ce n'est pas      #
#compliqué.                                                                    #
#                                                                              #
#Allez à la ligne 529                                                          #
#Vous voyez :                                                                  #
#                                                                              #
#if ["LIGHT","DARKNESS","TORCH","FIRE"].include?(key)                          #
#                                                                              #
#Ajoutez le nom de votre type personalisé dans le array comme les autres types.#
#(c'est pour que le script reconnaisse le commentaire)                        #
#                                                                              #
#if ["LIGHT","DARKNESS","TORCH","FIRE","MON_TRUC_PERSO"].include?(key)        #
#                                                                              #
#                                                                              #
#Allez à la ligne 689                                                          #
#Vous voyez:                                                                  #
#                                                                              # 
# def draw                                                                    #
#  case @light_type                                                          #
#    when "LIGHT"                                                            #
#      @light.bitmap = Cache.picture("le.png")                                #
#      @light.origine?("Centre")                                              #
#      @light.blend_type = 1                                                  #
#      @type_op  = 125                                                        #
#    when "TORCH"                                                            #
#      @light.bitmap = Cache.picture("le.png")                                #
#      @light.origine?("Centre")                                              #
#      @light.blend_type = 1                                                  #
#      @type_op  = 125                                                        #
#      @tremble  = [10,10]                                                    #
#    when "FIRE"                                                              #
#      @light.bitmap = Cache.picture("le.png")                                #
#      @light.origine?("Centre")                                              #
#      @light.blend_type = 1                                                  #
#      @type_op  = 125                                                        #
#      @tremble  = [3,3]                                                      #
#    when "DARKNESS"                                                          #
#      @light.bitmap = Cache.picture("le.png")                                #
#      @light.origine?("Centre")                                              #
#      @light.blend_type = 2                                                  #
#      @type_op  = 125                                                        #
#    else                                                                    #
#  end                                                                        #
# end                                                                          #
#                                                                              #
#Pas de panique, c'est relativement simple.                                    #
#Bon il y les 4 types de base avec leurs paramètres inérants. Décrivons-les.  #
#                                                                              #
#                                                                              #
#    when "FIRE"                                                              #
#    *Identifie le type de l'effet à faire. il faudra mettre un when "MON_TRUC_PERSO"
#    avant le else*                                                            #
#      @light.bitmap = Cache.picture("le.png")                                #
#    *Quelle image attribuer à votre effet*                                    #
#      @light.origine?("Centre")                                              #
#    *Comment centrer l'image (méthode perso à mot clé voir plus bas Sprite +)*#
#      @light.blend_type = 1                                                  #
#    *Comment intégrer l'image par addition 1 par soustraction 2  (0 n'est pas utile ici)
#      @type_op  = 125                                                        #
#    *Quelle est l'opacité de base de cet effet*                              #
#      @tremble  = [3,3]                                                      #
#    *Si l'effet tremble à quelle puisance.                                    #
#                                                                              #
#                                                                              #
#Pour ajouter votre effet, il suffit d'ajouter un when "MON_TRUC_PERSO" avant  #
#le else et de prendre modèle sur les autres types                            #
#                                                                              #
#Bon je crois que j'ai fait le tour...                                        #
#                                                                              #
#==============================================================================#






#==============================================================================#
#                                                                              #
#                        Gestionnaire des effets lumineux                    #
#                                                                              #
#==============================================================================#
class Gst_light
  #Variables globales
  DARK_MAP = {2 => 125,
              3 => 225,
              12=> 175 }
  TONE_INFLUENCE = false
 
  attr_accessor :map, :eq, :comp
#------------------------------------------------------------------------------#
#  Initialisation                                                              #
#------------------------------------------------------------------------------#
  def initialize
    vp_create
    @map = {}
    @eq    = {}
    @comp  = {}
  end

#==============================================================================#
#                        Ensemble des méthodes de créations                    #
#==============================================================================#
  def create
    create_darkness
  end
#------------------------------------------------------------------------------#
#  Création du viewport                                                        #
#------------------------------------------------------------------------------# 
  def vp_create
    @viewport  = Viewport.new(0,0,Graphics.width, Graphics.height)
    @viewport.z = 1
  end
#------------------------------------------------------------------------------#
#  Renvois le viewport                                                        #
#------------------------------------------------------------------------------#   
  def viewport
    return @viewport
  end
#------------------------------------------------------------------------------#
#  Création de la sprite de l'ombre.                                          #
#------------------------------------------------------------------------------# 
  def create_darkness
    if dark_map?()
      if (@dark.nil?)||(@dark.disposed?)
        @dark            = Sprite.new(@viewport)
        @dark.z          = 1000
        @dark.bitmap    = Bitmap.new(2*Graphics.width, 2*Graphics.height)
        @dark.bitmap.remplir(Color.new(255,255,255,255))
        @dark.origine?("Centre")
        @dark.coord?("Centre")
        @dark.blend_type = 2
        @dark.visible = false
      end
      @dark.opacity    = DARK_MAP[$game_map.map_id]
    else
      if (!@dark.nil?)&&(!@dark.disposed?)
        @dark.opacity    = 0
      end
    end
    #met à jour les opacités en fonction
    for light in @map.values
      light.refresh_op
    end
  end
#------------------------------------------------------------------------------#
#  Création de la sprite de l'ombre.                                          #
#------------------------------------------------------------------------------# 
  def create_from_event(type,param,id_event)
    light = Light.new
    light.create_from_event(type,param,id_event)
    @map[light.key] = light
  end
#==============================================================================#
#                            Méthodes de l'Ombre.                            #
#==============================================================================#
  def dark_map?(id = $game_map.map_id)
    return DARK_MAP.has_key?(id)
  end
 
  def dark_opacity
    if (!@dark.nil?)&&(!@dark.disposed?)
      return @dark.opacity
    else
      return 0
    end
  end

#==============================================================================#
#                        Ensemble des méthodes de monstration.                #
#==============================================================================# 
  def show
    show_darkness
    show_map
  end
 
  def hide
    hide_darkness
    hide_map
  end
#------------------------------------------------------------------------------#
#  Monstration de l'ombre.                                                    #
#------------------------------------------------------------------------------#
  def show_darkness
    if dark_map?()||(!@dark.nil?)
      if (!@dark.disposed?)
        @dark.visible = true
      end
    end
  end
 
  def hide_darkness
    if dark_map?()||(!@dark.nil?)
      if(!@dark.disposed?)
      @dark.visible = false
      end
    end
  end
#------------------------------------------------------------------------------#
#  Monstration des effets ce la map.                                          #
#------------------------------------------------------------------------------#
 
  def show_map
    for light in @map.values
      light.show
    end
  end
 
  def hide_map
    for light in @map.values
      light.hide
    end
  end

#==============================================================================#
#                        Ensemble des méthodes de mise à jour.                #
#==============================================================================#
  def update
    vp_update
    update_darkness
    update_map
  end
 
#------------------------------------------------------------------------------#
#  Mise à jour du viewport.                                                    #
#------------------------------------------------------------------------------# 
  def vp_update
    if TONE_INFLUENCE
      @viewport.tone = $game_map.screen.tone 
    end
    @viewport.ox = $game_map.screen.shake
    @viewport.update
  end
#------------------------------------------------------------------------------#
#  Mise à jour de l'ombre.                                                    #
#------------------------------------------------------------------------------#
  def update_darkness
    if dark_map?()
      if (@dark.nil?||@dark.disposed?)
        create_darkness
      end
      @dark.update
    end
  end
#------------------------------------------------------------------------------#
#  Mise à jour des lumières                                                    #
#------------------------------------------------------------------------------#
  def update_map
    for light in @map.values
      light.update
    end
  end
 
#------------------------------------------------------------------------------#
#  Tout éteindre la map.                                                      #
#------------------------------------------------------------------------------#
  def map_off
    for light in @map.values
      light.off
    end
  end
 

#------------------------------------------------------------------------------#
#  Tout allumer de la map.                                                    #
#------------------------------------------------------------------------------#
  def map_on
    for light in @map.values
      light.on
    end
  end
 
#==============================================================================#
#                        Ensemble des méthodes de destruction.                #
#==============================================================================#
  def dispose
    dispose_darkness
  end
 
#------------------------------------------------------------------------------#
#  Destruction du viewport                                                    #
#------------------------------------------------------------------------------# 
  def vp_dispose
    @viewport.dispose
  end
#------------------------------------------------------------------------------#
#  Destruction de l'ombre.                                                    #
#------------------------------------------------------------------------------#
  def dispose_darkness
    if dark_map?()
      @dark.dispose
    end
  end
#------------------------------------------------------------------------------#
#  Destruction de l'ombre.                                                    #
#------------------------------------------------------------------------------#
  def clear_map
    for light in @map.values
      light.dispose
    end
    @map.clear
  end
 
end



#==============================================================================#
#                                                                              #
#                    Alias de la classe des images de Maps                    #
#                                                                              #
#==============================================================================#
class Spriteset_Map
 
  #Alias nécessaires
  alias light_initalize initialize
  alias light_dispose dispose
  alias light_update update
 
#------------------------------------------------------------------------------#
#  Initialisation                                                              #
#------------------------------------------------------------------------------#
  def initialize
    light_initalize
    $game_light.create
    $game_light.show
  end
 
 
#------------------------------------------------------------------------------#
#  Update                                                                      #
#------------------------------------------------------------------------------#
  def update
    light_update
    $game_light.update
  end 
 
#------------------------------------------------------------------------------#
#  Dispose                                                                    #
#------------------------------------------------------------------------------#
  def dispose
    light_dispose
    $game_light.dispose
    $game_light.hide
  end
 
end 
 

#==============================================================================#
#                                                                              #
#                        Création du gestionnaire                            #
#                                                                              #
#==============================================================================#
class Scene_Title
  alias light_create_game_objects create_game_objects
  def create_game_objects
    light_create_game_objects
    $game_light = Gst_light.new
  end
end


#==============================================================================#
#                                                                              #
#                  Mise à jour du Gestionnaire à la Map                      #
#                                                                              #
#==============================================================================#
class Game_Map
 
  alias mhd_light_setup_events setup_events
  def setup_events
    mhd_light_setup_events
    self.Mhd_setup
  end
 
  def Mhd_setup
    for event in $game_map.events.values
      next if event.list == nil
      for i in 0...event.list.size
        if event.list[i].code == 108
          commentaire = ""
          commentaire = event.list[i].parameters.to_s
          info = Commentaire.analyse(commentaire)
          self.Analyse_Com(info[0], info[1], event)
        end   
      end
    end
  end
 
  if !defined?(Analyse_Com(key, param, event))
    def Analyse_Com(key, param, event)
    end
  end
 
 
  alias light_Analyse_Com Analyse_Com
  alias light_setup_events setup_events
   
  def Analyse_Com(key, param, event)
    light_Analyse_Com(key,param, event)
    if ["LIGHT","DARKNESS","TORCH","FIRE"].include?(key)
      $game_light.create_from_event(key,param, event.id)
    end
  end
   
  def setup_events
    $game_light.clear_map
    light_setup_events
  end
 
end

#==============================================================================#
#                                                                              #
#                            Classe d'un effet lumineux                        #
#                                                                              #
#==============================================================================#
class Light
 
#------------------------------------------------------------------------------#
#  Initialisation                                                            #
#------------------------------------------------------------------------------#
  def initialize()
   
    @light = Sprite.new($game_light.viewport)
   
    @light_type = nil
    @coord_type = nil
    @light.visible = false
   
    @op_count = 0
    @size_count = 0
    @active = true
    @id
  end
 
 
#------------------------------------------------------------------------------#
#  Ce qui permet de l'identifier                                              #
#------------------------------------------------------------------------------#
  def key
    return @coord
  end
 
#==============================================================================#
#                          Méthodes d'action.                                  #
#==============================================================================#
#------------------------------------------------------------------------------#
#  Allume la lumière.                                                        #
#------------------------------------------------------------------------------# 
  def on
    @state = true
    op_change(@type_op)
  end
#------------------------------------------------------------------------------#
#  Eteint la lumière.                                                        #
#------------------------------------------------------------------------------#
  def off
    @state = false
    op_change(0)
  end
 
#==============================================================================#
#                        Ensemble des méthodes d'opacité.                      #
#==============================================================================#
  def op_change (op , duration = 60)
    @op_count = duration
    @target_op = op
    if @op_count == 0
      @light.opacity = op
    end
  end
#------------------------------------------------------------------------------#
#  Eteint la lumière.                                                        #
#------------------------------------------------------------------------------#
  def align_op
    coef = 1 - (($game_light.dark_opacity.to_f)*0.5)/ 255.0
    @type_op = (@type_op.to_f * (coef)).to_i
  end
 
   
#------------------------------------------------------------------------------#
#  Redimensionnement de l'image                                              #
#------------------------------------------------------------------------------#
  def resize(a, count = 60)
   
    if (a.is_a?(Array)) && (a.size == 2)
      @size_target = [a[0].to_i, a[1].to_i]
      
    elsif (a.is_a?(Array)) && (a.size == 1)
      @size_target=[a[0].to_i, a[0].to_i]
      
    elsif a.is_a?(Integer)
      @size_target=[a.to_i, a.to_i]
    end
    @size_count = count
  end
 
#==============================================================================#
#                        Ensemble des méthodes de création.                    #
#==============================================================================#
#------------------------------------------------------------------------------#
#  Création par event                                                        #
#------------------------------------------------------------------------------#
  def create_from_event(type, param, id_event)
    info = Commentaire.decompose(param)
    create_light(type)
    info = check_state(info)
    info = create_tone(info)

    if !info.nil?
      if (info.is_a?(Array))&&(info.size > 1)
        create_size(info[0])
        create_coord(info[1],id_event)
      else
        create_size(info)
        create_coord([],id_event)      
      end
    else
      create_size([])
      create_coord([],id_event)
    end
   
    if @coord.is_a?(Array)
      @coord_type = "Fixe"
    elsif @coord.is_a?(Integer)
      @coord_type = "Event"
    elsif @coord.is_a?(String)
      @coord_type = "Player"
    end
  end

#------------------------------------------------------------------------------#
#  Création par équipement                                                    #
#------------------------------------------------------------------------------#
  def create_from_eq(type, param, id_eq)
  end

#------------------------------------------------------------------------------#
#  Création par compétence                                                    #
#------------------------------------------------------------------------------#
  def create_from_comp(type, param, id_comp)
  end
 
#==============================================================================#
#                    Ensemble des sous-méthodes de création.                  #
#==============================================================================#
#------------------------------------------------------------------------------#
#  Création de la lumière.                                                    #
#------------------------------------------------------------------------------#
  def create_light(type)
    @light_type = type
    draw
    align_op
    draw_op
  end
 
  def draw
    case @light_type
      when "LIGHT"
        @light.bitmap = Cache.picture("le.png")
        @light.origine?("Centre")
        @light.blend_type = 1
        @type_op  = 125
        @light.z = $game_light.map.size()
      when "TORCH"
        @light.bitmap = Cache.picture("le.png")
        @light.origine?("Centre")
        @light.blend_type = 1
        @type_op  = 125
        @tremble  = [10,10]
        @light.z = $game_light.map.size()
      when "FIRE"
        @light.bitmap = Cache.picture("le.png")
        @light.origine?("Centre")
        @light.blend_type = 1
        @type_op  = 125
        @light.z = $game_light.map.size()
        @tremble  = [3,3]
      when "DARKNESS"
        @light.bitmap = Cache.picture("le.png")
        @light.origine?("Centre")
        @light.blend_type = 2
        @type_op  = 125
        @light.z =  $game_light.map.size() -1000
        #pour les Ténèbres s'annulent à la lumière il faut qu'ils soient sous
        #la lumière.
      else
    end
  end
 
  def draw_op
    @target_op = @type_op
    @light.opacity = @type_op
  end
#------------------------------------------------------------------------------#
#  Création de la taille de l'image (zoom)                                    #
#------------------------------------------------------------------------------#
  def create_size(info)
    a = Commentaire.decompose(Commentaire.decompose(info))
    @size = 64
   
    if (a.is_a?(Array)) && (a.size == 2)
      @size = [a[0].to_i, a[1].to_i]
      
    elsif (a.is_a?(Array)) && (a.size == 1)
      @size=[a[0].to_i, a[0].to_i]
      
    elsif a.is_a?(String)
      if a[0,1] == 'P'
        @coord = a  #si le makeur oubli...
      else
        @size=[a.to_i, a.to_i]
      end
    end
    @light.zoom_resize(@size[0],@size[1])
    @size_target = @size
  end
 

 
#------------------------------------------------------------------------------#
#  Création de le ton de l'image (fonctionne par mots-clés et par arrays)    #
#------------------------------------------------------------------------------#
  def create_tone(param)
       
    if ( ! param.nil? )
      
      if  (param.is_a?(Array))
        for i in 0...param.size
          a = Commentaire.tone?(Commentaire.decompose(param[i]))
          if !(a.nil?)
            @light.tone = a
            param.delete_at(i)
          end
        end
      
        elsif (param.is_a?(String))
        a = Commentaire.tone?(param)
        if !(a.nil?)
          @light.tone = a
          param = nil
        end
      end
      
    end
    return param
   
   
   
  end
#------------------------------------------------------------------------------#
#  Création des Coordonnées de l'image                                        #
#------------------------------------------------------------------------------#
  def create_coord(info, id)
    if @coord.nil?
      a = Commentaire.decompose(Commentaire.decompose(info))
   
      if (a.is_a?(Array))&&(a.size == 2)
        @coord = [a[0].to_i, a[1].to_i]
      elsif (a.is_a?(Array))&&(a.size == 1)
        @coord = a[0].to_i
      elsif a.is_a?(String)
        if a[0,1] == 'P'
          @coord = a
        else
          @coord = a.to_i
        end
      else
        @coord = id
      end
    end
  end
#------------------------------------------------------------------------------#
#  Initialisation de l'état de l'éclairage.                                  #
#------------------------------------------------------------------------------#
  def check_state(param)
   
    if !param.nil?
      
      if param.is_a?(Array)
        for i in 0...param.size
          if param[i] == "false"
            @state = false
            @target_op = 0
            @light.opacity = 0
            param.delete_at(i)
          end
        end
       
      elsif param.is_a?(String)
        if param == "false"
          @state = false
          @target_op = 0
          @light.opacity = 0
          param = nil
        end
      end
    end
   
    if @state.nil?
      @state = true
    end
   
    return param
  end
 
#==============================================================================#
#                        Ensemble des méthodes de mise à jour.                #
#==============================================================================#
  def update
    if @active
      @light.update
      op_update
      size_update
      place
    end
  end
 
#------------------------------------------------------------------------------#
#  Mise à jour de l'opacité en changement.                                    #
#------------------------------------------------------------------------------#
  def op_update
    if @op_count>0
      d = @op_count
      @light.opacity = (@light.opacity * (d - 1) + @target_op) / d      
      @op_count -=1
    end
  end
 
#------------------------------------------------------------------------------#
#  Mise à jour de l'opacité en changement.                                    #
#------------------------------------------------------------------------------#
  def size_update
    if @size_count >0
      d = @size_count
      @size[0] = (@size[0] * (d - 1) + @size_target[0]) / d
      @size[1] = (@size[1] * (d - 1) + @size_target[1]) / d
      @light.zoom_resize(@size[0],@size[1])   
      @size_count -=1
    end
  end
 
#------------------------------------------------------------------------------#
#  Mise à jour de la position.                                                #
#------------------------------------------------------------------------------#
  def place
    if !(@light.opacity == 0)
      case @coord_type
        when "Fixe"
          @light.x = (((@coord[0]* 256)  - ($game_map.display_x))/8 + 16).round
          @light.y = (((@coord[1]* 256)  - ($game_map.display_y))/8 + 16).round
        when "Event"
          @light.x = ((($game_map.events[@coord].real_x)  - ($game_map.display_x))/8 + 16).round
          @light.y = ((($game_map.events[@coord].real_y)  - ($game_map.display_y))/8 + 16).round
        when "Player"
          @light.x = ((($game_player.real_x)  - ($game_map.display_x))/8 + 16).round
          @light.y = ((($game_player.real_y)  - ($game_map.display_y))/8 + 16).round
        else
      end
       
      
      if !(@tremble.nil?)
        @light.x += rand(2*@tremble[0]) - @tremble[0]
        @light.y += rand(2*@tremble[1]) - @tremble[1]
      end
    end 
  end
 
#------------------------------------------------------------------------------#
#  Rendre la lumière visible                                                  #
#------------------------------------------------------------------------------#
  def show
    @light.visible = true
    @active = true
  end
 
#------------------------------------------------------------------------------#
#  Rendre la lumière invisible                                                #
#------------------------------------------------------------------------------#
  def hide
    @light.visible = false
    @active = false
  end
#==============================================================================#
#                          Méthodes de refresh                                #
#==============================================================================#
  def refresh_op
    draw
    align_op
    draw_op
    if !(@state)
      @target_op = 0
      @light.opacity = 0
    end
  end
   
#==============================================================================#
#                        Ensemble des méthodes de destrution.                  #
#==============================================================================#
  def dispose
    @light.dispose
  end
end

#==============================================================================#
#                                                                              #
#                                                                              #
#                            AUTO-TELEPORT                                    #
#                                                                              #
#                                                                              #
#==============================================================================#
#                                                                              #
#Vincentmhd                                                                    #
#http://vincentmhdmaker.canalblog.com/                                        #
#10/2/2010                                                                    #
#                                                                              #
#                                                                              #
#-------------------------------------NOTE-------------------------------------#
#                                                                              #
#  Ce script permet d'ordonner les cartes les une par rapport aux autres.    #
#De créer les liens de téléportation automatiquement.                          #
#                                                                              #
#==============================================================================#




module Mhd_TP
 
  SWITCH    = 1                        #Id du switch active ou désactive le script
  X_ID      = 2                        #Id de la variable correspondante
  Y_ID      = 3                        #Id de la variable coorespondante
  SET_ID    = 1                        #Id de la variable correspondante
 
#------------------------------------------------------------------------------#
#                                                                              #
#  Les sets et les matrices de maps                                          #
#                                                                              #
#------------------------------------------------------------------------------# 
 
  SET_MAP    = [
                #Set n°0:
                {
                "Matrice"    =>
                                [
                                [1, 4,  6],
                                [2, 3, 5],
                                [7, 8, 9],
                                [12,10,11]
                                ],
                "Unlimited?" => true                  #boucle la matrice
                                                        #et saute les "nil"
                }
                ]
               

#------------------------------------------------------------------------------#
#                                                                              #
#  Gestions des collisions                                                    #
#                                                                              #
#------------------------------------------------------------------------------# 

  COLISION = true
 
# false : les colisions entre les différentes maps ne sont pas gérées
# true :  les colisions sont bloquantes, elles empêchent les changements de map
end









#==============================================================================#
#                                                                              #
#                                                                              #
#                            AUTO-TELEPORT                                    #
#                                                                              #
#                                                                              #
#==============================================================================#
#                                                                              #
#Vincentmhd                                                                    #
#http://vincentmhdmaker.canalblog.com/                                        #
#10/2/2010                                                                    #
#                                                                              #
#                                                                              #
#-------------------------------------NOTE-------------------------------------#
#                                                                              #
#  Classe du gestionnaire.                                                    #
#                                                                              #
#==============================================================================#



class Auto_Tp

 
  attr_reader  :m_x
  attr_reader  :m_y
  attr_reader  :set
 

 
#------------------------------------------------------------------------------#
#                                                                              #
#  Initialisation                                                            #
#                                                                              #
#------------------------------------------------------------------------------#
  def initialize()
   
    #prochaine map
    @next_map = Game_Map.new
   
    #Coordonnées matricielles
    @m_x  = 0         
    @m_y  = 0
    @set = 0
       
    $game_variables[Mhd_TP::X_ID]  = @m_x
    $game_variables[Mhd_TP::Y_ID]  = @m_y
    $game_variables[Mhd_TP::SET_ID] = @set
   
    #coordonnées physiques de destination
   
    @d_x = 0
    @d_y = 0

    @transfert = true
  end
 

 
#------------------------------------------------------------------------------#
#                                                                              #
#  Attribut les coordonnées                                                  #
#                                                                              #
#------------------------------------------------------------------------------#
  def set_coord(x,y, set =0)
    @m_x  = x
    @m_y  = y
    @set = set
  end

 
#------------------------------------------------------------------------------#
#                                                                              #
#  Crée une map légère, pour tester la prochaine map.                          #
#                                                                              #
#------------------------------------------------------------------------------#
  def create_map(map_id)
    @next_map.rapid_setup(map_id)
  end
 

 
#------------------------------------------------------------------------------#
#                                                                              #
# Choisi la map                                                                #
#                                                                              #
#------------------------------------------------------------------------------#
  def map_choice(direction)
   
    x = @m_x
    y = @m_y
   
    case direction
   
    when 2
      #Si la coordonnée y est possible
      if !(Mhd_TP::SET_MAP[@set]["Matrice"][y+1].nil?)
        #si le couple de coordonnée coordonnée [x,y] est possible
        if !(Mhd_TP::SET_MAP[@set]["Matrice"][y+1][x].nil?)
          y +=1
          possible = true
        else
          if Mhd_TP::SET_MAP[@set]["Unlimited?"] == true
            y += 1
            y %= Mhd_TP::SET_MAP[@set]["Matrice"].size()
            while (Mhd_TP::SET_MAP[@set]["Matrice"][y][x] == nil)
              y += 1
              y %= Mhd_TP::SET_MAP[@set]["Matrice"].size()
            end
            possible = true
          else
            possible = false
          end
        end
       
      else
        if Mhd_TP::SET_MAP[@set]["Unlimited?"] == true
          y += 1
          y %= Mhd_TP::SET_MAP[@set]["Matrice"].size()
          #le problème vient de ["Matrice"].size()
          while (Mhd_TP::SET_MAP[@set]["Matrice"][y][x] == nil)
            y += 1
            y %= Mhd_TP::SET_MAP[@set]["Matrice"].size()
          end
          possible = true
        else
          possible = false
        end
      end
      
    when 4
      if (x-1 >= 0)&&(Mhd_TP::SET_MAP[@set]["Matrice"][y][x-1] != nil)
        x -=1
        possible = true
      else
        if Mhd_TP::SET_MAP[@set]["Unlimited?"] == true
         
          x -= 1
          x %= Mhd_TP::SET_MAP[@set]["Matrice"][y].size()
          if x < 0
            x += (Mhd_TP::SET_MAP[@set]["Matrice"][y].size())
          end
         
          while (Mhd_TP::SET_MAP[@set]["Matrice"][y][x] == nil)
            x -= 1
            x %= Mhd_TP::SET_MAP[@set]["Matrice"][y].size()
            if x < 0
              x += (Mhd_TP::SET_MAP[@set]["Matrice"][y].size())
            end
          end
         
          possible = true
        else
          possible = false
        end
      end
    when 6
      if (Mhd_TP::SET_MAP[@set]["Matrice"][y][x+1] != nil)
        x +=1
        possible = true
      else
        if Mhd_TP::SET_MAP[@set]["Unlimited?"] == true
          x += 1
          x %= Mhd_TP::SET_MAP[@set]["Matrice"][y].size()         
          while (Mhd_TP::SET_MAP[@set]["Matrice"][y][x] == nil)
            x += 1
            x %= Mhd_TP::SET_MAP[@set]["Matrice"][y].size()
          end
          possible = true
        else
          possible = false
        end
      end
      
    when 8
      #si y -1 est possible
      if (y - 1 >= 0)&&(Mhd_TP::SET_MAP[@set]["Matrice"][y-1] != nil)
        #si le couple de coordonnée coordonnée [x,y-1] est possible
        if !(Mhd_TP::SET_MAP[@set]["Matrice"][y-1][x].nil?)
          y -=1
          possible = true
        else
          if Mhd_TP::SET_MAP[@set]["Unlimited?"] == true
            y -= 1
            y %= (Mhd_TP::SET_MAP[@set]["Matrice"].size())
            if y < 0
              y += (Mhd_TP::SET_MAP[@set]["Matrice"].size())
            end
            
            while (Mhd_TP::SET_MAP[@set]["Matrice"][y][x] == nil)
              y -= 1
              y %= Mhd_TP::SET_MAP[@set]["Matrice"].size()
              if  y < 0
              y += (Mhd_TP::SET_MAP[@set]["Matrice"].size())
              end
            end
            possible = true
          else
            possible = false
          end
        end
      else
        if Mhd_TP::SET_MAP[@set]["Unlimited?"] == true
          y -= 1
          y %= (Mhd_TP::SET_MAP[@set]["Matrice"].size())
          if y < 0
            y += (Mhd_TP::SET_MAP[@set]["Matrice"].size())
          end
         
          while (Mhd_TP::SET_MAP[@set]["Matrice"][y][x] == nil)
            y -= 1
            y %= (Mhd_TP::SET_MAP[@set]["Matrice"].size())
            if  y < 0
              y += (Mhd_TP::SET_MAP[@set]["Matrice"].size())
            end
          end
         
          possible = true
        else
          possible = false
        end
      end
    end
   
    id = Mhd_TP::SET_MAP[@set]["Matrice"][y][x]
    if id != nil
      create_map(id)
    else
      print("Ceci est un bug du Auto_Tp, repérez bien les conditions du bug! \n Vous pouvez continuer à jouer, cependant la map n'est pas accessible par ce chemin...")
      print("informations de matrice: x = " + x.to_s + " y = " + y.to_s)
      possible = false
    end
   
   

    result = {"next_map"  => id,
              "transfers"  => possible,
              "@m_x"      => x,
              "@m_y"      => y}
                  
    return result
  end
 

 
#------------------------------------------------------------------------------#
#                                                                              #
#Choisi la future map , la direction et la position du joueur                  #
#                                                                              #
#------------------------------------------------------------------------------#
  def tp_choice(direction) 
   
    result = map_choice(direction)
    #Gestion des collisions
    if result["transfers"]   
      case direction
      #détermination des coordonnées suivantes
      when 2
        @d_x = $game_player.x
        @d_y = 0
      when 4
        @d_x = (@next_map.width() -1)
        @d_y = $game_player.y
      when 6
        @d_x = 0
        @d_y = $game_player.y
      when 8
        @d_x = $game_player.x
        @d_y = (@next_map.height() -1)
      end
   
      if Mhd_TP::COLISION
        if (@next_map.passable?(@d_x,@d_y))
          @transfert = result["transfers"]
        else
          @transfert = false
        end
      else
        @transfert = result["transfers"]
      end
   
   
      #si téléportation, on réserve...
      if @transfert == true
        @m_x = result["@m_x"]
        @m_y = result["@m_y"]
      
        $game_variables[Mhd_TP::X_ID]  = @m_x
        $game_variables[Mhd_TP::Y_ID]  = @m_y
        $game_variables[Mhd_TP::SET_ID] = @set
      
        $game_player.auto_tp_reserve_transfer(result["next_map"], @d_x, @d_y, direction)
      end
    end
  end
 

  def teleportation(set, m_x, m_y, y, x, direction, active = true)
    id_map = Mhd_TP::SET_MAP[@set]["Matrice"][m_y][m_x]
    if id_map != nil
      
      @set = set
      @m_x = m_x
      @m_y = m_y
      
      $game_switches[Mhd_TP::SWITCH] =  active
      $game_player.auto_tp_reserve_transfer(id_map, x, y, direction)
    else
      print("Erreur de coordonnées matricielles ou de set, vérifiez vos données")
    end
  end

 
 
#------------------------------------------------------------------------------#
#                                                                              #
#Teste s'il y a téléportation avant le mouvement                              #
#                                                                              #
#------------------------------------------------------------------------------#
  def down_cond
    if $game_switches[Mhd_TP::SWITCH] ==  true
      if ($game_player.y==($game_map.height() -1))&&(!$game_map.loop_vertical?())
        tp_choice(2)
      end
    end
  end
 
  def left_cond
    if $game_switches[Mhd_TP::SWITCH] ==  true
      if ($game_player.x==0)&&(!$game_map.loop_horizontal?())
        tp_choice(4)
      end
    end
  end
 
  def right_cond
    if $game_switches[Mhd_TP::SWITCH] ==  true
      if ($game_player.x==($game_map.width() -1))&&(!$game_map.loop_horizontal?())
        tp_choice(6)
      end
    end
  end
 
  def up_cond
    if $game_switches[Mhd_TP::SWITCH] ==  true
      if ($game_player.y==0)&&(!$game_map.loop_vertical?())
        tp_choice(8)
      end
    end
  end
 
 

#------------------------------------------------------------------------------#
#                                                                              #
#  Changement de Set manuellement                                            #
#                                                                              #
#------------------------------------------------------------------------------#
  def tp_set(set)
    @set = set
    $game_variables[Mhd_TP::SET_ID] = @set
    id = Mhd_TP::SET_MAP[@set]["Matrice"][@m_y][@m_x]
    create_map(id)
   
    coord = replace
   
    #$game_map.setup(id)
    #$game_player.moveto(@d_x, @d_y)
    $game_player.auto_tp_reserve_transfer(id, @d_x, @d_y, $game_player.direction)
  end
 

 
 
 

 
#------------------------------------------------------------------------------#
#                                                                              #
#  Renvois les coordonnées d'une case dans la direction donné au rayon donné.  #
#                                                                              #
#------------------------------------------------------------------------------#
  #2: down, 4: left, 6: right, 8: up
  #  5 8 7
  #  4  6
  #  3 2 1
  def coord?(coord, direction, rayon = 1)
    case(direction)
    when 1
      coord[1] +=rayon
      coord[0] +=rayon
    when 2
      coord[1] +=rayon      
    when 3
      coord[1] +=rayon
      coord[0] -=rayon
    when 4
      coord[0] -=rayon
    when 5
      coord[0] -=rayon
      coord[1] -=rayon
    when 6
      coord[0] +=rayon
    when 7
      coord[0] +=rayon
      coord[1] -=rayon
    when 8
      coord[1] -=rayon
    else
      coord = nil
    end
    return coord
  end
 
 
#------------------------------------------------------------------------------#
#                                                                              #
#  Si entre 2 sets liés, il y a une différence de passabilité, le script      #
#  décale le joueur de quelques cases.                                        #
#                                                                              #
#------------------------------------------------------------------------------#
  def replace
    x = $game_player.x
    y = $game_player.y
   
    if(!@next_map.passable?(x, y))
      cherche = true
      rayon  = 0
   
      while cherche
        direction = 1
        x = $game_player.x
        y = $game_player.y
      
        while direction <=8
          coord = coord?([$game_player.x,$game_player.y], direction, rayon)
          x = coord[0]
          y = coord[1]
          if (x>= 0) && (y>= 0) && (y< @next_map.height() ) && (x< @next_map.width() )
            if(@next_map.passable?(x, y))
                direction = 9                              #arrêt première boucle
                cherche = false                            #arrêt seconde boucle
            end
          end
          direction += 1
        end
        rayon +=1
      end
    end
    @d_x = x
    @d_y = y
  end
 
      
 
 
#------------------------------------------------------------------------------#
#                                                                              #
#  Actualise la valeur des variables internes par les externes                #
#                                                                              #
#------------------------------------------------------------------------------#
  def refresh
    @m_x =  $game_variables[Mhd_TP::X_ID] 
    @m_y =  $game_variables[Mhd_TP::Y_ID] 
    @set = $game_variables[Mhd_TP::SET_ID]
  end
end






class Game_Player
 
#------------------------------------------------------------------------------#
#                                                                              #
#  Surcharges des commandes du players pour tester si tranfert de map        #
#                                                                              #
#------------------------------------------------------------------------------#
  alias tp_move_down move_down
  def move_down(turn_ok = true)
    $game_tp.down_cond
    tp_move_down(turn_ok)
  end
 
  alias tp_move_left move_left
  def move_left(turn_ok = true)
    $game_tp.left_cond
    tp_move_left(turn_ok)
  end
 
  alias tp_move_right move_right
  def move_right(turn_ok = true)
    $game_tp.right_cond
    tp_move_right(turn_ok)
  end
 
  alias auto_tp_move_up move_up
  def move_up(turn_ok = true)
    $game_tp.up_cond
    auto_tp_move_up(turn_ok)
  end
 
 
 
#------------------------------------------------------------------------------#
#                                                                              #
# Réservation de la téléportation                                              #
#                                                                              #
#------------------------------------------------------------------------------#
  def auto_tp_reserve_transfer(map_id, x, y, direction)
    reserve_transfer(map_id, x, y, direction)
    @tp_force_setup = true
  end
 
 
#------------------------------------------------------------------------------#
#                                                                              #
# Téléportation en cours                                                      #
#                                                                              #
#------------------------------------------------------------------------------#
  alias tp_perform_transfer perform_transfer
  def perform_transfer
    if @tp_force_setup != nil
      if @tp_force_setup == true
        return unless @transferring
        @transferring = false
        set_direction(@new_direction)
        $game_map.setup(@new_map_id)   
        moveto(@new_x, @new_y)
      else
        tp_perform_transfer
      end
    else
      tp_perform_transfer
    end
      @tp_force_setup = false
  end

end


class Game_Map
 
 
#------------------------------------------------------------------------------#
#                                                                              #
#  Création de maps + légères pour faire des tests                            #
#                                                                              #
#------------------------------------------------------------------------------#
  def rapid_setup (map_id)
    @map = load_data(sprintf("Data/Map%03d.rvdata", map_id))
    @passages = $data_system.passages
    setup_events
  end

 
#------------------------------------------------------------------------------#
#                                                                              #
#  Mise à jour des coordonnées de la matrice                                  #
#                                                                              #
#------------------------------------------------------------------------------#
  alias setup_map_mhd setup
  def setup(map_id)
    setup_map_mhd(map_id)
    $game_tp.refresh
  end
end

class Scene_Title
 
#------------------------------------------------------------------------------#
#                                                                              #
#  Initialisation du gestionnaire                                            #
#                                                                              #
#------------------------------------------------------------------------------#
  alias tp_create_game_objects create_game_objects
  def create_game_objects
    tp_create_game_objects
    $game_tp = Auto_Tp.new
  end
end