[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français - Scripts

Auteur : Corbaque
Logiciel : RPG Maker XP
Nombre de scripts : 1

Je me suis enfin décidé à développer le script de Sunmat, j'ai donc pondu ce gros script
Installation
A placer au-dessus de Main.

Commencez par mettre ces deux fichiers dans le dossier racine de votre projet si ce n'est pas déjà fait :
- screenshot.dll (~~http://rpgmxpstudio.pellnet.ch/Corbaque/screenshot.dll~~)
- RGSS100J.dll (~~http://rpgmxpstudio.pellnet.ch/Corbaque/RGSS100J.dll~~) Ou toute dll RGSS10XX.dll compatible avec votre pc.
$transition_id = 1
#===================================
# Pack de transitions
#---------------------------------------------------------------
# Créé par Corbaque
#---------------------------------------------------------------
# Un très grand merci à Sunmat.
#---------------------------------------------------------------
# Depuis le 04 / 11 / 2006
#---------------------------------------------------------------
# La transition vers le combat sera changée
# Selon la variable $transition_id
#---------------------------------------------------------------
# Vous pouvez aussi faire des superbe
# Transition de sortie :
# - Explosion :
# $scene = transition(Scene.new, 1)
# ou
# $scene = transition(Scene.new, 1, nbx, nby, gravitée, amplitude)
#   * nbx = Nombre de carré de droite à gauche (12)
#   * nby = Nombre de carré de haut en bas (8)
#   * gravitée = Gravitée exercée sur les morceaux (0.1)
#   * amplitude = Facteur d'amplification de l'explosion (1)
# - Zoom :
# $scene = transition(Scene.new, 2)
# ou
# $scene = transition(Scene.new, 2, zoom_x, zoom_y)
#   * zoom_x = Elargement de l'image en % (5)
#   * zoom_y = Elongement de l'image en % (5)
# - Dézoom
# $scene = transition(Scene.new, 3)
# ou
# $scene = transition(Scene.new, 2, zoom_x, zoom_y)
#   * zoom_x = Reduction de la largeur de l'image en % (5)
#   * zoom_y = Reduction de la longueur de l'image en % (5)
# - Rideau
# $scene = transition(Scene.new, 4)
# ou
# $scene = transition(Scene.new, 4, vx, vy)
#   * vx = vitesse de l'éloignement vers l'exterieur en pixel (5)
#   * vy = vitesse de l'éloignement vers le haut ou le bas {+/-} (0)
#===================================
def transition(scene, id, a=nil, b=nil, c=0.1, d=1)
  case id
  when 1
    if a == nil
      a = 12
    end
    if b == nil
      b = 8
    end
    $scene = Scene_Explosion.new(scene, a, b, c, d)
  when 2
    if a == nil
      a = 5
    end
    if b == nil
      b = 5
    end
    $scene = Scene_Zoom.new(scene, a, b)
  when 3
    
    $scene = Scene_Dezoom.new(scene, a, b)
  when 4
    $scene = Scene_Rideau.new(scene, a, b)
  end
end
#---------------------------------------------------------------
# Change la transition vers le combat
#---------------------------------------------------------------
class Scene_Map
  def call_battle
    $game_temp.battle_calling = false
    $game_temp.menu_calling = false
    $game_temp.menu_beep = false
    $game_player.make_encounter_count
    $game_temp.map_bgm = $game_system.playing_bgm
    $game_system.bgm_stop
    $game_system.bgm_play($game_system.battle_bgm)
    $game_player.straighten
    $game_system.se_play($data_system.battle_start_se)
    # Vous pouvez régler les paramètres
    case $transition_id
    when 1
      $scene = transition(Scene_Battle.new, 1, 10, 10, 0.2, 1)
    when 2
      $scene = transition(Scene_Battle.new, 2, 4, 4)
    when 3
      $scene = transition(Scene_Battle.new, 3, 4, 4)
    when 4
      $scene = transition(Scene_Battle.new, 4, 4, 0)
    end
  end
end
#===================================
# Screen_Shot
#---------------------------------------------------------------
# Créé par Andreas21 & cybersam
#===================================
module Screen
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  # Variables du module
  # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  @screen = Win32API.new 'screenshot', 'Screenshot', %w(l l l l p l l), ''
  @readini = Win32API.new 'kernel32', 'GetPrivateProfileStringA', %w(p p p p l p), 'l'
  @findwindow = Win32API.new 'user32', 'FindWindowA', %w(p p), 'l'
  # Méthode du module
  module_function
  #-------------------------------------------------------------
  # Gestion de la récupération de la fenêtre de
  # Jeu
  #-------------------------------------------------------------
  def handel
    game_name = "\0" * 256
    @readini.call('Game','Title','',game_name,255,".\\Game.ini")
    game_name.delete!("\0")
    # Trouve et renvoie la fenêtre de jeu
    return @findwindow.call('RGSS Player',game_name)
  end
end
#---------------------------------------------------------------
# Capture d'écran
#---------------------------------------------------------------
# Redéfinition de la Méthode shot pour retirer
# L'index d'image dans le nom de fichier.
#---------------------------------------------------------------
def Screen.shot_new(file = "Screen ", type = 1)
  # Si le type est 0
  if type == 0
    # L'extension est .bmp
    typname = ".bmp"
  # Si le type est 1
  elsif type == 1
    # L'extension est .jpg
    typname = ".jpg"
  # Si le type est 2
  elsif type == 2
    # L'extension est .png
    typname = ".png"
  end
  dir = ""
  # Nom du fichier final :
  # Dossier conteuneur + Nom du fichier + extension
  file_name = dir + file.to_s + typname.to_s
  # Lance le screen shot :
  # Position x puis y sur la fenêtre, longueur et
  # Largeur de l'image, le nom du fichier, gestion
  # De la récupération du jeu après l'utilisation
  # De la dll, extension ed l'image
  @screen.call(0,0,640,480,file_name,handel,type)
end
#===================================
# ■ Scene_Explosion & Physic Data
#---------------------------------------------------------------
# Créé par Sunmat
#---------------------------------------------------------------
# helping.gem@laposte.net
#---------------------------------------------------------------
# En exclusivité sur RMXP Studio 2
# Si vous avez trouvé ce script ailleur,
# Merci de me le signaler
#---------------------------------------------------------------
# Recommenté et très légèrement optimisé
# Par Corbaque
#===================================
class Physic_Data
  attr_accessor :rotate_speed  # Vitesse de rotation de l'image en degré par frame
  attr_accessor :gravity              # Gravité à appliquer sur les objets
  attr_accessor :vel_x                 # Composante en x de la vitesse
  attr_accessor :vel_y                 # Composante en y de la vitesse
  #-------------------------------------------------------------
  # Constructeur d'objet Physic_Data
  #-------------------------------------------------------------
  def initialize
    @rotate_speed = (100-rand(50))/50.0 * 4
    @gravity = $g
    @vel_x = 10-rand(20)
    @vel_y = -rand(10) * $ampl
  end
  #-------------------------------------------------------------
  # Mise à jour des données faisant intervenir 
  # la gravité
  #-------------------------------------------------------------
  def update
    @vel_y += @gravity
  end
end
#===================================
# Scene_Explosion
#---------------------------------------------------------------
# Scène faisant office de transition, procéder
# De cette manière :
# Sans transition :
# $scene = Ma_Scene.new
# Avec transition :
# $scene = Scene_Explosion.new(Ma_Scene.new)
#---------------------------------------------------------------
# Note :
# La transition peut être passée avec la action
#---------------------------------------------------------------
class Scene_Explosion
  #-------------------------------------------------------------
  # ● initialisation
  #-------------------------------------------------------------
  def initialize(next_scene, nbx=12, nby=8, gravite=0.1, amplitude=1)
    @nbx = (nbx == nil ? 12 : nbx)
    @nby = (nby == nil ? 8 : nby)
    @next_scene = next_scene
    $g = (gravite == nil ? 0.1 : gravite)
    $ampl = (amplitude == nil ? 1 : amplitude)
  end
  #-------------------------------------------------------------
  # ● lancement
  #-------------------------------------------------------------
  def main
   # appel de la fonction de screenshot
    screenshot()
    # arrêt des musiques et sons (facultatif)
    Audio.me_stop
    Audio.bgs_stop
    # condition de fin de scène
    @continue = true
    # Transition graphique
    Graphics.transition
   # boucle principale
    while $scene == self
      # mise à jour graphique
      Graphics.update 
      # mise à jour de l'appuie des touches
      Input.update 
      # mise à jour des données
      update()
    end
    # gèle de l'écran
    Graphics.freeze
  end
  #-------------------------------------------------------------
  # Méthode de screen shot pour le découpage
  #-------------------------------------------------------------
  def screenshot
    # Prise du screen_shot
    Screen.shot_new("temp",0) 
    # Chargement dans un Bitmap
    @screen = Bitmap.new("temp.bmp") 
    # Suppression du fichier temporaire
    File.delete("temp.bmp") 
    # Initialisation du tableau des sprites
    @sprites = [] 
    # Initialisation du tableau des données physiques
    @physic_data = [] 
    # Découpage :
    for i in 0...@nbx
      @sprites[i] = []
      @physic_data[i] = []
      for j in 0...@nby
        @sprites[i][j] = Sprite.new
        @sprites[i][j].x = i*(640/@nbx) + 640/(@nbx*2)
        @sprites[i][j].y = j*(480/@nby) + 480/(@nby*2)
        # Le repère de l'image est en son centre
        @sprites[i][j].ox = 640/(@nbx*2)
        @sprites[i][j].oy = 480/(@nby*2)
        @sprites[i][j].bitmap = Bitmap.new((640/@nbx),(480/@nby))
        @sprites[i][j].bitmap.blt(0, 0, @screen,Rect.new(i*(640/@nbx),j*(480/@nby),(640/@nbx),(480/@nby)))
        @physic_data[i][j] = Physic_Data.new
      end
    end
  end
  #-------------------------------------------------------------
  # Mise à jour
  #-------------------------------------------------------------
  def update
    # arrêt potentiel de la scène
    @continue = false 
    for i in 0...@nbx
      for j in 0...@nby
        if !(@sprites[i][j].disposed?) and @sprites[i][j].y < 500 + 480/(@nby*2)
          @continue = true
          @sprites[i][j].angle += @physic_data[i][j].rotate_speed
          @sprites[i][j].x += @physic_data[i][j].vel_x
          @sprites[i][j].y += @physic_data[i][j].vel_y
          @physic_data[i][j].update
          @sprites[i][j].update
        elsif !(@sprites[i][j].disposed?)
          @sprites[i][j].dispose
        end
      end
    end
    # Termine la scène si la touche action
    # (entrer) est appuyée
    finish if !(@continue) or Input.trigger?(Input::C) 
  end
  #-------------------------------------------------------------
  # Méthode de fin de scène
  #-------------------------------------------------------------
  def finish
    $scene = @next_scene
  end
end
#===================================
# ■ Scene_Zoom
#---------------------------------------------------------------
# Créé par Corbaque
#---------------------------------------------------------------
# Note :
# La transition peut être passée avec la action
#===================================
class Scene_Zoom
  #-------------------------------------------------------------
  # ● initialisation
  #-------------------------------------------------------------
  def initialize(next_scene, zx=5, zy=5)
    @zx = zx / 100.0
    @zy = zy / 100.0
    @next_scene = next_scene
  end
  #-------------------------------------------------------------
  # ● lancement
  #-------------------------------------------------------------
  def main
   # appel de la fonction de screenshot
    screenshot()
    # arrêt des musiques et sons (facultatif)
    Audio.me_stop
    Audio.bgs_stop
    # condition de fin de scène
    @continue = true
    # Transition graphique
    Graphics.transition
   # boucle principale
    while $scene == self
      # mise à jour graphique
      Graphics.update 
      # mise à jour de l'appuie des touches
      Input.update 
      # mise à jour des données
      update()
    end
    # gèle de l'écran
    Graphics.freeze
  end
  #-------------------------------------------------------------
  # Méthode de screen shot pour le découpage
  #-------------------------------------------------------------
  def screenshot
    # Prise du screen_shot
    Screen.shot_new("temp",0) 
    # Chargement dans un Bitmap
    @screen = Sprite.new()
    @screen.bitmap = Bitmap.new("temp.bmp") 
    @screen.x = 320
    @screen.y = 240
    @screen.ox = 320
    @screen.oy = 240
    # Suppression du fichier temporaire
    File.delete("temp.bmp") 
  end
  #-------------------------------------------------------------
  # Mise à jour
  #-------------------------------------------------------------
  def update
    # arrêt potentiel de la scène
    @continue = false 
    @screen.zoom_x += (@zx) * @screen.zoom_x
    @screen.zoom_y += (@zy) * @screen.zoom_y
    @screen.opacity -= (@zx + @zy) * 100
    if @screen.zoom_x > 5
      @continue = true
    end
    # Termine la scène si la touche action
    # (entrer) est appuyée
    finish if (@continue) or Input.trigger?(Input::C) 
  end
  #-------------------------------------------------------------
  # Méthode de fin de scène
  #-------------------------------------------------------------
  def finish
    $scene = @next_scene
  end
end
#===================================
# ■ Scene_Dezoom
#---------------------------------------------------------------
# Créé par Corbaque
#---------------------------------------------------------------
# Note :
# La transition peut être passée avec la action
#===================================
class Scene_Dezoom
  #-------------------------------------------------------------
  # ● initialisation
  #-------------------------------------------------------------
  def initialize(next_scene, zx=5, zy=5)
    @zx = zx / 100.0
    @zy = zy / 100.0
    @next_scene = next_scene
  end
  #-------------------------------------------------------------
  # ● lancement
  #-------------------------------------------------------------
  def main
   # appel de la fonction de screenshot
    screenshot()
    # arrêt des musiques et sons (facultatif)
    Audio.me_stop
    Audio.bgs_stop
    # condition de fin de scène
    @continue = true
    @a = 1.0
    # Transition graphique
    Graphics.transition
   # boucle principale
    while $scene == self
      # mise à jour graphique
      Graphics.update 
      # mise à jour de l'appuie des touches
      Input.update 
      # mise à jour des données
      update()
    end
    # gèle de l'écran
    Graphics.freeze
  end
  #-------------------------------------------------------------
  # Méthode de screen shot pour le découpage
  #-------------------------------------------------------------
  def screenshot
    # Prise du screen_shot
    Screen.shot_new("temp",0) 
    # Chargement dans un Bitmap
    @screen = Sprite.new()
    @screen.bitmap = Bitmap.new("temp.bmp") 
    @screen.x = 320
    @screen.y = 240
    @screen.ox = 320
    @screen.oy = 240
    # Suppression du fichier temporaire
    File.delete("temp.bmp") 
  end
  #-------------------------------------------------------------
  # Mise à jour
  #-------------------------------------------------------------
  def update
    # arrêt potentiel de la scène
    @continue = false 
    @screen.zoom_y -= @zx
    @screen.zoom_x -= @zy
    if @screen.zoom_x <= 0 or @screen.zoom_y <= 0
      Graphics.update
      @screen.dispose
      @continue = true
    end
    # Termine la scène si la touche action
    # (entrer) est appuyée
    finish if (@continue) or Input.trigger?(Input::C) 
  end
  #-------------------------------------------------------------
  # Méthode de fin de scène
  #-------------------------------------------------------------
  def finish
    $scene = @next_scene
  end
end
#===================================
# ■ Scene_Rideau
#---------------------------------------------------------------
# Créé par Corbaque
#===================================
class Scene_Rideau
  #-------------------------------------------------------------
  # ● initialisation
  #-------------------------------------------------------------
  def initialize(next_scene, vx=5, vy=0)
    @vx = vx
    @vy = vy
    @next_scene = next_scene
  end
  #-------------------------------------------------------------
  # ● lancement
  #-------------------------------------------------------------
  def main
   # appel de la fonction de screenshot
    screenshot()
    # arrêt des musiques et sons (facultatif)
    Audio.me_stop
    Audio.bgs_stop
    # condition de fin de scène
    @continue = true
    # Transition graphique
    Graphics.transition
   # boucle principale
    while $scene == self
      # mise à jour graphique
      Graphics.update 
      # mise à jour de l'appuie des touches
      Input.update 
      # mise à jour des données
      update()
    end
    # gèle de l'écran
    Graphics.freeze
  end
  #-------------------------------------------------------------
  # Méthode de screen shot pour le découpage
  #-------------------------------------------------------------
  def screenshot
    # Prise du screen_shot
    Screen.shot_new("temp",0) 
    # Chargement dans un Bitmap
    @screen = Bitmap.new("temp.bmp") 
    # Suppression du fichier temporaire
    File.delete("temp.bmp") 
    # Initialisation du tableau des sprites
    @sprites = [] 
    @sprites[0] = Sprite.new
    @sprites[0].x = 0
    @sprites[0].bitmap = Bitmap.new(320,480)
    @sprites[0].bitmap.blt(0, 0, @screen,Rect.new(0,0,320,480))
    @sprites[1] = Sprite.new
    @sprites[1].x = 320
    @sprites[1].bitmap = Bitmap.new(320,480)
    @sprites[1].bitmap.blt(0, 0, @screen,Rect.new(320,0,320,480))
  end
  #-------------------------------------------------------------
  # Mise à jour
  #-------------------------------------------------------------
  def update
    # arrêt potentiel de la scène
    @continue = false
    @sprites[0].x -= @vx
    @sprites[0].y -= @vy
    @sprites[1].x += @vx
    @sprites[1].y -= @vy
    if @sprites[0].x < -320 or @sprites[0].y < -480 or @sprites[0].y > 480
      @continue = true
      @sprites[0].dispose
      @sprites[1].dispose
    end
    # Termine la scène si la touche action
    # (entrer) est appuyée
    finish if (@continue) or Input.trigger?(Input::C) 
  end
  #-------------------------------------------------------------
  # Méthode de fin de scène
  #-------------------------------------------------------------
  def finish
    $scene = @next_scene
  end
end
Utilisation
Par défaut, la transition vers le combat est sur l'explosion, mais en changeant la variable [color=gold]$transition_id en première ligne du script ou dans un event ou n'importe ou, vous pourrez changer de transition !
1- Explosion
2- Zoom
3- Dézoom
4- Rideau

Tout est expliqué dans le script pour le reste, have fun !