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

Domaine concerné: Script
Logiciel utilisé: Rpg Maker Vx Ace
Salut les poulets.

Voilà donc j'ai ces deux scripts

Le premier est le script 8dir de JV Master.

#==============================================================================
# 8 Dir Move                                                  JV Master Script
#------------------------------------------------------------------------------
# Make player move in 8 dir, supports diagonal pattern.
#==============================================================================
 
module JvScripts
  module Dirs8
    
    Switch = 0               # Switch id for toggle 4/8 dir, 0 if always 8 dir
    DiagonalSuffix = "_di"   # Suffix for 8 dir charsets
                             # 8 dir charsets include in the first char
                             # the orthogonal and in the second the diagonal
  end
end
 
#==============================================================================
# Game CharacterBase
#==============================================================================
class Game_CharacterBase
  
  def move_diagonal(horz, vert)
    @move_succeed = diagonal_passable?(x, y, horz, vert)
    if @move_succeed
      @x = $game_map.round_x_with_direction(@x, horz)
      @y = $game_map.round_y_with_direction(@y, vert)
      @real_x = $game_map.x_with_direction(@x, reverse_dir(horz))
      @real_y = $game_map.y_with_direction(@y, reverse_dir(vert))
      increase_steps
    end
    if diagonal_charset?
      set_direction_diagonal(horz, vert)
    else
      set_direction(horz) if @direction == reverse_dir(horz)
      set_direction(vert) if @direction == reverse_dir(vert)
    end
  end
  
  def set_direction(d)
    if !@direction_fix && d != 0
      @direction = d
      @character_index = 0 if diagonal_charset?
    end
    @stop_count = 0
  end
  
  def set_direction_diagonal(horz, vert)
    if !@direction_fix && horz != 0 && vert != 0
      if horz == 4 && vert == 2
        @direction = 2
      elsif horz == 4 && vert == 8
        @direction = 4
      elsif horz == 6 && vert == 2
        @direction = 6
      elsif horz == 6 && vert == 8
        @direction = 8
      end
      
      @character_index = 1
    end
    @stop_count = 0
  end
  
  def diagonal_charset?
    true if @character_name.include?(JvScripts::Dirs8::DiagonalSuffix)
  end
end
 
#==============================================================================
# Game Player
#==============================================================================
class Game_Player < Game_Character
  def move_by_input
    return if !movable? || $game_map.interpreter.running?
    if JvScripts::Dirs8::Switch > 0
      if $game_switches[JvScripts::Dirs8::Switch] == true
        case Input.dir8
        when 2, 4, 6, 8
          move_straight(Input.dir4)
        when 1
          move_diagonal(4, 2)
        when 3
          move_diagonal(6, 2)
        when 7
          move_diagonal(4, 8)
        when 9
          move_diagonal(6, 8)
        end
      else
        move_straight(Input.dir4) if Input.dir4 > 0
      end
    else
      if Input.dir8 > 0
        case Input.dir8
        when 2, 4, 6, 8
          move_straight(Input.dir4)
        when 1
          move_diagonal(4, 2)
        when 3
          move_diagonal(6, 2)
        when 7
          move_diagonal(4, 8)
        when 9
          move_diagonal(6, 8)
        end
      end
    end
  end
end
#==============================================================================

#====================================================================
# Mode 7 Ace Addon : Map Rotation
# v.1.6
# Auteur : MGC
#
# Cet addon pour le script Mode 7 Ace permet d'effectuer
# une rotation de la carte
#
# Nécessite :
# - le script "Mode 7 Ace" du même auteur en V.1.8 minimum, placé
#   au-dessus de ce script
#
# Configuration :
# - MODE7_DEFAULT_ROT_ANGLE : valeur d'angle de rotation par défaut qui
#         s'applique dès le passage en mode 7. Compris entre 0 et 360.
#
# Utilisation :
# Commandes utilisables comme commandes d'évènement avec Script... :
# - MGC.to_rot_angle(nouvel angle, durée de transition, sens de rotation)
# le sens de rotation prend pour valeur -1 ou 1
# - MGC.rotate_by(angle, durée de transition) : effectue une rotation d'un
# certain angle par rapport à l'angle actuel 
#
# Optionnellement, dans le nom de la carte (prioritaire par rapport à MODE7_DEFAULT_ROT_ANGLE)
# - [Rx], où x est un entier entre 0 et 360 : angle de rotation de la carte
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * CONFIGURATION
  #--------------------------------------------------------------------------
  MODE7_DEFAULT_ROT_ANGLE = 0
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  class << self
    unless @already_aliased_mgc_m7a_addon_rotation
      alias initialize_mode7_mgc_m7a_addon_rotation initialize_mode7
      alias start_change_map_mgc_m7a_addon_rotation start_change_map
      alias update_mode7_mgc_m7a_addon_rotation update_mode7
      alias effect_mgc_m7a_addon_rotation? effect?
      @already_aliased_mgc_m7a_addon_rotation = true
    end
  end
  #--------------------------------------------------------------------------
  # * Initialisation des données du mode 7
  #--------------------------------------------------------------------------
  def self.initialize_mode7
    self.rot_angle = $game_system.rot_angle ? $game_system.rot_angle :
    $game_map.get_default_rot_angle
    @rot_angle_duration = 0
    initialize_mode7_mgc_m7a_addon_rotation
    @mode7_data << 0 # 10 : cos theta
    @mode7_data << 0 # 11 : sin theta
  end
  #--------------------------------------------------------------------------
  # * Change Map
  #--------------------------------------------------------------------------
  def self.start_change_map
    self.rot_angle = $game_map.get_default_rot_angle
    @rot_angle_duration = 0
    start_change_map_mgc_m7a_addon_rotation
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut rot_angle
  #--------------------------------------------------------------------------
  def self.rot_angle
    return @rot_angle
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut rot_angle
  #--------------------------------------------------------------------------
  def self.rot_angle=(new_rot_angle)
    unless new_rot_angle == @rot_angle
      @rot_angle = new_rot_angle % 360
      @rot_angle_real = @rot_angle
      $game_system.rot_angle = @rot_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Autre setter pour l'attribut rot_angle,
  # ne réinitialisant pas @rot_angle_real
  #--------------------------------------------------------------------------
  def self.set_rot_angle(new_rot_angle)
    unless new_rot_angle == @rot_angle
      @rot_angle = new_rot_angle % 360
      $game_system.rot_angle = @rot_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur de l'angle de rotation
  #--------------------------------------------------------------------------
  def self.incr_rot_angle
    @rot_angle_real += @rot_angle_step
    self.set_rot_angle(@rot_angle_real.to_i)
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de l'angle de rotation
  #--------------------------------------------------------------------------
  def self.to_rot_angle(new_angle, duration, direction = 1)
    unless @rot_angle == new_angle
      new_angle = new_angle % 360
      @rot_angle_duration = duration
      if direction == 1
        if new_angle < @rot_angle
          @rot_angle_step = (360 + new_angle - @rot_angle).to_f / duration
        else
          @rot_angle_step = (new_angle - @rot_angle).to_f / duration
        end
      else
        if new_angle > @rot_angle
          @rot_angle_step = (new_angle - 360 - @rot_angle).to_f / duration
        else
          @rot_angle_step = (new_angle - @rot_angle).to_f / duration
        end
      end
      @target_rot_angle = new_angle
    end
  end
  #--------------------------------------------------------------------------
  # * Rotate by an angle value [1.6]
  #--------------------------------------------------------------------------
  def self.rotate_by(delta_angle, duration)
    if delta_angle < 0
      self.to_rot_angle(@rot_angle + delta_angle, duration, -1)
    else
      self.to_rot_angle(@rot_angle + delta_angle, duration, 1)
    end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour du mode 7
  #--------------------------------------------------------------------------
  def self.update_mode7
    if @mode7_active
      if @rot_angle_duration > 0
        @rot_angle_duration -= 1
        if @rot_angle_duration == 0
          self.rot_angle = @target_rot_angle
        else
          self.incr_rot_angle
        end
        return
      end
    end
    update_mode7_mgc_m7a_addon_rotation
  end
  #--------------------------------------------------------------------------
  # * Vérifie si un effet est en cours
  #--------------------------------------------------------------------------
  def self.effect?
    return @mode7_active && @rot_angle_duration > 0 ||
    effect_mgc_m7a_addon_rotation?
  end
  #==============================================================================
  # ** MGC::Mode7_Map
  #==============================================================================
  class Mode7_Map
    attr_reader :theta
    #--------------------------------------------------------------------------
    # * Constantes
    #--------------------------------------------------------------------------
    RENDER = Win32API.new("MGC_Mode7_Ace_Rot_1_8", "renderMode7", "l", "l") # [1.3][1.4]
    #--------------------------------------------------------------------------
    # * Aliased methods
    #--------------------------------------------------------------------------
    unless @already_aliased_mgc_m7a_addon_rotation
      alias initialize_mgc_m7a_addon_rotation initialize
      alias update_mgc_m7a_addon_rotation update
      @already_aliased_mgc_m7a_addon_rotation = true
    end
    #--------------------------------------------------------------------------
    # * Initialisation
    #--------------------------------------------------------------------------
    def initialize(viewport)
      initialize_mgc_m7a_addon_rotation(viewport)
      @parameters << 0 # 39 : cos theta [1.4]
      @parameters << 0 # 40 : sin theta [1.4]
      m7_data = Table.new(6, Graphics.height)
      @parameters[20] = m7_data
      MGC.mode7_data[9] = m7_data
      self.theta = 0
    end
    #--------------------------------------------------------------------------
    # * Refresh all the parameters dependent on the angle of rotation
    #--------------------------------------------------------------------------
    def refresh_theta
      theta_rad = (Math::PI * theta) / 180
      cos_theta_real = Math.cos(theta_rad)
      sin_theta_real = Math.sin(theta_rad)
      cos_theta = (2048 * cos_theta_real).to_i
      sin_theta = (2048 * sin_theta_real).to_i
      parameters[39] = cos_theta # [1.4]
      parameters[40] = sin_theta # [1.4]
      parameters[29] = MODE7_SCAN_STEP
      MGC.mode7_data[10] = cos_theta_real
      MGC.mode7_data[11] = sin_theta_real
      @need_refresh = true
    end
    #--------------------------------------------------------------------------
    # * Setter pour l'attribut theta
    #--------------------------------------------------------------------------
    def theta=(new_theta)
      unless new_theta == theta
        @theta = new_theta
        refresh_theta
      end
    end
    #--------------------------------------------------------------------------
    # * Mise à jour, appelée normalement à chaque frame
    #--------------------------------------------------------------------------
    def update
      if @visible
        self.theta = MGC.rot_angle
      end
      update_mgc_m7a_addon_rotation
    end
  end
end
 
#==============================================================================
# ** Game_System
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_accessor :rot_angle
end
 
#==============================================================================
# ** Game_Map
#==============================================================================
class Game_Map
  #--------------------------------------------------------------------------
  # * Get default rotation angle
  #--------------------------------------------------------------------------
  def get_default_rot_angle
    if $data_mapinfos[@map_id].full_name[/\[R(\d+)\]/]
      return $1.to_i % 360
    else
      return MGC::MODE7_DEFAULT_ROT_ANGLE
    end
  end
end
 
#==============================================================================
# ** Sprite_Character
#==============================================================================
class Sprite_Character < Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a_addon_rotation
    alias update_src_rect_mgc_m7a_addon_rotation update_src_rect
    @already_aliased_mgc_m7a_addon_rotation = true
  end
  #--------------------------------------------------------------------------
  # * Update Transfer Origin Rectangle
  #--------------------------------------------------------------------------
  def update_src_rect
    if MGC.mode7_active
      if @tile_id == 0
        index = character.character_index
        pattern = character.pattern < 3 ? character.pattern : 1
        sx = (index % 4 * 3 + pattern) * @cw
        unless character.direction_fix
          current_direction = character.direction - 2 >> 1
          directions_list = [0, 2, 3, 1]
          current_direction = directions_list[(directions_list.index(current_direction) +
          ((MGC.rot_angle + 45) % 360) / 90) % 4]
          sy = current_direction * @ch
        else
          sy = (character.direction - 2 >> 1) * @ch
        end
        sy += (index >> 2 << 2) * @ch
        self.src_rect.set(sx, sy, @cw, @ch)
      end
    else
      update_src_rect_mgc_m7a_addon_rotation
    end
  end
  #--------------------------------------------------------------------------
  # * Update Position In Mode7
  #--------------------------------------------------------------------------
  def update_mode7
    if @character.tile_id == 0 && character.character_name == "" # [1.5]
      @force_mode7_invisible = true
      return
    end
    y_screen = character.screen_y +
    (character.is_a?(Game_Vehicle) ? character.altitude : 0)
    yr = MGC.mode7_data[2] * (y_screen - MGC.mode7_data[0])
    xr = MGC.mode7_data[2] * (character.screen_x - (Graphics.width >> 1))
    y_init = (yr * MGC.mode7_data[10] - xr * MGC.mode7_data[11]).to_i
    if y_init < - (MGC::MODE7_VIEW_LIMIT << 5) - MGC.mode7_data[0] ||
      y_init > Graphics.height
    then
      @force_mode7_invisible = true
      return
    else
      @force_mode7_invisible = false
    end
    x_init = (yr * MGC.mode7_data[11] + xr * MGC.mode7_data[10]).to_i
    self.y = (MGC.mode7_data[0] + (MGC.mode7_data[5] * y_init *
    MGC.mode7_data[3]) / (MGC.mode7_data[5] - y_init * MGC.mode7_data[4])).to_i
    zx = MGC.mode7_data[6] * y + MGC.mode7_data[7]
    self.x = ((Graphics.width >> 1) + zx * x_init).to_i
    @phase_mode7 = true
    self.zoom_x = MGC.mode7_data[2] * zx
    self.zoom_y = zoom_x_real
    @phase_mode7 = false
    self.z = @character.screen_z + (y << 8) # [1.4]
    if character.is_a?(Game_Vehicle)
      self.y -= character.altitude * zoom_y_real
    end
  end
end
 
module MGC
  #==============================================================================
  # ** MGC::Vertical_Tile [1.4]
  #==============================================================================
  class Vertical_Tile
    #--------------------------------------------------------------------------
    # * Update Position In Mode7
    #--------------------------------------------------------------------------
    def update_mode7
      x_scr = 32 * $game_map.adjust_x(x.to_f / 32)
      y_scr = 32 * $game_map.adjust_y(y.to_f / 32)
      yr = MGC.mode7_data[2] * (y_scr - MGC.mode7_data[0])
      xr = MGC.mode7_data[2] * (x_scr - (Graphics.width >> 1))
      y_init = (yr * MGC.mode7_data[10] - xr * MGC.mode7_data[11]).to_i
      if y_init < - (MGC::MODE7_VIEW_LIMIT << 5) - MGC.mode7_data[0] ||
        y_init > Graphics.height
      then
        @force_invisible = true
        return
      else
        @force_invisible = false
      end
      x_init = (yr * MGC.mode7_data[11] + xr * MGC.mode7_data[10]).to_i
      self.screen_y = (MGC.mode7_data[0] + (MGC.mode7_data[5] * y_init *
      MGC.mode7_data[3]) / (MGC.mode7_data[5] - y_init * MGC.mode7_data[4])).to_i
      zx = MGC.mode7_data[6] * screen_y + MGC.mode7_data[7]
      self.screen_x = ((Graphics.width >> 1) + zx * x_init).to_i
      self.zoom = MGC.mode7_data[2] * zx
    end
  end
end

Comme vous le voyez sur cette vidéo...
https://www.youtube.com/watch?v=F58HcBa1lao
... la rotation de la caméra ne prend pas en compte le script 8dir

Un scripteur pour corriger ça ?
Merci d'avance !