Dynamic lights english partial translation

# Lumières Dynamiques Version 3o
# A script imagined and written by Fabien - fabien_35@hotmail.com
# The complete manual, the code update and free help of the author an on The Factory forum : adress
# Aim : Deal with lights which are not only white over the dark of the night
#       but that are really pushing away the darkness to reveal true colors.
#       This is what we'll call light in this scirpt : a hole in the layer hiding the map.
#       However let's be clear :
#            - Immobile lights are easily done without scripts (see tutorial on The Factory)
#            - One single moving light is easily done without scripts (see tutorial on The Factory)
#            - However several lights relativeley moving from each other, accouting for collisions, is impossible without a script like this one.
#            => The aim of this code is the animation of several lights "at once".
#-----------------------------------------
# Use : Parallel Event, script : ecran_nuit to initialize. For example ecran_nuit(150,0,0,15) for slightly blue darkness
# then lum(name,id) as many times as you want lights,
# with "name" the file name of the light picture and "id" the id of event bearing the light.
# The script has much more functionalities : visit his topic on Factory to see them.

#=====Interface functions : =========================================================
#-----Initialization function of the script. Creates darkness. Arguments are the color component of the darkness and transparency-------------
def ecran_nuit(op=150,r=0,v=0,b=0) # (ooacité de la nuit, rouge, vert,bleu)
  $lum.img.dispose if $lum.is_a?(Lumières_dynamiques) # effacage des lum précédentes.
  $lum=Lumières_dynamiques.new(255-r,255-v,255-b,op) # création de l'unique instance du script
end
#-------Main interface function. Creates a light following an event.-------------------------------------
def lum(nom,id=0,op=255,dx=0,dy=0,x=nil,y=nil,zx=1,zy=1)
  $lum.lums[id]=Lum.new(nom,id,op,x,y,dx,dy,zx,zy,nil)
end #The characteristics of the lum are stored within a structure
#-------set-up unmovable decoration lights------------------------
def lumF(nom,id,op=255,dx=0,dy=0,x=nil,y=nil,zx=1,zy=1)
  $lum.coller_le_trou(true,nom,x,y,op,dx,dy,id,zx,zy) # installe la lumière
end
#-------lumF_tile creates lumF on all identifcal tiles from one given in an example ----------
def lum_tile(nom,x_tile,y_tile,i_tile,op=255,dx=0,dy=0)
    cherche_tile(x_tile,y_tile,i_tile).each{|tile|  # collecte les tiles identiques
    $lum.coller_le_trou(true,nom,tile[0]*32+dx,tile[1]*32+dy,op)} # y installe des lumières
  end
#--------antilum keeps rectanglular areas in the darkness-----------------------
def antilum(x1,y1,x2,y2)
  x1*=32
  y1*=32
  x2=(x2+1)*32
  y2=(y2+1)*32
  $lum.antilums.push(Rect.new(x1,y1,(x2-x1).abs,(y2-y1).abs))
end
#------stick a lumF on all the map----------------------------------
def lumFCarte(nom,op=255)
  $lum.coller_le_trou(true,nom,$game_map.width*16,$game_map.height*16,255,0,0,1)
end
#--set-up specials anti-darkness lums. For areas that cannot be lightened.
def proteger(nom,id=0,op=255,dx=0,dy=0,x=nil,y=nil,zx=1,zy=1)   # peu utile en pratique
  $lum.proctections.push([nom,x,y,id,op,dx,dy,zx,zy])
end
#------same thing for all occurrences of one tile.This one os useful-----------------
def proteger_tiles(nom,x_tile,y_tile,i_tile,op=255,dx=0,dy=0,zx=1,zy=1)
  $game_map.cherche_tile(x_tile,y_tile,i_tile).each{|tile|  # collecte les tiles identiques
  $lum.proctections.push([nom,tile[0]*32,tile[1]*32,id,op,dx,dy,zx,zy]) }# y installe des protections
end
#----end of interface functions-----------------------------------------------------------------


#---Class storing all information about lights  ( allow a more intuitive access)-----------------
Lum = Struct.new( "Lum", :nom, :id, :op, :x, :y, :dx, :dy, :zx, :zy, :stock)
#---------------------------------------------------------------------
#--- Main class, stocks Lum and display everything. -----------
class Lumières_dynamiques
  attr_accessor :lums ,:img ,:id_map ,:antilums ,:proctections ,:repertoire
#---------------------------------------------------------------------
  def initialize(r,v,b,op) # création des variables du script
    @fixes=false # mode fixe ? oui ou non, non par defaut
    @lums=Hash.new #Stocke les caractéristiques des lums
    @antilums=[]
    @reparations=[] #stocke les réparations à faire à la prochaine frame
    @proctections=[]
    @id_map=$game_map.map_id # mémorisation de l'id map ( pour gerer les téléportations)
    @periode=1 # economie de puissance ( perte de fluidité)
    @img=Sprite.new # l'unique spritedu script, qui portera tout
    @img.bitmap=Bitmap.new(640,480) # on commence en mode non fixe, donc taille ecran
    @img.blend_type=2 # pour pouvoir assombrir l'ecran et faire des trous
    @img.z=10 # avec ça des sprites de z<10 seront obscurcis
    @img.opacity=op # opacité de la nuit ( et plus généralement, de ce que masque la carte)
    @fond=Color.new(r,v,b,255) #stockage de la couleur de la nuit.
    @repertoire="Pictures/lumieres"#répertoire dans Graphics/ ou seront prise les images.
    maj # on appelle la fct de mise à jour pour que tout s'affiche direct
  end
#------# permet de basculer du mode non-fixe vers le mode fixe -------------
  def inifixes
    if not @fixes # si on à pas déjà basculé en fixe
      #on va créer et remplir de la couleur de fond un bitmap de la taille de la carte
      @bmp=Bitmap.new($game_map.width*32,$game_map.height*32)
      @bmp.fill_rect(@bmp.rect,@fond) # bmp sera notre rèference, on y collera les lums fixes
      @img.bitmap=Bitmap.new($game_map.width*32,$game_map.height*32)
      @img.bitmap.fill_rect(@img.bitmap.rect,@fond) # on met le bitmap affiché au bon format
      @fixes=true # on memorise qu'on est passé en mode fixe
    end
  end
#----- fonction centrale. Est appellée à chaque frame via Spritesetmap ci-dessous------------------
  def maj
    if @fixes # si on est en mode avec lumières fixes
      @img.ox=$game_map.display_x/4 # déplacer l'image avec la carte
      @img.oy=$game_map.display_y/4
    end
    @img.visible=true
    return if Graphics.frame_count%@periode != 0 or @id_map != $game_map.map_id # gain de fps
    reparer  # on rebouche les trous qui ont été fait à la frame d'avant
    trouer # on fait les trous requis pour cette frame (les lums)
    proteger # application de l'option de protection "antilum"
  end
#------rebouche les trous qui ont été fait à la frame d'avant-----------------------------------------------------
def reparer
  if not @fixes
    @img.bitmap.fill_rect(@img.bitmap.rect,@fond)
    @reparations=[]
  else
    @reparations.each{|reparation|
    @img.bitmap.blt(reparation.x,reparation.y,@bmp,reparation) }
    @reparations=[]
  end
end
#--------commande les trous requis à chaque frame-------------------------------------------------------------
def trouer
  @lums.each_value{|lum|
    coller_le_trou(false,
      lum.nom,lum.x,lum.y,lum.op,lum.dx,lum.dy,lum.id,lum.zx,lum.zy) }
end
#--------les antilums protègent certaines zone en effacant les lumières
def proteger
  @antilums.each{|antilum|
    x=antilum.x-(@fixes ? 0 : $game_map.display_x/4)
    y=antilum.y-(@fixes ? 0 : $game_map.display_y/4)
    @img.bitmap.fill_rect(Rect.new(x,y,antilum.width,antilum.height),@fond) }
  @proctections.each{|proctection|
    nom,x,y,id,op,dx,dy,zx,zy=proctection
    coller_le_trou(false,nom,x,y,op,dx,dy,id,zx,zy) }
end
#--------- calcule les coordonées du trou à partir de son id ou lum.x et y
def calculer_coords(x,y,id,dx,dy,image,tx,ty,fixe=false)
  if x==nil # si aucun x n'a été entré, on fixe la lum sur l'event id
    return [$game_map.display_x/4,$game_map.display_y/4] if id.is_a?(String)
    id==0 ? ev=$game_player : ev=$game_map.events[id]
    x=ev.screen_x #donc on calcule le x/map de cet event
    y=ev.screen_y
    x+=dx # ajustement précis des coordonées par un petit facteur optionnel
    y+=dy
    return [nil,nil] if (x-tx/2>640 or y-ty/2>480 or x+tx/2<0 or y+ty/2<0) and not fixe
    x-=tx/2 # centrage de l'image sur les coords
    y-=ty/2
  else
    if not id.is_a?(String) # si l'id est une String, x est une coord/map en pixel
      x-=$game_map.display_x/4 # on les convertis en /ecran
      y-=$game_map.display_y/4
    end # sinon si id est une string, c'est une coord/ecran en pixel
    x+=dx # ajustement précis des coordonées par un petit facteur optionnel
    y+=dy
    return [nil,nil] if (x>640 or y>480 or x+tx<0 or y+ty<0) and not fixe
  end
  x+=$game_map.display_x/4 if @fixes # conversion en coords /MAP
  y+=$game_map.display_y/4 if @fixes # mais seulement pour le mode avec lums fixes
  return [x,y] #les coord renvoyées sont par rapport à la MAP ( et en pixels)
end
#--------fct qui fait vraiment le trou-------------------------------------------------------------
def coller_le_trou(fixe,image,x,y,op=255,dx=0,dy=0,id=0,zx=1,zy=1)
  inifixes if fixe
  image=RPG::Cache.load_bitmap("Graphics/"+@repertoire+"/",image) if image.is_a?(String) # charge de l'image à partir du nom de fichier
  tx,ty=image.width*zx,image.height*zy #simple mémo de la taille de l'image
  x,y=calculer_coords(x,y,id,dx,dy,image,tx,ty,fixe)
  return if x==nil
  op>255 ? op=255 : (op<0 ? op=0 : nil )
  #maintenant on passe au collage lui-même.
  @img.bitmap.stretch_blt(Rect.new(x,y, tx,ty), image,image.rect,op)
  if fixe # sauvegarde du trou dans @bmp (si c'est une lumière fixe)
          @bmp.stretch_blt(Rect.new(x,y,tx,ty), image,image.rect,op)
  else # sinon sauvegarde de la zone trouée, pour effacer le trou plus tard
    @reparations.push(Rect.new(x,y,tx,ty))
  end
end
#---------------------------------------------------------------------
end# fin la classe Lumières_dynamiques
#---------------------------------------------------------------------
#---------------------------------------------------------------------
class Spriteset_Map # modif pour que le script soit mise à jour automatiquement
  alias lum_update update # court circuit de l'update. On la renomme en lum_update
  def update # redefinition de update
    lum_update   # fonction update normale de Spriteset_Map
    if $lum.is_a?(Lumières_dynamiques) and not $lum.img.disposed?
      $lum.maj   # maj si le script est en route
      if $lum.id_map != $game_map.map_id# quitter le script si on a changé de carte
        $lum.img.dispose
        $lum=nil
      end
    end
  end
#------------------------------------------------------
  alias lum_dispose dispose
    def dispose
    lum_dispose
     $lum.img.visible = $scene.is_a?(Scene_Map) if $lum.is_a?(Lumières_dynamiques) and not $lum.img.disposed?
   end
end# fin la classe Spriteset_Map
#---------------------------------------------------------------------
#---------------------------------------------------------------------

  def cherche_tile(x,y,i)  #fct pour chercher les tiles identiques
    tile_cible=$game_map.data[x, y, i] # on definit le carreau cherché
    # maintenant on va le chercher
    results=[]  #définition d'une var pr stocker les résultats
    for x in 0...$game_map.data.xsize # pour chaque case de la carte
      for y in 0...$game_map.data.ysize
        for i in [2, 1, 0] # dans chaque couche
          results.push([x,y,i]) if $game_map.data[x, y, i]==tile_cible # si tile est le même que l'exemple, on le stocke
        end
      end
    end
    return results # en renvoie les bons tiles
  end
#---------------------------------------------------------------------
#---------------------------------------------------------------------