【>A<】截圖存檔腳本衝突

duzine · 发表于 2016-8-17 17:15:04

加入我们，或者，欢迎回来。

您需要登录才可以下载或查看，没有账号？注册会员

×

本帖最后由 duzine 于 2016-8-17 20:49 编辑

其實大概去年就知道衝突了，只是今天才心血來潮把衝突的腳本給找到
我想了很久，我真的希望這兩個優秀的腳本能夠共存，請求高手相助!

截圖存檔腳本
[pre lang="ruby"]#==============================================================================
# [PS0]截图存档
#    Window_SaveFile_Plus
#------------------------------------------------------------------------------
# 　一种带有截图的存档，同时可以自定义存档数量。
#==============================================================================
# [核心脚本]
# - 快速储存Bitmap的Marshal       By 柳之一
#------------------------------------------------------------------------------
# [更新记录]
# - 2012.01.28 By 各种压力的猫君
#    * 去掉效率较差的双线性缩放算法;
#    * 新增存档管理功能（F5键，复制/移动/删除存档）
# - 2011.12.27 By 各种压力的猫君
#    * 补上截图阴影；
#    * 新增“不缩放”截图（推荐使用，尤其是大分辨率）；
#    * 修正选择不存在的存档时存档列表窗口卡死以及奇怪的SE；
#    * 新增“存档中”提示窗口、覆盖存档提示、删除存档功能(Z键，对应键盘D)
# - 2011.12.26 By 各种压力的猫君
#    * 功能齐全的测试版
# - 2011.12.16 By 各种压力的猫君
#    * 移植至RGSS3，遵循PS0协议；
#    * 丰富自定义选项，整合双线性插值算法精简版
# - 2008.05.26 By 沉影不器
#    * 蓝本（VX新截图存档）
#------------------------------------------------------------------------------
# [使用方法]
# - 将本脚本插入到MAIN以上
# - 删除原Scene_File、Window_SaveFile（或确保本脚本位于上述两个脚本以下）
#==============================================================================
$_PS0 = {} if $_PS0 == nil
$_PS0["Window_SaveFile_Plus"] = 20120128
#==============================================================================
# [PS0] 通用配置模块
#==============================================================================
module PS0
  module Window_SaveFile_Plus

# 最大存档数（范围正整数）
MAX_SAVE = 99

# 存档目录（默认值 "Saves/"；根目录 ""）
SAVE_DIR = "Save/"

# 无存档时显示的文字
NO_DATA  = "无存档"

# 保存时显示的信息
SAVE_NOW = "存档中..."

# 复制存档时的帮助文字
HELP_COPY = "要复制到哪个位置？"

# 移动存档时的帮助文字
HELP_MOVE = "要移动到哪个位置？"

# 是否显示存档中窗口（true:显示；false:不显示）
# - 分辨率较大时建议显示
SHOW_SAVE_NOW = false

# 截图缩放使用的插值算法
# - "NN" 最邻近（速度最快，质量最差，RM默认算法）
# - "NZ" 不缩放（速度快，质量好，以主角为中心切边，非全屏）
Zoom_Type = "NN"

# 双线性插值能获得更好的截图缩放质量，但所需时间较最邻近插值更长。
# 缩略图尺寸（范围整数，单位像素）
# - VA默认分辨率（544×416）推荐使用340×260
# - VA最大分辨率（640×480）推荐使用425×325
# - 本脚本兼容分辨率解放，窗口大小将自动计算。
# 请自行计算截图分辨率，注意要确保宽高比一致，
# 若使用“不缩放”模式则可以不保持一致。
Thumbnail_Width  = 425  # 宽度
Thumbnail_Height = 325  # 高度

# 缩略图位置微调（范围整数，单位像素）
Thumbnail_ox = -2 # 横向
Thumbnail_oy = -2-32 # 纵向

# 各窗口切换时的渐变帧数
TRANS_DURATION = 5

  end
end
#==============================================================================
# [核心脚本] 快速储存Bitmap的Marshal By 柳之一
#==============================================================================
class Font
  def marshal_dump
  end
  def marshal_load(obj)
  end
end
class Bitmap
  RtlMoveMemory_pi = Win32API.new('kernel32', 'RtlMoveMemory', 'pii', 'i')
  RtlMoveMemory_ip = Win32API.new('kernel32', 'RtlMoveMemory', 'ipi', 'i')
  def _dump(limit)
data = "rgba" * width * height
RtlMoveMemory_pi.call(data, address, data.length)
[width, height, Zlib::Deflate.deflate(data)].pack("LLa*")
  end
  def self._load(str)
w, h, zdata = str.unpack("LLa*")
b = self.new(w, h)
RtlMoveMemory_ip.call(b.address, Zlib::Inflate.inflate(zdata), w * h * 4)
return b
  end
  def address
buffer, ad = "rgba", object_id * 2 + 16
RtlMoveMemory_pi.call(buffer, ad, 4)
ad = buffer.unpack("L")[0] + 8
RtlMoveMemory_pi.call(buffer, ad, 4)
ad = buffer.unpack("L")[0] + 16
RtlMoveMemory_pi.call(buffer, ad, 4)
return buffer.unpack("L")[0]
  end
end
#==============================================================================
# ■ Game_Temp
#==============================================================================
class Game_Temp
  attr_accessor :save_bitmap
  attr_accessor :save_snapshoot
  alias new_initialize initialize
  def initialize
new_initialize
@save_bitmap = Bitmap.new(1, 1)
@save_snapshoot = Bitmap.new(1, 1)
  end
end
#==============================================================================
# ■ SceneManager
#==============================================================================
module SceneManager
  def self.snapshot_for_save
$game_temp.save_bitmap = Graphics.snap_to_bitmap
unless FileTest.exist?(PS0::Window_SaveFile_Plus::SAVE_DIR)
   Dir.mkdir(PS0::Window_SaveFile_Plus::SAVE_DIR)
end
  end
end
#==============================================================================
# ■ Scene_Map
#==============================================================================
class Scene_Map < Scene_Base
  alias save_terminate terminate
  def terminate
SceneManager.snapshot_for_save
save_terminate
  end
end
#==============================================================================
# ■ DataManager
#==============================================================================
module DataManager
  def self.save_file_exists?
!Dir.glob(PS0::Window_SaveFile_Plus::SAVE_DIR + 'Save*.rvdata2').empty?
  end
  def self.make_filename(index)
sprintf(PS0::Window_SaveFile_Plus::SAVE_DIR + "Save%02d.rvdata2", index + 1)
  end
  #--------------------------------------------------------------------------
  # ● セーブヘッダの作成
  #--------------------------------------------------------------------------
  def self.make_save_header
d_rect = Rect.new(0, 0, PS0::Window_SaveFile_Plus::Thumbnail_Width,
                        PS0::Window_SaveFile_Plus::Thumbnail_Height)
case PS0::Window_SaveFile_Plus::Zoom_Type
when "NN"
   s_rect = $game_temp.save_bitmap.rect
   $game_temp.save_snapshoot = Bitmap.new(d_rect.width, d_rect.height)
   $game_temp.save_snapshoot.stretch_blt(d_rect, $game_temp.save_bitmap, s_rect)
when "NZ"
   x = [[$game_player.screen_x - d_rect.width/2, 0].max, Graphics.width].min
   y = [[$game_player.screen_y - d_rect.height/2, 0].max, Graphics.height].min
   s_rect = Rect.new(x, y, d_rect.width, d_rect.height)
   $game_temp.save_snapshoot = Bitmap.new(d_rect.width, d_rect.height)
   $game_temp.save_snapshoot.blt(0, 0, $game_temp.save_bitmap, s_rect)
end
header = {}
header[:characters] = $game_party.characters_for_savefile
header[:playtime_s] = $game_system.playtime_s
header[:snapshoot]  = $game_temp.save_snapshoot
header
  end
  #--------------------------------------------------------------------------
  # ● セーブの実行
  #--------------------------------------------------------------------------
  def self.save_game(index)
saving_window = Window_Saving.new
Graphics.update
begin
   save_game_without_rescue(index)
rescue
   delete_save_file(index)
   false
end
saving_window.dispose
return true
  end
end
#==============================================================================
# ■ Window_Yes_Or_No
#------------------------------------------------------------------------------
# 　提供“是”、“否”两个选项的窗口（替换、删除存档用）
#==============================================================================
class Window_Yes_Or_No < Window_HorzCommand
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(yes, no)
@yes = yes
@no = no
super(130, 0)
self.visible = false
self.active = false
@index = 0
  end
  #--------------------------------------------------------------------------
  # ● 桁数の取得
  #--------------------------------------------------------------------------
  def col_max
return 2
  end
  #--------------------------------------------------------------------------
  # ● コマンドリストの作成
  #--------------------------------------------------------------------------
  def make_command_list
add_command(@yes, :yes)
add_command(@no, :cancel)
  end
  #--------------------------------------------------------------------------
  # ● 決定ボタンが押されたときの処理
  #--------------------------------------------------------------------------
  def process_ok
Input.update
call_ok_handler
  end
  #--------------------------------------------------------------------------
  # ● 按下取消键时的处理
  #--------------------------------------------------------------------------
  def process_cancel
Input.update
call_cancel_handler
  end
  #--------------------------------------------------------------------------
  # ● 启用窗口
  #--------------------------------------------------------------------------
  def activate
temp = self.y + self.height - Graphics.height
if temp > 0
   self.y -= (temp + 12)
end
self.active = true
self
  end
end
#==============================================================================
# ■ Window_Saving
#------------------------------------------------------------------------------
# 　显示保存信息的窗口
#==============================================================================
class Window_Saving < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize
w = PS0::Window_SaveFile_Plus::SAVE_NOW.length * 16 + 32
x = (Graphics.width - w)/2
y = (Graphics.height - fitting_height(1))/2
super(x, y, w, fitting_height(1))
self.visible = PS0::Window_SaveFile_Plus::SHOW_SAVE_NOW
draw_text_ex(4, 0, PS0::Window_SaveFile_Plus::SAVE_NOW)
  end
end
#==============================================================================
# ■ Window_SaveManagerCommand
#------------------------------------------------------------------------------
# 　存档管理窗口
#==============================================================================
class Window_SaveManagerCommand < Window_Command
  #--------------------------------------------------------------------------
  # ● 初始化对象
  #--------------------------------------------------------------------------
  def initialize(*args)
@copy, @move, @delete, @cancel = args[0..3]
super(130, 0)
self.visible = false
self.active = false
@index = 0
  end
  #--------------------------------------------------------------------------
  # ● 获取窗口的宽度
  #--------------------------------------------------------------------------
  def window_width
return 100
  end
  #--------------------------------------------------------------------------
  # ● 获取项目数
  #--------------------------------------------------------------------------
  def item_max
return 4
  end
  #--------------------------------------------------------------------------
  # ● 生成指令列表
  #--------------------------------------------------------------------------
  def make_command_list
add_command(@copy, :copy  )
add_command(@move, :move  )
add_command(@delete, :delete)
add_command(@cancel, :cancel)
  end
  #--------------------------------------------------------------------------
  # ● 按下确定键时的处理
  #--------------------------------------------------------------------------
  def process_ok
Input.update
call_ok_handler
  end
  #--------------------------------------------------------------------------
  # ● 启用窗口
  #--------------------------------------------------------------------------
  def activate
temp = self.y + self.height - Graphics.height
if temp > 0
   self.y -= (temp + 12)
end
self.active = true
self
  end
end
#==============================================================================
# ■ Window_FileCommand
#------------------------------------------------------------------------------
# 　截图存档左侧的选择窗口。
#==============================================================================
class Window_FileCommand < Window_Command
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize
super(0, 0)
  end
  #--------------------------------------------------------------------------
  # ● ウィンドウ幅の取得
  #--------------------------------------------------------------------------
  def window_height
return Graphics.height-fitting_height(1)
  end
  #--------------------------------------------------------------------------
  # ● 表示行数の取得
  #--------------------------------------------------------------------------
  def visible_line_number
item_max
  end
  #--------------------------------------------------------------------------
  # ● コマンドリストの作成
  #--------------------------------------------------------------------------
  def make_command_list
add_main_commands
  end
  #--------------------------------------------------------------------------
  # ● 主要コマンドをリストに追加
  #--------------------------------------------------------------------------
  def add_main_commands
for i in 1..PS0::Window_SaveFile_Plus::MAX_SAVE
   if i < 10
      text = Vocab::File + " 0" + i.to_s
   else
      text = Vocab::File + " " + i.to_s
   end
   add_command(text, :file)
end
  end
  #--------------------------------------------------------------------------
  # ● 決定ボタンが押されたときの処理
  #--------------------------------------------------------------------------
  def process_ok
  end
end
#==============================================================================
# ■ Window_SaveFile
#------------------------------------------------------------------------------
# 　セーブ画面およびロード画面で表示する、セーブファイルのウィンドウです。
#==============================================================================
class Window_SaveFile < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    index : セーブファイルのインデックス
  #--------------------------------------------------------------------------
  def initialize(index)
super(160, 0, Graphics.width-160, Graphics.height-fitting_height(1))
@file_index = index
@selected = true
refresh
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
contents.clear
change_color(normal_color)
w = (self.width-PS0::Window_SaveFile_Plus::Thumbnail_Width-16)/2
h = (self.height-PS0::Window_SaveFile_Plus::Thumbnail_Height-16)/2
width  = w + PS0::Window_SaveFile_Plus::Thumbnail_ox
height = h + PS0::Window_SaveFile_Plus::Thumbnail_oy
draw_shadow(width+5, height+5)
draw_text((self.width-32-PS0::Window_SaveFile_Plus::NO_DATA.length*16)/2,
            self.height/2-32, PS0::Window_SaveFile_Plus::NO_DATA.length*32,
            line_height, PS0::Window_SaveFile_Plus::NO_DATA)
draw_party_characters(32, Graphics.height-fitting_height(1)-32)
draw_playtime(-10, contents.height - line_height-10, contents.width - 4, 2)
draw_snapshoot(width, height)
  end
  #--------------------------------------------------------------------------
  # ● パーティキャラの描画
  #--------------------------------------------------------------------------
  def draw_party_characters(x, y)
header = DataManager.load_header(@file_index)
return unless header
header[:characters].each_with_index do |data, i|
   draw_character(data[0], data[1], x + i * 48, y)
end
  end
  #--------------------------------------------------------------------------
  # ● プレイ時間の描画
  #--------------------------------------------------------------------------
  def draw_playtime(x, y, width, align)
header = DataManager.load_header(@file_index)
return unless header
draw_text(x, y, width, line_height, header[:playtime_s], 2)
  end
  #--------------------------------------------------------------------------
  # ● 绘制截图
  #--------------------------------------------------------------------------
  def draw_snapshoot(x, y)
header = DataManager.load_header(@file_index)
return unless header
bitmap = header[:snapshoot]
contents.blt(x, y, bitmap, bitmap.rect)
bitmap.dispose
  end
  #--------------------------------------------------------------------------
  # ● 绘制阴影
  #--------------------------------------------------------------------------
  def draw_shadow(x, y)
header = DataManager.load_header(@file_index)
return unless header
contents.fill_rect(x, y, PS0::Window_SaveFile_Plus::Thumbnail_Width,
                           PS0::Window_SaveFile_Plus::Thumbnail_Height, Color.new(0, 0, 0))
contents.blur
  end
end
#==============================================================================
# ■ Scene_File
#------------------------------------------------------------------------------
# 　セーブ画面とロード画面の共通処理を行うクラスです。
#==============================================================================
class Scene_File < Scene_MenuBase
  #--------------------------------------------------------------------------
  # ● 開始処理
  #--------------------------------------------------------------------------
  def start
super
create_help_window
create_savefile_viewport
create_command_window
create_savefile_window
create_manager_window
create_replace_window
create_delete_window
  end
  #--------------------------------------------------------------------------
  # ● 終了処理
  #--------------------------------------------------------------------------
  def terminate
super
@savefile_viewport.dispose
@savefile_window.dispose
@command_window.dispose
@window_manager.dispose
@window_replace.dispose
@window_delete.dispose
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
super
update_savefile_selection
  end
  #--------------------------------------------------------------------------
  # ● 创建替换窗口
  #--------------------------------------------------------------------------
  def create_replace_window
@window_replace = Window_Yes_Or_No.new("替换", "取消")
@window_replace.set_handler(:yes, method(:do_replace))
@window_replace.set_handler(:cancel, method(:do_cancel))
  end
  #--------------------------------------------------------------------------
  # ● 创建删除窗口
  #--------------------------------------------------------------------------
  def create_delete_window
@window_delete  = Window_Yes_Or_No.new("删除", "取消")
@window_delete.set_handler(:yes, method(:do_delete))
@window_delete.set_handler(:cancel, method(:do_return_manager))
@window_delete.x += 40
  end
  #--------------------------------------------------------------------------
  # ● 创建管理窗口
  #--------------------------------------------------------------------------
  def create_manager_window
@window_manager = Window_SaveManagerCommand.new("复制", "移动", "删除", "取消")
@window_manager.set_handler(:copy  , method(:on_copy?))
@window_manager.set_handler(:move  , method(:on_move?))
@window_manager.set_handler(:delete, method(:on_delete?))
@window_manager.set_handler(:cancel, method(:do_cancel))
  end
  #--------------------------------------------------------------------------
  # ● ヘルプウィンドウの作成
  #--------------------------------------------------------------------------
  def create_help_window
@help_window = Window_Help.new(1)
@help_window.set_text(help_window_text)
  end
  #--------------------------------------------------------------------------
  # ● ヘルプウィンドウのテキストを取得
  #--------------------------------------------------------------------------
  def help_window_text
return ""
  end
  #--------------------------------------------------------------------------
  # ● セーブファイルビューポートの作成
  #--------------------------------------------------------------------------
  def create_savefile_viewport
@savefile_viewport = Viewport.new
@savefile_viewport.rect.y = @help_window.height
@savefile_viewport.rect.height -= @help_window.height
  end
  #--------------------------------------------------------------------------
  # ● セーブファイルウィンドウの作成
  #--------------------------------------------------------------------------
  def create_savefile_window
@savefile_window = Window_SaveFile.new(@index)
@savefile_window.viewport = @savefile_viewport
  end
  #--------------------------------------------------------------------------
  # ● 生成存档列表窗口
  #--------------------------------------------------------------------------
  def create_command_window
@command_window = Window_FileCommand.new
@command_window.index = first_savefile_index
@index = @command_window.index
@command_window.viewport = @savefile_viewport
@command_window.set_handler(:file,    method(:on_savefile_ok))
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル選択の更新
  #--------------------------------------------------------------------------
  def update_savefile_selection
if @source_index != nil
   if Input.trigger?(:C)
      if @index == @source_index
      Sound.play_buzzer
      elsif FileTest.exist?(DataManager.make_filename(@index))
      Graphics.freeze
      @command_window.deactivate
      @window_replace.y = 72 + @index * 24
      @window_replace.activate
      @window_replace.visible = true
      @window_replace.refresh
      Sound.play_ok
      Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
      else
      return on_copy_ok
      end
   elsif Input.trigger?(:B)
      return do_return_manager
   end
else
   if Input.trigger?(:C)
      if self.is_a?(Scene_Save) and FileTest.exist?(DataManager.make_filename(@index))
      Graphics.freeze
      @command_window.deactivate
      @window_replace.y = 72 + @index * 24
      @window_replace.activate
      @window_replace.visible = true
      @window_replace.refresh
      Sound.play_ok
      Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
      else
      return on_savefile_ok
      end
   elsif Input.trigger?(:B)
      return on_savefile_cancel
   elsif Input.trigger?(:F5)
      unless @window_manager.active == true or
            @window_delete.active == true or
            @window_replace.active == true
      return on_manager?
      end
   end
end
@need_refresh = true if @index != @command_window.index
if @need_refresh
   Graphics.freeze
   @index = @command_window.index
   @savefile_window.dispose
   create_savefile_window
   @need_refresh = false
   Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
end
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル［決定］
  #--------------------------------------------------------------------------
  def on_savefile_ok
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル［キャンセル］
  #--------------------------------------------------------------------------
  def on_savefile_cancel
Sound.play_cancel
return_scene
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル［決定］
  #--------------------------------------------------------------------------
  def on_copy_ok
Graphics.freeze
source_name = DataManager.make_filename(@source_index)
new_name = DataManager.make_filename(@index)
case @source_type
when "copy"
   # 复制存档文件（API）
   Win32API.new('kernel32',"CopyFileA",'ppl','').call(source_name,new_name,0)
when "move"
   # 重命名存档
   File.rename(source_name, new_name)
end
# 返回
@help_window.set_text(help_window_text)
@source_index = nil
do_return_savelist
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル［复制］
  #--------------------------------------------------------------------------
  def on_copy?
Graphics.freeze
@help_window.set_text(PS0::Window_SaveFile_Plus::HELP_COPY)
@source_index = @index
@source_type = "copy"
do_return_savelist
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル［移动］
  #--------------------------------------------------------------------------
  def on_move?
Graphics.freeze
@help_window.set_text(PS0::Window_SaveFile_Plus::HELP_MOVE)
@source_index = @index
@source_type = "move"
do_return_savelist
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル［管理］
  #--------------------------------------------------------------------------
  def on_manager?
if FileTest.exist?(DataManager.make_filename(@index))
   Graphics.freeze
   @command_window.deactivate
   @window_manager.y = 72 + @index * 24
   @window_manager.activate
   @window_manager.visible = true
   @window_manager.refresh
   Sound.play_ok
   Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
else
   Sound.play_buzzer
end
  end
  #--------------------------------------------------------------------------
  # ● セーブファイル［删除］
  #--------------------------------------------------------------------------
  def on_delete?
Graphics.freeze
@window_manager.deactivate
@command_window.deactivate
@window_delete.y = 72 + 72 + @index * 24
@window_delete.activate
@window_delete.visible = true
@window_delete.refresh
Sound.play_ok
Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
  end
  #--------------------------------------------------------------------------
  # ● 删除
  #--------------------------------------------------------------------------
  def do_delete
Graphics.freeze
File.delete(DataManager.make_filename(@index))
@window_delete.index  = 0
@window_manager.index = 0
@window_delete.visible  = false
@window_manager.visible = false
@window_delete.deactivate
@window_manager.deactivate
@command_window.activate
@need_refresh = true
Sound.play_save
if DataManager.save_file_exists?
   Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
else
   return_scene
end
  end
  #--------------------------------------------------------------------------
  # ● 替换
  #--------------------------------------------------------------------------
  def do_replace
Graphics.freeze
if @source_index != nil
   return on_copy_ok
else
   return on_savefile_ok
end
@window_replace.visible = false
@window_replace.deactivate
@need_refresh = true
  end
  #--------------------------------------------------------------------------
  # ● 取消
  #--------------------------------------------------------------------------
  def do_cancel
Graphics.freeze
Sound.play_cancel
@window_delete.index  = 0
@window_replace.index = 0
@window_manager.index = 0
@window_delete.visible  = false
@window_replace.visible = false
@window_manager.visible = false
@window_delete.deactivate
@window_replace.deactivate
@window_manager.deactivate
@command_window.activate
Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
  end
  #--------------------------------------------------------------------------
  # ● 返回管理菜单
  #--------------------------------------------------------------------------
  def do_return_manager
Graphics.freeze
@help_window.set_text(help_window_text)
@command_window.index = @source_index unless @source_index == nil
@source_index = nil
@source_type = nil
@command_window.deactivate
@window_delete.index  = 0
@window_replace.index = 0
@window_delete.visible  = false
@window_replace.visible = false
@window_delete.deactivate
@window_replace.deactivate
@window_manager.y = 72 + @index * 24
@window_manager.activate
@window_manager.visible = true
@window_manager.refresh
Sound.play_cancel
Graphics.transition(PS0::Window_SaveFile_Plus::TRANS_DURATION)
  end
  #--------------------------------------------------------------------------
  # ● 返回文件列表（复制、移动用）
  #--------------------------------------------------------------------------
  def do_return_savelist
@window_manager.visible = false
@window_manager.deactivate
@command_window.activate
@need_refresh = true
Sound.play_ok
  end
end
#==============================================================================
# [PS0] End of Script
#==============================================================================[/pre]

兇手腳本： mode 7

[pre lang="ruby"]#====================================================================
# Mode 7 Ace
# v.1.9
# Auteur : MGC
#
# Il s'agit d'un script de mode 7 basique pour RMVX Ace.
#
# - Permet une inclinaison de la carte de 0° à 89°
# - Toute la carte est inclinée, sans relief. Seuls les évènements
# paraissent dressés verticalement.
# - L'effet de colorisation à l'horizon est personnalisable.
# - Les tiles animés sont supportés, ainsi que le bouclage de la carte.
# - possibilité de zoomer (de 1:8 à 8:1) quand le mode 7 est activé.
#
# IMPORTANT : SI VOUS RENCONTREZ DU LAG, VEUILLEZ VOUS ASSURER D'AVOIR
# DECOCHER "REDUCE SCREEN FLICKERING" (F1).
#
# Nécessite :
# - le fichier MGC_Mode7_Ace_1_9.dll à la racine du projet
# - les 3 fichiers graphiques suivants, déposés dans Pictures/ :
#       - autotiles_data.png
#       - autotiles_data_small.png
#       - autotiles_data_xsmall.png
#
# Configuration :
# - MODE7_MAPS_ID : Contient la liste des id des cartes pour lesquelles
#       le mode 7 est appliqué dès l'entrée sur ces cartes
# - MODE7_DEFAULT_ZOOM : valeur de zoom par défaut qui s'applique dès le
#       passage en mode 7. Compris entre 0.125 et 8.0.
# - MODE7_DEFAULT_ANGLE : valeur d'angle d'inclinaison par défaut qui
#       s'applique dès le passage en mode 7. Compris entre 0 et 89.
# - MODE7_VIEW_LIMIT : nombre de tiles supplémentaires à afficher (en plus
#       des 13 pour la vue normale de la carte en 544 * 416) avant l'horizon.
# - MODE7_FADING_DISTANCE : nombre de tiles avant l'horizon subissant un
#       dégradé de ton et/ou d'opacité.
# - MODE7_FADING_TONE : composantes de couleur R, G, B vers lesquelles tend
#       le dégradé de ton à l'horizon. Chaque composantes peut varier
#       entre -255 et 255.
# - MODE7_FADING_OPACITY : opacité vers laquelle tend le dégradé d'opacité ton
#       à l'horizon. Compris entre 255 (pas de dégradé d'opacité) et 0.
# - MODE7_SCAN_STEP : méthode de rafraîchissement de l'écran :
#       - 1 : l'écran est entièrement redessiné en 1 frame. Déconseillé
#             car extrêmement gourmand en ressources.
#       - 2 : l'écran est redessiné en 2 frames (une ligne de l'écran sur
#             deux est dessinée pour chaque frame).
#       - 3 : l'écran est redessiné en 3 frames (une ligne de l'écran sur
#             trois est dessinée pour chaque frame). Conseillé s'il y a
#             trop de lag.
# - MODE7_TERRAIN_TAGS : liste de valeurs de terrain tags pour lesquelles les
#       tiles doivent être dessinés verticalement en mode 7. Si le paramètre
#       MODE7_VERTICAL_TILES_TYPE n'a pas sa valeur égale à 0, utiliser
#       plusieurs valeurs permet de séparer des regroupements de tiles
#       contigus.
# - MODE7_VERTICAL_TILES_TYPE :
#       - 0 : aucun regroupement des tiles verticaux même si des tiles voisins
#             ont le même terrain tag. Pour un tile avec un terrain tag
#             configuré pour être dessiné verticalement, un sprite de
#             dimensions 32*32 est créé. A priori aucun intérêt sans la
#             rotation, car aura le même effet que la valeur 2 mais avec
#             plus de sprites à l'écran, donc plus de ralentissements.
#       - 1 : regroupement des tiles verticaux contigus sur la même colonne
#             ayant le même terrain tag. Un sprite est créé par regroupement,
#             le tile le plus bas du regroupement servant de base au sprite.
#             A priori aucun intérêt sans la rotation, car aura le même effet
#             que la valeur 3 mais avec plus de sprites à afficher.
#       - 2 : regroupement des tiles verticaux contigus sur la même ligne
#             ayant le même terrain tag. Un sprite est créé par regroupement,
#             l'origine horizontale étant fixée au milieu du regroupement.
#       - 3 : regroupement des tiles verticaux contigus ayant le même
#             terrain tag, quelle que soit la ligne ou la colonne. Un sprite
#             est créé par regroupement, le tile le plus bas du regroupement
#             servant de base au sprite et l'origine horizontale étant fixée
#             au milieu du regroupement. Valeur par défaut.
# - MODE7_ALWAYS_DRAW_TILES_ON_MAP :
#       - 0 : les tiles verticaux ne sont pas dessinés couchés sur la carte.
#             Valeur par défaut.
#       - 1 : les tiles verticaux sont également dessinés couchés sur la carte.
# - MODE7_PARALLAXED_MAPS_ID : Contient la liste des id des cartes en mode 7
#       pour lesquelles le panorama est utilisé en tant que couche inférieure.
#       Vous pouvez utiliser un second panorama pour le fond, il faut ajouter
#       dans les notes de la carte le texte suivant : [m7a_pano:nom_du_fichier]
#
# Utilisation :
# Commandes utilisables comme commandes d'évènement avec Script... :
# - MGC.start_mode7 : lance le mode 7 pour la carte
# - MGC.to_mode7_angle(nouvel angle, durée de transition)
# - MGC.to_mode7_zoom(nouvelle valeur de zoom, durée de transition)
# - MGC.end_mode7 : quitte le mode 7
# - MGC.set_mode7_scan(nouvelle valeur) : modifie le paramètre MODE7_SCAN_STEP
#
# Vous pouvez ajouter des commandes dans le nom des cartes pour forcer le
# paramétrage du mode 7 de la carte. Les paramètres dans le nom de la
# carte sont prioritaires par rapport à ceux dans la partie CONFIGURATION
# - [M7] : active le mode 7 pour la carte
# - [Ax], où x est un entier entre 0 et 89 : angle de la carte
# - [Zx], où x est un décimal entre 0.125 et 8.0 : zoom de la carte
# - [FDx], où x est un entier positif : nombre de tiles avant l'horizon
#       subissant un dégradé de ton et/ou d'opacité
# - [FTx,y,z], où x, y et z sont des entiers entre -255 et 255 :
#       composantes de couleur R, G, B vers lesquelles tend le dégradé
#       de ton à l'horizon
# - [FOx], où x est un entier entre 0 et 255 : opacité vers laquelle
#       tend le dégradé d'opacité ton à l'horizon
# - [P] : le panorama est utilisé en tant que couche inférieure de la carte
# Exemple :
# My Worldmap [M7][A55][Z0.5][FD20][FT128,64,-32][FO128]
#====================================================================
module MGC
  #--------------------------------------------------------------------------
  # * CONFIGURATION
  #--------------------------------------------------------------------------
  MODE7_MAPS_ID = []
  MODE7_DEFAULT_ZOOM = 1.0
  MODE7_DEFAULT_ANGLE = 0
  MODE7_VIEW_LIMIT = 26
  MODE7_FADING_DISTANCE = 13
  MODE7_FADING_TONE = Tone.new(64, 64, 128)
  MODE7_FADING_OPACITY = 0
  MODE7_SCAN_STEP = 2
  MODE7_TERRAIN_TAGS = [1, 2] # [1.7]
  MODE7_VERTICAL_TILES_TYPE = 3 # [1.7]
  MODE7_ALWAYS_DRAW_TILES_ON_MAP = 0 # [1.7]
  MODE7_PARALLAXED_MAPS_ID = [] # [1.9]
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  @mode7_zoom = 1.0
  @mode7_active = false
  #--------------------------------------------------------------------------
  # * Lancement du mode 7
  #--------------------------------------------------------------------------
  def self.start_mode7
@end_mode7 = false
@spriteset.start_mode7
  end
  #--------------------------------------------------------------------------
  # * Fin du mode 7
  #--------------------------------------------------------------------------
  def self.end_mode7
@end_mode7 = true
self.to_mode7_zoom(1.0, 1)
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut spriteset
  #--------------------------------------------------------------------------
  def self.spriteset=(spriteset)
@spriteset = spriteset
  end
  #--------------------------------------------------------------------------
  # * Initialisation des données du mode 7
  #--------------------------------------------------------------------------
  def self.initialize_mode7(reset = false) # [1.9]
if reset
   self.mode7_angle = $game_map.get_default_mode7_angle
   @mode7_zoom = $game_map.get_default_mode7_zoom
else
   self.mode7_angle = $game_system.mode7_angle ? $game_system.mode7_angle :
   $game_map.get_default_mode7_angle
   @mode7_zoom = $game_system.mode7_zoom ? $game_system.mode7_zoom :
   $game_map.get_default_mode7_zoom
end
@mode7_angle_duration = 0
@mode7_zoom_incr = Math.log(@mode7_zoom) / Math.log(2)
@mode7_zoom_duration = 0
pivot = (Graphics.height >> 1) + 12
@mode7_data = [pivot, pivot.to_f / Graphics.height, 1.0, 1.0, 0,
Graphics.height, 0, 0, 0, 0]
  end
  #--------------------------------------------------------------------------
  # * Change Map
  #--------------------------------------------------------------------------
  def self.start_change_map
self.mode7_angle = $game_map.get_default_mode7_angle
@mode7_angle_duration = 0
@mode7_zoom = $game_map.get_default_mode7_zoom
@mode7_zoom_incr = Math.log(@mode7_zoom) / Math.log(2)
@mode7_zoom_duration = 0
@change_map = true
  end
  #--------------------------------------------------------------------------
  # * Is Changing Map ?
  #--------------------------------------------------------------------------
  def self.is_changing_map?
return @change_map
  end
  #--------------------------------------------------------------------------
  # * End Change Map
  #--------------------------------------------------------------------------
  def self.end_change_map
@change_map = false
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_data
  #--------------------------------------------------------------------------
  def self.mode7_data
return @mode7_data
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_zoom
  #--------------------------------------------------------------------------
  def self.mode7_zoom
return @mode7_zoom
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_angle
  #--------------------------------------------------------------------------
  def self.mode7_angle
return @mode7_angle
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut mode7_active
  #--------------------------------------------------------------------------
  def self.mode7_active
return @mode7_active
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_active
  #--------------------------------------------------------------------------
  def self.mode7_active=(flag)
$game_system.mode7_active = flag
@mode7_active = flag
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_zoom
  #--------------------------------------------------------------------------
  def self.mode7_zoom=(zoom_value)
unless mode7_zoom == zoom_value
   if zoom_value < 0.125 || zoom_value > 8.0 then return end
   @mode7_zoom = zoom_value
   $game_system.mode7_zoom = @mode7_zoom
   $game_player.center($game_player.x, $game_player.y)
end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur du zoom du mode 7
  #--------------------------------------------------------------------------
  def self.incr_mode7_zoom(val = 0.02)
@mode7_zoom_incr += val
new_zoom = 2 ** @mode7_zoom_incr
self.mode7_zoom = new_zoom
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de zoom du mode 7
  #--------------------------------------------------------------------------
  def self.to_mode7_zoom(new_zoom, duration)
unless mode7_zoom == new_zoom
   if new_zoom < 0.125 || new_zoom > 8.0 then return end
   @mode7_zoom_duration = duration
   target_zoom_incr = Math.log(new_zoom) / Math.log(2)
   @mode7_zoom_step = (target_zoom_incr - @mode7_zoom_incr) / duration
   @target_mode7_zoom = new_zoom
end
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut mode7_angle
  #--------------------------------------------------------------------------
  def self.mode7_angle=(new_angle)
unless new_angle == @mode7_angle
   @mode7_angle = [[new_angle, 0].max, 89].min
   @mode7_angle_real = @mode7_angle
   $game_system.mode7_angle = @mode7_angle
end
  end
  #--------------------------------------------------------------------------
  # * Autre setter pour l'attribut mode7_angle, ne réinitialisant pas @mode7_angle_real
  #--------------------------------------------------------------------------
  def self.set_mode7_angle(new_angle)
unless new_angle == @mode7_angle
   @mode7_angle = [[new_angle, 0].max, 89].min
   $game_system.mode7_angle = @mode7_angle
end
  end
  #--------------------------------------------------------------------------
  # * Incrémentation de la valeur de l'angle du mode 7
  #--------------------------------------------------------------------------
  def self.incr_mode7_angle
@mode7_angle_real += @mode7_angle_step
self.set_mode7_angle(@mode7_angle_real.to_i)
  end
  #--------------------------------------------------------------------------
  # * Pour aller progressivement vers une nouvelle valeur de l'angle du mode 7
  #--------------------------------------------------------------------------
  def self.to_mode7_angle(new_angle, duration)
unless @mode7_angle == new_angle
   new_angle = [[new_angle, 0].max, 89].min
   @mode7_angle_duration = duration
   @mode7_angle_step = (new_angle - @mode7_angle).to_f / duration
   @target_mode7_angle = new_angle
end
  end
  #--------------------------------------------------------------------------
  # * Mise à jour du mode 7
  #--------------------------------------------------------------------------
  def self.update_mode7
if @mode7_active
   if @mode7_zoom_duration > 0
      @mode7_zoom_duration -= 1
      if @mode7_zoom_duration == 0
      self.mode7_zoom = @target_mode7_zoom
      else
      self.incr_mode7_zoom(@mode7_zoom_step)
      end
   elsif @mode7_angle_duration > 0
      @mode7_angle_duration -= 1
      if @mode7_angle_duration == 0
      self.mode7_angle = @target_mode7_angle
      else
      self.incr_mode7_angle
      end
   elsif @end_mode7
      @spriteset.end_mode7
      @end_mode7 = false
   end
end
  end
  #--------------------------------------------------------------------------
  # * Vérifie si un effet est en cours
  #--------------------------------------------------------------------------
  def self.effect?
return @mode7_active && (@mode7_zoom_duration > 0 ||
@mode7_angle_duration > 0 || @end_mode7)
  end
  #--------------------------------------------------------------------------
  # * Modifie la valeur de la méthode de rafraîchissement de l'écran
  #--------------------------------------------------------------------------
  def self.set_mode7_scan(new_value)
new_value = [[new_value, 1].max, 3].min
unless MODE7_SCAN_STEP == new_value
   self.const_set(:MODE7_SCAN_STEP, new_value)
end
  end
  #==============================================================================
  # ** MGC::Mode7_Map
  #==============================================================================
  class Mode7_Map
#--------------------------------------------------------------------------
# * Attributs
#--------------------------------------------------------------------------
attr_reader :viewport, :visible, :ox, :oy, :opacity, :blend_type, :color,
:tone, :wave_amp, :wave_length, :wave_speed, :wave_phase, :zoom, :map_data,
:flags
attr_accessor :bitmaps, :flash_data
attr_reader :alpha, :parameters
attr_reader :param_tiles # [1.7]
attr_reader :map_id # [1.9]
#--------------------------------------------------------------------------
# * Constantes
#--------------------------------------------------------------------------
RENDER = Win32API.new("MGC_Mode7_Ace_Rot_1_9", "renderMode7", "l", "l")
#--------------------------------------------------------------------------
# * Initialisation
#--------------------------------------------------------------------------
def initialize(viewport)
   @viewport = viewport
   self.bitmaps = [0, 0, 0, 0, 0, 0, 0, 0, 0]
   @map_data = 0
   @flags = 0
   self.flash_data = nil
   @cx = Graphics.width >> 1
   @cy = Graphics.height >> 1
   @sprite_render = Sprite.new(viewport)
   @render = Bitmap.new(Graphics.width, Graphics.height)
   @sprite_render.bitmap = @render
   @sprite_render.x = 0
   @sprite_render.y = 0
   @sprite_render.z = 0
   @zoom = 1.0
   @view_limit = MODE7_VIEW_LIMIT << 5
   m7_data = Table.new(6, Graphics.height) # [1.7]
   @parameters = [@render, 0, map_data, bitmaps,
   Cache.picture('autotiles_data'), Cache.picture('autotiles_data_small'),
   Cache.picture('autotiles_data_xsmall'), 0, 0, 0, 0, 0, 0, 0, 4096,
   100, $game_map.loop_horizontal?, $game_map.loop_vertical?, MODE7_SCAN_STEP,
   0, m7_data, 2048, 0, MGC.mode7_data[5], MGC.mode7_data[0], 0, 0, 0, 0, 0,
   0, 0, 0, 0, 0, 0]
   @parameters << $game_map.tileset.flags # 36 [1.7]
   @parameters << MGC::MODE7_ALWAYS_DRAW_TILES_ON_MAP # 37 [1.7]
   @parameters << MGC::MODE7_TERRAIN_TAGS # 38 [1.7]
   @parameters << 0 # 39 [1.9]
   refresh_fading
   MGC.mode7_data[9] = m7_data
   self.alpha = 0
   self.visible = true
   self.zoom = 1.0
   self.ox = 0
   self.oy = 0
   self.opacity = 255
   self.blend_type = 0
   self.color = Color.new
   self.tone = Tone.new
   self.wave_amp = 0
   self.wave_length = 180
   self.wave_speed = 360
   self.wave_phase = 0.0
   @initialization = true
   @param_tiles = [Bitmap.new(32, 32), bitmaps,
   Cache.picture('autotiles_data'),
   Cache.picture('autotiles_data_small'),
   Cache.picture('autotiles_data_xsmall'), 0, [0, 0, 0]] # [1.7]
   @map_id = $game_map.map_id # [1.9]
end
#--------------------------------------------------------------------------
# * Refresh Fading
#--------------------------------------------------------------------------
def refresh_fading
   fading_dist = $game_map.get_default_fading_distance << 5
   fading_begin = Graphics.height + @view_limit - fading_dist
   @parameters[30] = fading_begin
   @parameters[31] = fading_dist
   @parameters[32] = $game_map.get_default_fading_tone.red.to_i
   @parameters[33] = $game_map.get_default_fading_tone.green.to_i
   @parameters[34] = $game_map.get_default_fading_tone.blue.to_i
   @parameters[35] = $game_map.get_default_fading_opacity
end
#--------------------------------------------------------------------------
# * Refresh all the parameters dependent on the angle of slant
#--------------------------------------------------------------------------
def refresh_alpha
   # angle of slant
   alpha_rad = (Math::PI * alpha) / 180
   cos_alpha_real = Math.cos(alpha_rad)
   sin_alpha_real = Math.sin(alpha_rad)
   cos_alpha = (2048 * cos_alpha_real).to_i
   sin_alpha = (2048 * sin_alpha_real).to_i
   distance_h = MGC.mode7_data[5]
   pivot = MGC.mode7_data[0]
   # h0,  z0 : intermediate values used to calculate the slope
   h0 = (-distance_h * pivot * cos_alpha) / ((distance_h << 11) +
   pivot * sin_alpha) + pivot
   z0 = (distance_h << 11).to_f / ((distance_h << 11) + pivot * sin_alpha)
   # slope
   slope_value = (1.0 - z0) / (pivot - h0)
   slope_value_map = (131072 * slope_value).to_i
   corrective_value = 1.0 - pivot * slope_value
   corrective_value_map = (131072 * corrective_value).to_i
   last_line = ((-pivot - @view_limit) * zoom).to_i
   height_limit = (distance_h * last_line * cos_alpha) /
   ((distance_h << 11) - last_line * sin_alpha) + pivot
   height_limit = [height_limit.to_i, 0].max
   parameters[21] = cos_alpha
   parameters[22] = sin_alpha
   parameters[25] = slope_value_map
   parameters[26] = corrective_value_map
   parameters[27] = height_limit
   parameters[29] = MODE7_SCAN_STEP
   @need_refresh = true
   MGC.mode7_data[3] = cos_alpha_real
   MGC.mode7_data[4] = sin_alpha_real
   MGC.mode7_data[6] = slope_value
   MGC.mode7_data[7] = corrective_value
   MGC.mode7_data[8] = height_limit
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut map_data
#--------------------------------------------------------------------------
def map_data=(new_map_data)
   @map_data = new_map_data
   parameters[2] = @map_data
end
#--------------------------------------------------------------------------
# * Charge le panorama en mode 7 [1.9]
#--------------------------------------------------------------------------
def parallax=(new_parallax)
   if new_parallax
      parameters[39] = new_parallax
   else
      parameters[39] = 0
   end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut flags
#--------------------------------------------------------------------------
def flags=(new_flags)
   @flags = new_flags
   parameters[7] = @flags
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut zoom
#--------------------------------------------------------------------------
def zoom=(new_zoom)
   unless zoom == new_zoom
      @zoom = new_zoom
      parameters[14] = (4096.0 / new_zoom).to_i
      MGC.mode7_data[2] = new_zoom
      vox = @ox
      @ox = nil
      self.ox = vox
      voy = @oy
      @oy = nil
      self.oy = voy
      @need_refresh = true
      parameters[29] = MODE7_SCAN_STEP
      @need_refresh = true
      last_line = ((-parameters[24] - @view_limit) * zoom).to_i
      height_limit = (parameters[23] * last_line * parameters[21]) /
      ((parameters[23] << 11) - last_line * parameters[22]) + parameters[24]
      parameters[27] = [height_limit.to_i, 0].max
      MGC.mode7_data[8] = parameters[27]
   end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut alpha
#--------------------------------------------------------------------------
def alpha=(new_alpha)
   unless new_alpha == alpha
      @alpha = new_alpha
      refresh_alpha
   end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut shadow_opacity
#--------------------------------------------------------------------------
def shadow_opacity=(value)
   @parameters[15] = [[value, 0].max, 255].min
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut visible
#--------------------------------------------------------------------------
def visible=(flag)
   @visible = flag
   @sprite_render.visible = flag
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut ox
#--------------------------------------------------------------------------
def ox=(new_ox)
   new_ox = new_ox.to_i
   unless new_ox == @ox
      @ox = new_ox
      @need_refresh = true
      parameters[8] = @ox
      parameters[29] = MODE7_SCAN_STEP
   end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut oy
#--------------------------------------------------------------------------
def oy=(new_oy)
   new_oy = new_oy.to_i
   unless new_oy == @oy
      @oy = new_oy
      @need_refresh = true
      parameters[9] = @oy
      parameters[29] = MODE7_SCAN_STEP
   end
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut opacity
#--------------------------------------------------------------------------
def opacity=(new_opacity)
   @opacity = new_opacity
   @sprite_render.opacity = new_opacity
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut blend_type
#--------------------------------------------------------------------------
def blend_type=(new_blend_type)
   @blend_type = new_blend_type
   @sprite_render.blend_type = new_blend_type
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut color
#--------------------------------------------------------------------------
def color=(new_color)
   @color = new_color
   @sprite_render.color = new_color
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut tone
#--------------------------------------------------------------------------
def tone=(new_tone)
   @tone = new_tone
   @sprite_render.tone = new_tone
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut wave_amp
#--------------------------------------------------------------------------
def wave_amp=(new_wave_amp)
   @wave_amp = new_wave_amp
   @sprite_render.wave_amp = new_wave_amp
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut wave_length
#--------------------------------------------------------------------------
def wave_length=(new_wave_length)
   @wave_length = new_wave_length
   @sprite_render.wave_length = new_wave_length
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut wave_speed
#--------------------------------------------------------------------------
def wave_speed=(new_wave_speed)
   @wave_speed = new_wave_speed
   @sprite_render.wave_speed = new_wave_speed
end
#--------------------------------------------------------------------------
# * Setter pour l'attribut wave_phase
#--------------------------------------------------------------------------
def wave_phase=(new_wave_phase)
   @wave_phase = new_wave_phase
   @sprite_render.wave_phase = new_wave_phase
end
#--------------------------------------------------------------------------
# * Libération de l'instance
#--------------------------------------------------------------------------
def dispose
   @render.dispose
   @sprite_render.dispose
   clear_vertical_tiles # [1.7]
   @param_tiles[0].dispose
end
#--------------------------------------------------------------------------
# * Suppression des tiles verticaux [1.7]
#--------------------------------------------------------------------------
def clear_vertical_tiles
   if @vertical_tiles
      @vertical_tiles.each {|sprite| sprite.dispose}
      @vertical_tiles.clear
   end
end
#--------------------------------------------------------------------------
# * Retourne true si l'instance a été libérée
#--------------------------------------------------------------------------
def disposed?
   return @render.disposed?
end
#--------------------------------------------------------------------------
# * Mise à jour, appelée normalement à chaque frame
#--------------------------------------------------------------------------
def update
   if @visible
      if MGC.is_changing_map?
      refresh_fading
      MGC.end_change_map
      end
      if parameters[18] != MODE7_SCAN_STEP
      parameters[18] = MODE7_SCAN_STEP
      parameters[19] = 0
      parameters[29] = 0
      @need_refresh = true
      end
      self.alpha = MGC.mode7_angle
      self.zoom = MGC.mode7_zoom
      if Graphics.frame_count & 31 == 0
      parameters[10] += 1
      parameters[10] %= 3
      parameters[29] = MODE7_SCAN_STEP
      unless @need_refresh
         @need_refresh_anim = true
      end
      end
      if parameters[29] > 0 && !@need_refresh && !@need_refresh_anim
      @need_refresh = true
      end
      begin
      if @need_refresh
         parameters[19] += 1
         if parameters[19] == parameters[18]
            parameters[19] = 0
         end
         parameters[11] = 0
         RENDER.call(parameters.__id__)
         parameters[29] -= 1
         if parameters[29] == 0
            @need_refresh = false
         end
      elsif @need_refresh_anim
         parameters[19] += 1
         if parameters[19] == parameters[18]
            parameters[19] = 0
         end
         parameters[11] = 1
         RENDER.call(parameters.__id__)
         parameters[29] -= 1
         if parameters[29] == 0
            @need_refresh_anim = false
         end
      end
      if @initialization && parameters[29] == 0
         @initialization = false
      end
      end while @initialization
      @sprite_render.update
      @vertical_tiles.each {|sprite| sprite.update} # [1.7]
   end
end
#--------------------------------------------------------------------------
# * Flash des couches de la tilemap
#--------------------------------------------------------------------------
def flash(color, duration)
   @sprite_render.flash(color, duration)
end
#--------------------------------------------------------------------------
# * Create vertical tiles [1.7]
#--------------------------------------------------------------------------
def create_vertical_tiles
   unless @vertical_tiles
      @vertical_tiles = []
   end
   clear_vertical_tiles
   @vt_checked_tiles = Table.new($game_map.width, $game_map.height,
   MGC::MODE7_TERRAIN_TAGS.size)
   (0...$game_map.height).each {|iy|
      (0...$game_map.width).each {|ix|
      (0...3).each {|il|
         terrain_tag = $game_map.terrain_tag_for_layer(ix, iy, il)
         if terrain_tag > 0 && MGC::MODE7_TERRAIN_TAGS.include?(terrain_tag)
            tag_index = MGC::MODE7_TERRAIN_TAGS.index(terrain_tag)
            unless @vt_checked_tiles[ix, iy, tag_index] == 1
            @vt_found_tiles = []
            @vt_x_min = ix
            @vt_x_max = ix
            @vt_y_min = iy
            @vt_y_max = iy
            find_linked_tiles(ix, iy, terrain_tag, tag_index)
            v_tile = MGC::Vertical_Tile.new(self, @viewport)
            v_tile.x = 1 + @vt_x_max + @vt_x_min << 5 >> 1
            v_tile.y = 1 + @vt_y_max << 5
            v_tile.refresh_tile_data(@vt_found_tiles,
            @vt_x_min, @vt_x_max, @vt_y_min, @vt_y_max)
            @vertical_tiles << v_tile
            break
            end
         end
      }
      }
   }
   @vt_checked_tiles = nil
end
#--------------------------------------------------------------------------
# * Find linked tiles [1.7]
# param x : Integer
# param y : Integer
# param terrain_tag : Integer
# param tag_index : Integer
#--------------------------------------------------------------------------
def find_linked_tiles(x, y, terrain_tag, tag_index)
   unless @vt_checked_tiles[x, y, tag_index] == 1
      @vt_checked_tiles[x, y, tag_index] = 1
      found = false
      (0...3).each {|il|
      if $game_map.terrain_tag_for_layer(x, y, il) == terrain_tag
         unless found
            found_tile = [x, y, [false, false, false]]
            @vt_found_tiles << found_tile
            found = true
         end
         found_tile[2][il] = true
      end
      }
      if found
      if x > @vt_x_max
         @vt_x_max = x
      end
      if x < @vt_x_min
         @vt_x_min = x
      end
      if y > @vt_y_max
         @vt_y_max = y
      end
      if y < @vt_y_min
         @vt_y_min = y
      end
      if MGC::MODE7_VERTICAL_TILES_TYPE & 1 == 1
         if y < $game_map.height - 1
            find_linked_tiles(x, y + 1, terrain_tag, tag_index)
         end
      end
      if MGC::MODE7_VERTICAL_TILES_TYPE & 2 == 2
         if x < $game_map.width - 1
            find_linked_tiles(x + 1, y, terrain_tag, tag_index)
         end
      end
      if MGC::MODE7_VERTICAL_TILES_TYPE == 3
         if x > 0
            find_linked_tiles(x - 1, y, terrain_tag, tag_index)
         end
         if y > 0
            find_linked_tiles(x, y - 1, terrain_tag, tag_index)
         end
      end
      end
   end
end
  end
end

#==============================================================================
# ** Game_System
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Attributs
  #--------------------------------------------------------------------------
  attr_accessor :mode7_zoom, :mode7_angle, :mode7_active
end

#==============================================================================
# ** Game_Map
#==============================================================================
class Game_Map
  attr_accessor :start_mode7, :end_mode7
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
alias setup_mgc_m7a setup
alias set_display_pos_mgc_m7a set_display_pos
alias scroll_down_mgc_m7a scroll_down
alias scroll_left_mgc_m7a scroll_left
alias scroll_right_mgc_m7a scroll_right
alias scroll_up_mgc_m7a scroll_up
@already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Setup
  #--------------------------------------------------------------------------
  def setup(map_id)
setup_mgc_m7a(map_id)
@map = load_data(sprintf("Data/Map%03d.rvdata2", map_id)) # [1.9]
if is_mode7?
   if MGC.mode7_active
      MGC.start_change_map
   end
   self.start_mode7 = true
else
   self.end_mode7 = true
end
  end
  #--------------------------------------------------------------------------
  # * Check if the map is configured for mode 7
  #--------------------------------------------------------------------------
  def is_mode7?
return MGC::MODE7_MAPS_ID.include?(@map_id) ||
$data_mapinfos[@map_id].full_name[/\[M7\]/]
  end
  #--------------------------------------------------------------------------
  # * Get default mode7 angle
  #--------------------------------------------------------------------------
  def get_default_mode7_angle
if $data_mapinfos[@map_id].full_name[/\[A(\d+)\]/]
   return [[$1.to_i, 0].max, 89].min
else
   return MGC::MODE7_DEFAULT_ANGLE
end
  end
  #--------------------------------------------------------------------------
  # * Get default mode7 zoom
  #--------------------------------------------------------------------------
  def get_default_mode7_zoom
if $data_mapinfos[@map_id].full_name[/\[Z(\d+(?:\.\d+)*)\]/]
   return [[$1.to_f, 0.125].max, 8.0].min
else
   return MGC::MODE7_DEFAULT_ZOOM
end
  end
  #--------------------------------------------------------------------------
  # * Get default fading distance
  #--------------------------------------------------------------------------
  def get_default_fading_distance
if $data_mapinfos[@map_id].full_name[/\[FD(\d{1,3})\]/]
   return [$1.to_i, 0].max
else
   return MGC::MODE7_FADING_DISTANCE
end
  end
  #--------------------------------------------------------------------------
  # * Get default fading opacity
  #--------------------------------------------------------------------------
  def get_default_fading_opacity
if $data_mapinfos[@map_id].full_name[/\[FO(\d{1,3})\]/]
   return [[$1.to_i, 0].max, 255].min
else
   return MGC::MODE7_FADING_OPACITY
end
  end
  #--------------------------------------------------------------------------
  # * Get default fading tone
  #--------------------------------------------------------------------------
  def get_default_fading_tone
if $data_mapinfos[@map_id].full_name[/\[FT(\-?\d{1,3}),(\-?\d{1,3}),(\-?\d{1,3})\]/]
   red = [[$1.to_i, -255].max, 255].min
   green = [[$2.to_i, -255].max, 255].min
   blue = [[$3.to_i, -255].max, 255].min
   return Tone.new(red, green, blue)
else
   return MGC::MODE7_FADING_TONE
end
  end
  #--------------------------------------------------------------------------
  # * Check if the map is parallaxed [1.9]
  #--------------------------------------------------------------------------
  def is_parallaxed?
return MGC::MODE7_PARALLAXED_MAPS_ID.include?(@map_id) ||
$data_mapinfos[@map_id].full_name[/\[P\]/]
  end
  #--------------------------------------------------------------------------
  # * Check if the parallaxed map has a panorama in mode 7 [1.9]
  #--------------------------------------------------------------------------
  def has_additionnal_panorama?
return @map.note[/\[m7a_pano:\w+\]/]
  end
  #--------------------------------------------------------------------------
  # * Return the panorama in mode 7 if the map is parallaxed [1.9]
  #--------------------------------------------------------------------------
  def set_additional_panorama
if @map.note[/\[m7a_pano:(\w+)\]/]
   @parallax_name = $1
end
  end
  #--------------------------------------------------------------------------
  # * Set Display Position
  #--------------------------------------------------------------------------
  def set_display_pos(x, y)
if MGC.mode7_active
   if loop_horizontal?
      @display_x = (x + width) % width
   else
      if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
      @display_x = (width - screen_tile_x) / 2
      else
      x_min = screen_tile_x * (1.0 / MGC.mode7_zoom - 1.0) / 2
      x_max = width + screen_tile_x * ((1.0 - 1.0 / MGC.mode7_zoom) / 2 - 1)
      x = [x_min, [x, x_max].min].max
      @display_x = x
      end
   end
   if loop_vertical?
      @display_y = (y + height) % height
   else
      if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
      @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
      else
      y_min = screen_tile_y * (1.0 / MGC.mode7_zoom - 1.0) * MGC.mode7_data[1]
      y_max = height + screen_tile_y *
      ((1.0 - 1.0 / MGC.mode7_zoom) * (1 - MGC.mode7_data[1]) - 1)
      y = [y_min, [y, y_max].min].max
      @display_y = y
      end
   end
   @parallax_x = x
   @parallax_y = y
else
   set_display_pos_mgc_m7a(x, y)
end
  end
  #--------------------------------------------------------------------------
  # * Scroll Down
  #--------------------------------------------------------------------------
  def scroll_down(distance)
if MGC.mode7_active
   if loop_vertical?
      @display_y += distance
      @display_y %= @map.height
      @parallax_y += distance if @parallax_loop_y
   else
      last_y = @display_y
      if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
      @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
      else
      max = height + screen_tile_y *
      ((1.0 - 1.0 / MGC.mode7_zoom) * (1 - MGC.mode7_data[1]) - 1)
      @display_y = [@display_y + distance, max].min
      end
      @parallax_y += @display_y - last_y
   end
else
   scroll_down_mgc_m7a(distance)
end
  end
  #--------------------------------------------------------------------------
  # * Scroll Left
  #--------------------------------------------------------------------------
  def scroll_left(distance)
if MGC.mode7_active
   if loop_horizontal?
      @display_x += @map.width - distance
      @display_x %= @map.width
      @parallax_x -= distance if @parallax_loop_x
   else
      last_x = @display_x
      if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
      @display_x = (width - screen_tile_x) / 2
      else
      min = screen_tile_x * (1.0 / MGC.mode7_zoom - 1.0) / 2
      @display_x = [@display_x - distance, min].max
      end
      @parallax_x += @display_x - last_x
   end
else
   scroll_left_mgc_m7a(distance)
end
  end
  #--------------------------------------------------------------------------
  # * Scroll Right
  #--------------------------------------------------------------------------
  def scroll_right(distance)
if MGC.mode7_active
   if loop_horizontal?
      @display_x += distance
      @display_x %= @map.width
      @parallax_x += distance if @parallax_loop_x
   else
      last_x = @display_x
      if MGC.mode7_zoom < 1.0 && width * MGC.mode7_zoom < screen_tile_x
      @display_x = (width - screen_tile_x) / 2
      else
      max = width + screen_tile_x * ((1.0 - 1.0 / MGC.mode7_zoom) / 2 - 1)
      @display_x = [@display_x + distance, max].min
      end
      @parallax_x += @display_x - last_x
   end
else
   scroll_right_mgc_m7a(distance)
end
  end
  #--------------------------------------------------------------------------
  # * Scroll Up
  #--------------------------------------------------------------------------
  def scroll_up(distance)
if MGC.mode7_active
   if loop_vertical?
      @display_y += @map.height - distance
      @display_y %= @map.height
      @parallax_y -= distance if @parallax_loop_y
   else
      last_y = @display_y
      if MGC.mode7_zoom < 1.0 && height * MGC.mode7_zoom < screen_tile_y
      @display_y = (height - screen_tile_y) * MGC.mode7_data[1]
      else
      min = screen_tile_y * (1.0 / MGC.mode7_zoom - 1.0) * MGC.mode7_data[1]
      @display_y = [@display_y - distance, min].max
      end
      @parallax_y += @display_y - last_y
   end
else
   scroll_up_mgc_m7a(distance)
end
  end
  #--------------------------------------------------------------------------
  # * Get Terrain Tag for a layer [1.7]
  #--------------------------------------------------------------------------
  def terrain_tag_for_layer(x, y, layer)
return 0 unless valid?(x, y)
return tileset.flags[tile_id(x, y, layer)] >> 12
  end
end

#==============================================================================
# ** Game_CharacterBase
#==============================================================================
class Game_CharacterBase
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :sprite
end

#==============================================================================
# ** Serialisation
#==============================================================================
[:Sprite, :Viewport, :Bitmap, :Font].each {|classname|
  eval(
  "class #{classname}
def marshal_dump
   return []
end
def marshal_load(array)
end
  end")
}

#==============================================================================
# ** Sprite
#==============================================================================
class Sprite
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
alias initialize_mgc_m7a initialize
alias zoom_x_mgc_m7a= zoom_x=
alias zoom_y_mgc_m7a= zoom_y=
alias zoom_x_mgc_m7a zoom_x
alias zoom_y_mgc_m7a zoom_y
@already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Initialisation
  #--------------------------------------------------------------------------
  def initialize(*args)
initialize_mgc_m7a(*args)
@phase_mode7 = false
self.zoom_x = 1.0
self.zoom_y = 1.0
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x=(new_zoom_x)
unless @phase_mode7
   @base_zoom_x = new_zoom_x
end
self.zoom_x_mgc_m7a = new_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Setter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y=(new_zoom_y)
unless @phase_mode7
   @base_zoom_y = new_zoom_y
end
self.zoom_y_mgc_m7a = new_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_x
  #--------------------------------------------------------------------------
  def zoom_x
return @base_zoom_x
  end
  #--------------------------------------------------------------------------
  # * Getter pour l'attribut zoom_y
  #--------------------------------------------------------------------------
  def zoom_y
return @base_zoom_y
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_x en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_x_real
return zoom_x_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Valeur réelle du zoom_y en prenant en compte le zoom de la carte
  #--------------------------------------------------------------------------
  def zoom_y_real
return zoom_y_mgc_m7a
  end
end

#==============================================================================
# ** Sprite_Base
#==============================================================================
class Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
alias animation_set_sprites_mgc_m7a_aprite_base animation_set_sprites
@already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Set Animation Sprite
  #    frame : Frame data (RPG::Animation::Frame)
  #--------------------------------------------------------------------------
  def animation_set_sprites(frame)
if MGC.mode7_active
   cell_data = frame.cell_data
   @ani_sprites.each_with_index do |sprite, i|
      next unless sprite
      pattern = cell_data[i, 0]
      if !pattern || pattern < 0
      sprite.visible = false
      next
      end
      sprite.bitmap = pattern < 100 ? @ani_bitmap1 : @ani_bitmap2
      sprite.visible = true
      sprite.src_rect.set(pattern % 5 * 192,
      pattern % 100 / 5 * 192, 192, 192)
      if @ani_mirror
      sprite.x = @ani_ox - cell_data[i, 1] * zoom_y_real
      sprite.y = @ani_oy + cell_data[i, 2] * zoom_y_real
      sprite.angle = (360 - cell_data[i, 4])
      sprite.mirror = (cell_data[i, 5] == 0)
      else
      sprite.x = @ani_ox + cell_data[i, 1] * zoom_y_real
      sprite.y = @ani_oy + cell_data[i, 2] * zoom_y_real
      sprite.angle = cell_data[i, 4]
      sprite.mirror = (cell_data[i, 5] == 1)
      end
      sprite.z = self.z + 300 + i
      sprite.ox = 96
      sprite.oy = 96
      sprite.zoom_x = cell_data[i, 3] * zoom_y_real / 100.0
      sprite.zoom_y = cell_data[i, 3] * zoom_y_real / 100.0
      sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
      sprite.blend_type = cell_data[i, 7]
   end
else
   animation_set_sprites_mgc_m7a_aprite_base(frame)
end
  end
end

#==============================================================================
# ** Sprite_Character
#==============================================================================
class Sprite_Character < Sprite_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
alias initialize_mgc_m7a_aprite_character initialize
alias update_position_mgc_m7a_aprite_character update_position
alias update_other_mgc_m7a_aprite_character update_other
alias update_balloon_mgc_m7a_aprite_character update_balloon
@already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    character : Game_Character
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil)
initialize_mgc_m7a_aprite_character(viewport, character)
character.sprite = self
  end
  #--------------------------------------------------------------------------
  # * Update Position
  #--------------------------------------------------------------------------
  def update_position
if MGC.mode7_active
   old_x = x
   old_y = y
   update_mode7
   @in_mode_7 = true # [1.5]
   move_animation(x - old_x, y - old_y)
else
   if @in_mode_7 # [1.5]
      self.zoom_x = zoom_x
      self.zoom_y = zoom_y
      @in_mode_7 = false
   end
   update_position_mgc_m7a_aprite_character
end
  end
  #--------------------------------------------------------------------------
  # * Update Other
  #--------------------------------------------------------------------------
  def update_other
update_other_mgc_m7a_aprite_character
if MGC.mode7_active && visible
   if !@force_mode7_invisible &&
      y >= MGC.mode7_data[8] &&
      (y - height * zoom_y_real) < Graphics.height
   then
      self.visible = true
      if y < Graphics.height
      dat = MGC.mode7_data[9]
      self.opacity += dat[5, y]
      self.tone.set(dat[2, y], dat[3, y], dat[4, y])
      end
   else
      self.visible = false
   end
end
  end
  #--------------------------------------------------------------------------
  # * Update Position In Mode7
  #--------------------------------------------------------------------------
  def update_mode7
if @character.tile_id == 0 && character.character_name == "" # [1.8]
   @force_mode7_invisible = true
   return
end
y_screen = character.screen_y +
(character.is_a?(Game_Vehicle) ? character.altitude : 0)
y_init = MGC.mode7_data[2] * (y_screen - MGC.mode7_data[0])
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 = MGC.mode7_data[2] * (character.screen_x - (Graphics.width >> 1))
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.7]
if character.is_a?(Game_Vehicle)
   self.y -= character.altitude * zoom_y_real
end
  end
  #--------------------------------------------------------------------------
  # * Update Balloon Icon
  #--------------------------------------------------------------------------
  def update_balloon
update_balloon_mgc_m7a_aprite_character
if MGC.mode7_active && @balloon_duration > 0
   @balloon_sprite.y = y - height * zoom_y_real
   @balloon_sprite.zoom_x = zoom_x_real
   @balloon_sprite.zoom_y = zoom_y_real
end
  end
end

#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
alias initialize_mgc_m7a initialize
alias create_tilemap_mgc_m7a create_tilemap
alias update_mgc_m7a update
alias update_shadow_mgc_m7a update_shadow
alias update_parallax_mgc_m7a update_parallax
@already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
MGC.spriteset = self
initialize_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Lance le mode 7
  #--------------------------------------------------------------------------
  def start_mode7
unless @tilemap_mode7 && @tilemap_mode7.map_id == $game_map.map_id # [1.9]
   if @tilemap_mode7
      @tilemap_mode7.dispose unless @tilemap_mode7.disposed?
      MGC.initialize_mode7(true)
   else
      MGC.initialize_mode7
      @tilemap_classic = @tilemap
   end
   @tilemap_mode7 = MGC::Mode7_Map.new(@viewport1)
   @tilemap_mode7.map_data = $game_map.data
   if $game_map.is_parallaxed? && $game_map.parallax_name &&
      $game_map.parallax_name != '' # [1.9]
   then
      @tilemap_mode7.parallax = Cache.parallax($game_map.parallax_name)
      $game_map.set_additional_panorama
   end
   @tilemap = @tilemap_mode7
   load_tileset
end
@tilemap_mode7.create_vertical_tiles # [1.7]
@tilemap_mode7.visible = true
@tilemap_classic.visible = false
@tilemap = @tilemap_mode7
MGC.mode7_active = true
  end
  #--------------------------------------------------------------------------
  # * Met fin au mode 7
  #--------------------------------------------------------------------------
  def end_mode7
if @tilemap_mode7
   @tilemap_mode7.visible = false
   @tilemap_classic.visible = true
   @tilemap = @tilemap_classic
   @tilemap_mode7.clear_vertical_tiles # [1.7]
   @parallax.visible = true # [1.9]
end
MGC.mode7_active = false
  end
  #--------------------------------------------------------------------------
  # * Create Tilemap
  #--------------------------------------------------------------------------
  def create_tilemap
create_tilemap_mgc_m7a
unless $game_system.mode7_active
   MGC.mode7_active = false
end
if $game_map.is_mode7? || $game_system.mode7_active
   start_mode7
end
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
MGC.update_mode7
if $game_map.start_mode7
   start_mode7
   $game_map.start_mode7 = false
elsif $game_map.end_mode7
   end_mode7
   $game_map.end_mode7 = false
end
update_mgc_m7a
  end
  #--------------------------------------------------------------------------
  # * Update Parallax [1.9]
  #--------------------------------------------------------------------------
  def update_parallax
update_parallax_mgc_m7a
if MGC.mode7_active && $game_map.is_parallaxed?
   if $game_map.has_additionnal_panorama?
      $game_map.set_additional_panorama
   else
      @parallax.visible = false
   end
end
  end
  #--------------------------------------------------------------------------
  # * Update Airship Shadow Sprite
  #--------------------------------------------------------------------------
  def update_shadow
if MGC.mode7_active
   airship_sprite = $game_map.airship.sprite
   @shadow_sprite.x = airship_sprite.x
   @shadow_sprite.y = airship_sprite.y + $game_map.airship.altitude *
   airship_sprite.zoom_y_real
   @shadow_sprite.opacity = $game_map.airship.altitude * 8 *
   airship_sprite.opacity
   @shadow_sprite.zoom_x = airship_sprite.zoom_x_real
   @shadow_sprite.zoom_y = airship_sprite.zoom_y_real
   @shadow_sprite.update
else
   update_shadow_mgc_m7a
end
  end
end

#==============================================================================
# ** Scene_Map
#==============================================================================
class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # * Aliased methods
  #--------------------------------------------------------------------------
  unless @already_aliased_mgc_m7a
alias update_call_menu_mgc_m7a update_call_menu
@already_aliased_mgc_m7a = true
  end
  #--------------------------------------------------------------------------
  # * Determine if Menu is Called due to Cancel Button
  #--------------------------------------------------------------------------
  def update_call_menu
unless MGC.effect?
   update_call_menu_mgc_m7a
end
  end
end

#============================================================================
# ** RPG::MapInfo
#============================================================================
class RPG::MapInfo
  # defines the map name as the name without anything within brackets,
  # including brackets
  def name
return @name.gsub(/\[.*\]/) {''}
  end
  #--------------------------------------------------------------------------
  # the original name with the codes
  def full_name
return @name
  end
end

module MGC
  #--------------------------------------------------------------------------
  # * Constantes [1.7]
  #--------------------------------------------------------------------------
  RENDER_TILE = Win32API.new("MGC_Mode7_Ace_1_9", "renderTile", "l", "l")
  #==============================================================================
  # ** MGC::Vertical_Tile [1.7]
  #==============================================================================
  class Vertical_Tile
#--------------------------------------------------------------------------
# * Attributs
#--------------------------------------------------------------------------
attr_accessor :x, :y, :screen_x, :screen_y, :zoom
attr_accessor :tile_width, :tile_height, :width, :height
#--------------------------------------------------------------------------
# * Initialisation
# param parent : MGC::Mode7_Map
# param viewport : Viewport
#--------------------------------------------------------------------------
def initialize(parent, viewport)
   @parent = parent
   @viewport = viewport
   @visible = false
   @sprite = nil
end
#--------------------------------------------------------------------------
# * Refresh tile data
# param tiles : Array<Array[Integer, Integer, Array[3]<Boolean>]>
# param x_min : Integer
# param x_max : Integer
# param y_min : Integer
# param y_max : Integer
#--------------------------------------------------------------------------
def refresh_tile_data(tiles, x_min, x_max, y_min, y_max)
   self.tile_width = 1 + x_max - x_min
   self.width = tile_width << 5
   self.tile_height = 1 + y_max - y_min
   self.height = tile_height << 5
   @tiles_data = Array.new(tile_width * tile_height)
   tiles.each {|tile|
      x_tile = tile[0] - x_min
      y_tile = tile[1] - y_min
      @tiles_data[x_tile + y_tile * tile_width] = tile
   }
end
#--------------------------------------------------------------------------
# * Dispose
#--------------------------------------------------------------------------
def dispose
   if @sprite
      @sprite.bitmap.dispose
      @sprite.dispose
      @sprite = nil
   end
end
#--------------------------------------------------------------------------
# * Update
#--------------------------------------------------------------------------
def update
   update_mode7
   update_visibility
end
#--------------------------------------------------------------------------
# * 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)
   y_init = MGC.mode7_data[2] * (y_scr - MGC.mode7_data[0])
   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 = MGC.mode7_data[2] * (x_scr - (Graphics.width >> 1))
   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
#--------------------------------------------------------------------------
# * Update Visibility
#--------------------------------------------------------------------------
def update_visibility
   if @visible
      if !@force_invisible &&
      screen_y >= MGC.mode7_data[8] &&
      (screen_y - height * zoom) < Graphics.height &&
      (screen_x + width * zoom / 2)  >= 0 &&
      (screen_x - width * zoom / 2) < Graphics.width
      then
      if screen_y < Graphics.height
         dat = MGC.mode7_data[9]
         @sprite.opacity = 255 + dat[5, screen_y]
         @sprite.tone.set(dat[2, screen_y], dat[3, screen_y], dat[4, screen_y])
      end
      @sprite.x = screen_x
      @sprite.y = screen_y
      @sprite.z = screen_y << 8
      @sprite.zoom_x = zoom
      @sprite.zoom_y = zoom
      else
      @visible = false
      @sprite.bitmap.dispose
      @sprite.dispose
      @sprite = nil
      end
   else
      if !@force_invisible &&
      screen_y >= MGC.mode7_data[8] &&
      (screen_y - height * zoom) < Graphics.height &&
      (screen_x + width * zoom / 2)  >= 0 &&
      (screen_x - width * zoom / 2) < Graphics.width
      then
      @visible = true
      @sprite = Sprite.new(@viewport)
      @sprite.ox = tile_width * 32 / 2
      @sprite.oy = tile_height * 32
      @sprite.x = screen_x
      @sprite.y = screen_y
      @sprite.z = screen_y << 8
      @sprite.zoom_x = zoom
      @sprite.zoom_y = zoom
      @sprite.bitmap = Bitmap.new(32 * tile_width, 32 * tile_height)
      (0...tile_height).each {|iy|
         (0...tile_width).each {|ix|
            tile_data = @tiles_data[ix + iy * tile_width]
            if tile_data
            (0...3).each {|il|
               if tile_data[2][il]
                  @parent.param_tiles[6][il] =
                  $game_map.tile_id(tile_data[0], tile_data[1], il)
               else
                  @parent.param_tiles[6][il] = 0
               end
            }
            @parent.param_tiles[0].clear
            MGC::RENDER_TILE.call(@parent.param_tiles.__id__)
            @sprite.bitmap.blt(ix << 5, iy << 5, @parent.param_tiles[0],
            @parent.param_tiles[0].rect)
            end
         }
      }
      if screen_y < Graphics.height
         dat = MGC.mode7_data[9]
         @sprite.opacity = 255 + dat[5, screen_y]
         @sprite.tone.set(dat[2, screen_y], dat[3, screen_y], dat[4, screen_y])
      end
      end
   end
end
  end
end[/pre]

mode 7 必要檔案

Project1.rar (51.26 KB, 下载次数: 28)

[已经过期] 【>A<】截圖存檔腳本衝突

加入我们，或者，欢迎回来。

开拓者