腳本衝突問題

pahk2006

本人使用了 畫面彷3D 系統 (Mode 7)
但希望再加上地圖作戰鬥時的背景 希望有大大能幫解決衝突問題

#============================================================================ #此脚本增加了一种深入的地图。 #作者MGCaladtogel #中文版（ 24/04/08 ） #---------------------------------------------------------------------------- #你必须添加到地图上的名字： # You must add to the map's name : #- [M7]  ：激活Mode7 #- [#xx] ： xx是倾斜角（度） 。默认值为0 （正常地图） #- [Y]   ： Y型地图循环 #  [X]   ：X地图的循环。此选项需要资源（较低的FPS ） #- [A]   : 动画autotiles （ 4模式） 。此选项增加 #          显着的加载时间，因此它可能会崩溃的大地图 #          (SystemStackError) #- [C]   : 为中心的地图上的英雄（即使是小地图） #- [P]   : 有一个固定的全景 #- [H]   : 有一个白色的地平线 #- [OV]  : Overworld脚本调整（一Mewsterus的脚本功能） # # 或： # 看到“ $ mode7_maps_settings ”如下（ L.48采取行动） ，以prapare设置 #---------------------------------------------------------------------------- #  其他命令(事件)： #- $scene.spriteset.tilemap.mode7_set(new_angle) #  ＃重绘地图与new_angle #- $scene.spriteset.tilemap.mode7_set_p(new_angle) #  重绘地图逐步从目前的角度 #- $scene.spriteset.tilemap.mode7_redraw #  重绘地图（有用下面的命令） #- $game_system.map_opacity = value #  界定不透明的Mode7地图（它需要重绘） #- $game_system.map_gradual_opacity = value #  要定义一个渐进的不透明的Mode7地图（它需要重绘） #  错误与横向循环 #- $game_system.map_tone = Color.new(Red, Green, Blue) #  确定了基调Mode7地图（它需要重绘） #- $game_system.map_gradual_tone = Tone.new(Red, Green, Blue, Gray) #  要定义一个渐进的基调Mode7地图（它需要重绘） #- $game_system.horizon = value #  要定义视图的距离(默认是:960)(它需要重绘) #- $game_system.reset #  初始化前的选择 # #- 如果要取得持平活动： #  刚刚添加评论的事件的命令清单： “平面” # #- 要处理的高度垂直事件： #  添加评论的事件的命令清单： “ Heigth X ”的，其中X是 #============================================================================ # 地图来自所有瓷砖的3层，不具有 # terrain_tag的值为1或2 。 # 其他瓷砖（ terrain_tag = 1或2 ）的形式要素，得出垂直， # 如第三层元素的旧版本。 # 2地形编号用于垂直形式的内容 $terrain_tags_vertical_tiles = [1,2] # You can modify these values # To access maps names $data_maps = load_data("Data/MapInfos.rxdata") $mode7_maps_settings = {} # Prepare your own settings for mode7 maps # Just put the first parameter in a map's name # For example : $mode7_maps_settings["Worldmap"] = ["#60", "X", "Y", "A", "H", "OV"] # -> will  be called  when "Worldmap" is included in the name $mode7_maps_settings["Smallslant"] = ["#20", "A", "S"] # Add any number of settings you want # enable/disable mode7 for mode7 maps (not on the fly, just when the map is loaded), enabled by default $enable_mode7_number = 5 # switch number : change this value ! #============================================================================ # ■ Game_System #---------------------------------------------------------------------------- # Add attributes to this class #============================================================================ class Game_System   attr_accessor :mode7 # false : normal map / true : mode 7   attr_accessor :loop_x # true : horizontal-looping map   attr_accessor :loop_y # true : vertical-looping map   attr_accessor :always_scroll # true : to center the camera around the hero   attr_accessor :map_tone # mode7 map's tone (Color)   attr_accessor :map_opacity # mode7 map's opacity (0..255)   attr_accessor :animated # true : animated autotiles for mode7 maps   attr_accessor :white_horizon # true : white line horizon for mode7 maps   attr_accessor :angle # mode7 map's slant angle (in degree)   attr_accessor :horizon # horizon's distance   attr_accessor :fixed_panorama # true : to fix the panorama (no scrolling any more)   attr_accessor :ov # true : Overworld Sprite Resize (smaller hero's sprite)   attr_accessor :ov_zoom # resize's value with ov   attr_accessor :map_gradual_opacity # mode7 map's gradual opacity (0..255)   attr_accessor :map_gradual_tone # mode7 map's gradual tone (Color)   #--------------------------------------------------------------------------   # * Object Initialization   #--------------------------------------------------------------------------   alias initialize_mode7_game_system initialize   def initialize     initialize_mode7_game_system     self.mode7 = false     self.loop_x = false     self.loop_y = false     self.always_scroll = false     self.animated = false     self.white_horizon = false     self.angle = 0     self.fixed_panorama = false     self.ov = false     self.ov_zoom = 0.6     reset   end   #--------------------------------------------------------------------------   # * Reset the values for opacity, tone and horizon's distance   #--------------------------------------------------------------------------   def reset     self.map_opacity = 255     self.map_tone = Color.new(0,0,0,0)     self.horizon = 960 # default value, equivalent to 30 tiles     self.map_gradual_opacity = 0     self.map_gradual_tone = Tone.new(0,0,0,0)   end end #============================================================================ # ■ Tilemap_mode7 #---------------------------------------------------------------------------- # This new Tilemap class handles the drawing of a mode7 map #============================================================================ class Tilemap_mode7   attr_accessor  :maps_list # contains map's graphics   attr_accessor  :map_ground # original map's graphic to handle flat events   attr_accessor  :tone_values # tone values for each line (Hash)   attr_accessor  :opacity_values # opacity values for each line (Hash)   attr_reader :spriteset   #--------------------------------------------------------------------------   # * Object Initialization   #     viewport  : viewport   #--------------------------------------------------------------------------   def initialize(viewport, spriteset)     @spriteset = spriteset     @id = $game_map.map_id # map's ID : to load or save the map in Cache     @maps_list = [] # contains map's drawings (Bitmap)     @disp_y = $game_map.display_y # @disp_y : tilemap's display_y     @disp_x = $game_map.display_x # @disp_x : tilemap's display_x     @height = 32 * $game_map.height # @height : map's height (in pixel)     @width = 32 * $game_map.width # @width : map's width (in pixel)     $game_temp.height = @height     # map's drawings are loaded if already in Cache     if RPG::Cache_Carte.in_cache(@id)       @map = RPG::Cache_Carte.load(@id)       @maps_list.push(@map)       @map_ground = RPG::Cache_Carte.load(@id, 4) # to handle flat events       if $game_system.animated         @map_2 = RPG::Cache_Carte.load(@id, 1)         @map_3 = RPG::Cache_Carte.load(@id, 2)         @map_4 = RPG::Cache_Carte.load(@id, 3)         @maps_list.push(@map_2)         @maps_list.push(@map_3)         @maps_list.push(@map_4)       end     else # draw the map and save it in the Cache       draw_map     end     # create vertical elements from tiles     data_V = Data_Vertical_Sprites.new(viewport)     # @sprites_V : list of vertical sprites (Sprite_V)     @sprites_V = data_V.list_sprites_V     # @sprites_V_animated : list of animated vertical sprites (Sprite_V)     @sprites_V_animated = data_V.list_sprites_V_animated     @Angle = $game_system.angle # map's slant angle (in degree)     @distance_h = 480 # distance between the map's center and the vanishing point     @pivot = 256 # screenline's number of the slant's pivot     @index_animated = 0 # 0..3 : index of animated tiles pattern     @viewport = viewport     @tone_values = {} # list of the tone values for each line     @opacity_values = {} # list of the opacity values for each line     init_sprites(@angle) # initialize screenlines sprites   end   #--------------------------------------------------------------------------   # * Dispose   #--------------------------------------------------------------------------   def dispose     # dispose of @sprites (scanlines), @sprites_V (vertical_sprites), and     # @sprites_loop_x (additional scanlines for horizontal looping)     for sprite in @sprites + @sprites_V + @sprites_loop_x       sprite.dispose     end     @sprites.clear     @sprites_loop_x.clear     @sprites_V.clear     @sprites_V_animated.clear     @maps_list.clear     $game_system.angle = @angle   end   #--------------------------------------------------------------------------   # * Increase slant's angle   #--------------------------------------------------------------------------   def increase_angle     return if @Angle == 88     @angle = [@angle + 2, 88].min # angle's value between 0 and 88 degrees     @sprites.clear     @sprites_loop_x.clear     init_sprites(@angle) # reinitialize screenlines sprites   end   #--------------------------------------------------------------------------   # * Decrease slant's angle   #--------------------------------------------------------------------------   def decrease_angle     return if @angle == 0     @angle = [@angle - 2, 0].max # angle's value between 0 and 88 degrees     @sprites.clear     @sprites_loop_x.clear     init_sprites(@angle) # reinitialize screenlines sprites   end   #--------------------------------------------------------------------------   # * Slide from the current angle into the target value   #     value  : target angle's value (in degree)   #--------------------------------------------------------------------------   def mode7_set_p(value)     while value > @angle       increase_angle       spriteset.update       Graphics.update     end     while value < @angle       decrease_angle       spriteset.update       Graphics.update     end   end   #--------------------------------------------------------------------------   # * Redraw the map instantaneously with the new slant angle's value   #     value  : target angle's value (in degree)   #--------------------------------------------------------------------------   def mode7_set(value)     @angle = [[value, 0].max, 89].min     @sprites.clear     @sprites_loop_x.clear     init_sprites(@angle) # reinitialize screenlines sprites     update     Graphics.update   end   #--------------------------------------------------------------------------   # * Reinitialize screenlines sprites   #--------------------------------------------------------------------------   def mode7_redraw     @sprites.clear     @sprites_loop_x.clear     init_sprites(@angle) # reinitialize scanlines     update     Graphics.update   end   #--------------------------------------------------------------------------   # * Create sprites equivalent to scanlines   #     value  : target angle's value (in degree)   #--------------------------------------------------------------------------   def init_sprites(angle)     @horizon = $game_system.horizon     angle_rad = (Math::PI * angle) / 180 # angle in radian     @sprites = [] # list of the scanlines sprites (Sprite)     @sprites_loop_x = [] # list of the additionnal sprites (for X-looping)     cos_angle = Math.cos(angle_rad)     sin_angle = Math.sin(angle_rad)     # save values in $game_temp     $game_temp.distance_h = @distance_h     $game_temp.pivot = @pivot     $game_temp.cos_angle = cos_angle     $game_temp.sin_angle = sin_angle     # h0, z0 : intermediate values     h0 = (- @distance_h * @pivot * cos_angle).to_f /     (@distance_h + @pivot * sin_angle) + @pivot     z0 = @distance_h.to_f / (@distance_h + @pivot * sin_angle)     $game_temp.slope_value = (1.0 - z0) / (@pivot - h0)     $game_temp.corrective_value = 1.0 - @pivot * $game_temp.slope_value     last_line = - @pivot - @horizon # last_line : the highest line that is drawn     height_limit = (@distance_h * last_line * cos_angle).to_f /     (@distance_h - last_line * sin_angle) + @pivot # the line corresponding to     # the last_line in the warped reference = horizon's line     $game_temp.height_limit = height_limit     # constant to handle gradual opacity     k2lim = ((@distance_h * last_line).to_f /       (@distance_h * cos_angle + last_line * sin_angle)).to_i     # one sprite is created for each screenline     for j in 0..479       next if j < height_limit # if the line is further than the horizon's line,       # no sprite is created       i = j - @pivot # y-reference is the pivot's line       sprite = Sprite.new(@viewport)       sprite.x = 320 # x-reference is the vertical line in the middle of the screen       sprite.y = j       sprite.z = - 99999 # map must not mask vertical elements       sprite.y_origin_bitmap = (@distance_h * i).to_f /       (@distance_h * cos_angle + i * sin_angle) + @pivot       sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap + 0.5).to_i       sprite.y_origin_bitmap_i %= @height if $game_system.loop_y       sprite.zoom_x = $game_temp.slope_value * j + $game_temp.corrective_value       sprite.length = 2 + (640.to_f / sprite.zoom_x).to_i       sprite.x_origin_bitmap_i = ((642 - sprite.length) / 2)       sprite.x_origin_bitmap_i %= @width if $game_system.loop_x       sprite.x_origin_bitmap = (sprite.x_origin_bitmap_i).to_f       sprite.ox = sprite.length / 2       sprite.bitmap = @map       # horizontal translation to center around the hero       if @disp_x != 0         sprite.x_origin_bitmap += @disp_x / 4         sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i         sprite.x_origin_bitmap_i %= @width if $game_system.loop_x       end       # vertical translation to center around the hero       if @disp_y != 0         sprite.y_origin_bitmap += @disp_y / 4         sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap + 0.5).to_i         sprite.y_origin_bitmap_i %= @height if $game_system.loop_y       end       # handle opacity and tone       k2 = ((@distance_h * i).to_f /       (@distance_h * cos_angle + i * sin_angle)).to_i       k2 = 0 if k2 > 0       k_red = (- k2.to_f/k2lim * $game_system.map_gradual_tone.red).to_i       k_green = (- k2.to_f/k2lim * $game_system.map_gradual_tone.green).to_i       k_blue = (- k2.to_f/k2lim * $game_system.map_gradual_tone.blue).to_i       k_gray = (- k2.to_f/k2lim * $game_system.map_gradual_tone.gray).to_i       k2 = (- k2.to_f/k2lim * $game_system.map_gradual_opacity).to_i       sprite.tone = Tone.new(k_red, k_green, k_blue, k_gray)       sprite.opacity = 255 - k2       sprite.opacity *= ($game_system.map_opacity).to_f / 255       sprite.color = $game_system.map_tone       # white horizon's line       k = j - height_limit       k = 500 / k       if $game_system.white_horizon         tone_red = sprite.tone.red + k         tone_green = sprite.tone.green + k         tone_blue = sprite.tone.blue + k         tone_gray = sprite.tone.gray + k         sprite.tone = Tone.new(tone_red, tone_green, tone_blue, tone_gray)       end       @tone_values[j] = sprite.tone       @opacity_values[j] = sprite.opacity       # set sprite's graphics       sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,       sprite.length, 1)       @sprites.push(sprite)       if $game_system.loop_x and j < @pivot         # additional sprite to handle horizontal looping         sprite2 = Sprite.new(@viewport)         sprite2.x = 320         sprite2.y = j         sprite2.z = - 99999         sprite2.y_origin_bitmap = sprite.y_origin_bitmap         sprite2.y_origin_bitmap_i = sprite.y_origin_bitmap_i         sprite2.zoom_x = sprite.zoom_x         sprite2.length = sprite.length         sprite2.x_origin_bitmap_i = sprite.x_origin_bitmap_i - @width         sprite2.x_origin_bitmap = sprite.x_origin_bitmap_i - @width         sprite2.ox = sprite.ox         sprite2.bitmap = @map         sprite2.opacity = sprite.opacity         sprite2.color = sprite.color         sprite2.tone = sprite.tone         sprite2.src_rect.set(sprite2.x_origin_bitmap_i, sprite2.y_origin_bitmap_i,         sprite2.length, 1)         @sprites_loop_x.push(sprite2)       end     end   end   #--------------------------------------------------------------------------   # * Update the screenlines sprites and the vertical sprites   #   compare tilemap's display with map's display   #--------------------------------------------------------------------------   def update     # update screenlines sprites     if @disp_y < $game_map.display_y       difference = $game_map.display_y - @disp_y       @disp_y += difference       for sprite in @sprites + @sprites_loop_x         sprite.y_origin_bitmap += difference.to_f / 4         sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap+0.5).to_i         sprite.y_origin_bitmap_i %= @height if $game_system.loop_y         sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,         sprite.length, 1)       end     end     if @disp_y > $game_map.display_y       difference = @disp_y - $game_map.display_y       @disp_y -= difference       for sprite in @sprites + @sprites_loop_x         sprite.y_origin_bitmap -= difference.to_f / 4         sprite.y_origin_bitmap_i = (sprite.y_origin_bitmap+0.5).to_i         sprite.y_origin_bitmap_i %= @height if $game_system.loop_y         sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,         sprite.length, 1)       end     end     if @disp_x < $game_map.display_x       difference = $game_map.display_x - @disp_x       @disp_x += difference       for sprite in @sprites         sprite.x_origin_bitmap += difference.to_f / 4         sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i         sprite.x_origin_bitmap_i %= @width if $game_system.loop_x         sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,         sprite.length, 1)       end       for sprite in @sprites_loop_x         sprite.x_origin_bitmap += difference.to_f / 4         sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i         sprite.x_origin_bitmap_i %= @width         sprite.x_origin_bitmap_i -= @width         sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,         sprite.length, 1)       end     end     if @disp_x > $game_map.display_x       difference = @disp_x - $game_map.display_x       @disp_x -= difference       for sprite in @sprites         sprite.x_origin_bitmap -= difference.to_f / 4         sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i         sprite.x_origin_bitmap_i %= @width if $game_system.loop_x         sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,         sprite.length, 1)       end       for sprite in @sprites_loop_x         sprite.x_origin_bitmap -= difference.to_f / 4         sprite.x_origin_bitmap_i = (sprite.x_origin_bitmap).to_i         sprite.x_origin_bitmap_i %= @width         sprite.x_origin_bitmap_i -= @width         sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,         sprite.length, 1)       end     end     # update vertical sprites     for sprite in @sprites_V       sprite.update     end   end   #--------------------------------------------------------------------------   # * Update animation for animated tiles   #--------------------------------------------------------------------------   def update_animated     @index_animated += 1     @index_animated %= 4     map = @maps_list[@index_animated]     # update screenlines sprites     for sprite in @sprites + @sprites_loop_x       sprite.bitmap = map       sprite.src_rect.set(sprite.x_origin_bitmap_i, sprite.y_origin_bitmap_i,       sprite.length, 1)     end     # update vertical sprites     for sprite in @sprites_V_animated       sprite.update_animated(@index_animated)     end   end   #--------------------------------------------------------------------------   # * Create bitmaps representing the map   #--------------------------------------------------------------------------   def draw_map     data = $game_map.data     # Table where animated tiles are flagged     data_animated = Table.new($game_map.width, $game_map.height)     # bigger maps to handle horizontal looping     offset = ($game_system.loop_x ? 640 : 0)     @map = Bitmap.new(@width + offset, @height)     @maps_list.push(@map)     rect = Rect.new(0, 0, 32, 32)     # create autotiles graphics     RPG::Cache.clear     @autotiles = []     for i in 0..6       autotile_name = $game_map.autotile_names       fichier = RPG::Cache.autotile(autotile_name)       for l in 0..3         data_autotile = Data_Autotiles.new(fichier,l)         data_autotile.number = 4*i + l         RPG::Cache.save_autotile(data_autotile, data_autotile.number)         @autotiles.push(data_autotile)       end     end     # scan map's data to draw it     for i in 0...$game_map.height       for j in 0...$game_map.width         data_animated[j, i] = 0         # tile's ID for the first layer         value1 = data[j, i, 0].to_i         # prevent from drawing a vertical tile         value1 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value1]) ?         0 : value1)         # value1 != 0         if value1 != 0           # tile's ID for the second layer           value2 = data[j, i, 1].to_i           # prevent from drawing a vertical tile           value2 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value2]) ?           0 : value2)           # tile's ID for the third layer           value3 = data[j, i, 2].to_i           # prevent from drawing a vertical tile           value3 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value3]) ?           0 : value3)           # value1 != 0, value2 = 0           if value2 == 0             # value1 != 0, value2 = 0, value3 = 0             if value3 == 0               # value1 associated with a normal autotile               if value1 > 383                 bitmap = RPG::Cache.tile($game_map.tileset_name, value1, 0)                 @map.blt(32*j, 32*i, bitmap, rect)                 if $game_system.loop_x and j.between?(0, 19)                   @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)                 end               # value1 associated with an autotile               else                 num = 4*((value1 / 48) - 1)                 bitmap = RPG::Cache.autotile_base(num, value1)                 if @autotiles[num].animated                   data_animated[j, i] = 1                 end                 @map.blt(32*j, 32*i, bitmap, rect)                 if $game_system.loop_x and j.between?(0, 19)                   @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)                 end               end             # value1 != 0, value2 = 0, value3 != 0             else               bitmap = RPG::Cache_Tile.load(value1, value3)               # value1 associated with an autotile               if value1 < 384                 num = 4*((value1 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               # value3 associated with an autotile               if value3 < 384                 num = 4*((value3 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               @map.blt(32*j, 32*i, bitmap, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)               end             end           # value1 != 0, value2 != 0           else             # value1 != 0, value2 != 0, value3 = 0             if value3 == 0               bitmap = RPG::Cache_Tile.load(value1, value2)               # value1 associated with an autotile               if value1 < 384                 num = 4*((value1 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               # value2 associated with an autotile               if value2 < 384                 num = 4*((value2 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               @map.blt(32*j, 32*i, bitmap, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)               end             # value1 != 0, value2 != 0, value3 != 0             else               bitmap = RPG::Cache_Tile.load2(value1, value2, value3)               # value1 associated with an autotile               if value1 < 384                 num = 4*((value1 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               # value2 associated with an autotile               if value2 < 384                 num = 4*((value2 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               # value3 associated with an autotile               if value3 < 384                 num = 4*((value3 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               @map.blt(32*j, 32*i, bitmap, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)               end             end           end         # value1 = 0         else           value2 = data[j, i, 1].to_i           value2 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value2]) ?           0 : value2)           value3 = data[j, i, 2].to_i           value3 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value3]) ?           0 : value3)           # value1 = 0, value2 = 0           if value2 == 0             # value1 = 0, value2 = 0, value3 != 0             if value3 != 0               # value3 associated with a normal tile               if value3 > 383                 bitmap = RPG::Cache.tile($game_map.tileset_name, value3, 0)                 @map.blt(32*j, 32*i, bitmap, rect)                 if $game_system.loop_x and j.between?(0, 19)                   @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)                 end               # value3 associated with an autotile               else                 num = 4*((value3 / 48) - 1)                 bitmap = RPG::Cache.autotile_base(num, value3)                 if @autotiles[num].animated                   data_animated[j, i] = 1                 end                 @map.blt(32*j, 32*i, bitmap, rect)                 if $game_system.loop_x and j.between?(0, 19)                   @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)                 end               end             end           # value1 = 0, value2 != 0           else             # value1 = 0, value2 != 0, value3 = 0             if value3 == 0               # value2 associated with a normal tile               if value2 > 383                 bitmap = RPG::Cache.tile($game_map.tileset_name, value2, 0)                 @map.blt(32*j, 32*i, bitmap, rect)                 if $game_system.loop_x and j.between?(0, 19)                   @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)                 end               # value2 associated with an autotile               else                 num = 4*((value2 / 48) - 1)                 bitmap = RPG::Cache.autotile_base(num, value2)                 if @autotiles[num].animated                   data_animated[j, i] = 1                 end                 @map.blt(32*j, 32*i, bitmap, rect)                 if $game_system.loop_x and j.between?(0, 19)                   @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)                 end               end             # value1 = 0, value2 != 0, value3 != 0             else               bitmap = RPG::Cache_Tile.load(value2, value3)               # value2 associated with an autotile               if value2 < 384                 num = 4*((value2 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               # value3 associated with an autotile               if value3 < 384                 num = 4*((value3 / 48) - 1)                 data_animated[j, i] = 1 if @autotiles[num].animated               end               @map.blt(32*j, 32*i, bitmap, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map.blt(32*(j+$game_map.width), 32*i, bitmap, rect)               end             end           end         end       end     end     # save the map's drawing in the Cache     RPG::Cache_Carte.save(@id, @map)     @map_ground = @map.clone     # save a copy of the map to handle flat events     RPG::Cache_Carte.save(@id, @map_ground, 4)     return if !$game_system.animated     # create 3 other maps in case of animated tiles     @map_2 = @map.clone     @map_3 = @map.clone     @map_4 = @map.clone     @maps_list.push(@map_2)     @maps_list.push(@map_3)     @maps_list.push(@map_4)     for i in 0...$game_map.height       for j in 0...$game_map.width         next if data_animated[j, i].to_i == 0         # modify the tile if it is flagged as animated         value1 = data[j, i, 0].to_i         value2 = data[j, i, 1].to_i         value3 = data[j, i, 2].to_i         # prevent from drawing a vertical tile         value1 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value1]) ?         0 : value1)         value2 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value2]) ?         0 : value2)         value3 = ($terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value3]) ?         0 : value3)         if value1 != 0           if value2 == 0             if value3 == 0               num = 4*((value1 / 48) - 1)               bitmap_2 = RPG::Cache.autotile_base(num+1, value1)               bitmap_3 = RPG::Cache.autotile_base(num+2, value1)               bitmap_4 = RPG::Cache.autotile_base(num+3, value1)               @map_2.blt(32*j, 32*i, bitmap_2, rect)               @map_3.blt(32*j, 32*i, bitmap_3, rect)               @map_4.blt(32*j, 32*i, bitmap_4, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)                 @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)                 @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)               end             else               bitmap_2 = RPG::Cache_Tile.load(value1, value3, 1)               bitmap_3 = RPG::Cache_Tile.load(value1, value3, 2)               bitmap_4 = RPG::Cache_Tile.load(value1, value3, 3)               @map_2.blt(32*j, 32*i, bitmap_2, rect)               @map_3.blt(32*j, 32*i, bitmap_3, rect)               @map_4.blt(32*j, 32*i, bitmap_4, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)                 @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)                 @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)               end             end           else             if value3 == 0               bitmap_2 = RPG::Cache_Tile.load(value1, value2, 1)               bitmap_3 = RPG::Cache_Tile.load(value1, value2, 2)               bitmap_4 = RPG::Cache_Tile.load(value1, value2, 3)               @map_2.blt(32*j, 32*i, bitmap_2, rect)               @map_3.blt(32*j, 32*i, bitmap_3, rect)               @map_4.blt(32*j, 32*i, bitmap_4, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)                 @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)                 @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)               end             else               bitmap_2 = RPG::Cache_Tile.load2(value1, value2, value3, 1)               bitmap_3 = RPG::Cache_Tile.load2(value1, value2, value3, 2)               bitmap_4 = RPG::Cache_Tile.load2(value1, value2, value3, 3)               @map_2.blt(32*j, 32*i, bitmap_2, rect)               @map_3.blt(32*j, 32*i, bitmap_3, rect)               @map_4.blt(32*j, 32*i, bitmap_4, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)                 @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)                 @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)               end             end           end         else           if value2 != 0             if value3 == 0               num = 4*((value2 / 48) - 1)               bitmap_2 = RPG::Cache.autotile_base(num+1, value2)               bitmap_3 = RPG::Cache.autotile_base(num+2, value2)               bitmap_4 = RPG::Cache.autotile_base(num+3, value2)               @map_2.blt(32*j, 32*i, bitmap_2, rect)               @map_3.blt(32*j, 32*i, bitmap_3, rect)               @map_4.blt(32*j, 32*i, bitmap_4, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)                 @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)                 @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)               end             else               bitmap_2 = RPG::Cache_Tile.load(value2, value3, 1)               bitmap_3 = RPG::Cache_Tile.load(value2, value3, 2)               bitmap_4 = RPG::Cache_Tile.load(value2, value3, 3)               @map_2.blt(32*j, 32*i, bitmap_2, rect)               @map_3.blt(32*j, 32*i, bitmap_3, rect)               @map_4.blt(32*j, 32*i, bitmap_4, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)                 @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)                 @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)               end             end           else             if value3 != 0               num = 4*((value3 / 48) - 1)               bitmap_2 = RPG::Cache.autotile_base(num+1, value3)               bitmap_3 = RPG::Cache.autotile_base(num+2, value3)               bitmap_4 = RPG::Cache.autotile_base(num+3, value3)               @map_2.blt(32*j, 32*i, bitmap_2, rect)               @map_3.blt(32*j, 32*i, bitmap_3, rect)               @map_4.blt(32*j, 32*i, bitmap_4, rect)               if $game_system.loop_x and j.between?(0, 19)                 @map_2.blt(32*(j+$game_map.width), 32*i, bitmap_2, rect)                 @map_3.blt(32*(j+$game_map.width), 32*i, bitmap_3, rect)                 @map_4.blt(32*(j+$game_map.width), 32*i, bitmap_4, rect)               end             end           end         end       end     end     # save the three additional maps in the Cache     RPG::Cache_Carte.save(@id, @map_2, 1)     RPG::Cache_Carte.save(@id, @map_3, 2)     RPG::Cache_Carte.save(@id, @map_4, 3)   end   #--------------------------------------------------------------------------   # * no tileset for mode7 maps   #--------------------------------------------------------------------------   def tileset     return nil   end end

#============================================================================ #此脚本增加了一种深入的地图。 #作者MGCaladtogel #中文版(24/04/08) #============================================================================ # ■ Game_Map #------------------------------------------------- --------------------------- # 方法处理地图变通循环 #============================================================================ class Game_Map   #--------------------------------------------------------------------------   # *向下滚动，   # 距离：滚动的距离   #--------------------------------------------------------------------------   alias scroll_down_mode7_game_map scroll_down   def scroll_down(distance)     if !$game_system.mode7       scroll_down_mode7_game_map(distance)       return     end     if $game_system.loop_y or $game_system.always_scroll       @display_y = @display_y + distance # always scroll     else       @display_y = [@display_y + distance, (self.height - 15) * 128].min     end   end     #--------------------------------------------------------------------------     #  *滚动左     #距离：滚动的距离     #--------------------------------------------------------------------------   alias scroll_left_mode7_game_map scroll_left   def scroll_left(distance)     if !$game_system.mode7       scroll_left_mode7_game_map(distance)       return     end     if $game_system.loop_x or $game_system.always_scroll       @display_x = @display_x - distance # always scroll     else       @display_x = [@display_x - distance, 0].max     end   end   #--------------------------------------------------------------------------   # *滚动权   # 距离：滚动的距离   #--------------------------------------------------------------------------   alias scroll_right_mode7_game_map scroll_right   def scroll_right(distance)     if !$game_system.mode7       scroll_right_mode7_game_map(distance)       return     end     if $game_system.loop_x or $game_system.always_scroll       @display_x = @display_x + distance # always scroll     else       @display_x = [@display_x + distance, (self.width - 20) * 128].min     end   end   #--------------------------------------------------------------------------   #  *向上滚动   #  距离：滚动的距离   #--------------------------------------------------------------------------   alias scroll_up_mode7_game_map scroll_up   def scroll_up(distance)     if !$game_system.mode7       scroll_up_mode7_game_map(distance)       return     end     if $game_system.loop_y or $game_system.always_scroll       @display_y = @display_y - distance # always scroll     else       @display_y = [@display_y - distance, 0].max     end   end   #--------------------------------------------------------------------------   #  *确定有效坐标   #  x： X的坐标   #  y： Y的坐标   #  允许英雄走出去的地图时，地图循   #--------------------------------------------------------------------------   alias valid_mode7_game_map? valid?   def valid?(x, y)     if !$game_system.mode7       return (valid_mode7_game_map?(x, y))     end     if $game_system.loop_x       if $game_system.loop_y         return true       else         return (y >= 0 and y < height)       end     elsif $game_system.loop_y       return (x >= 0 and x < width)     end     return (x >= 0 and x < width and y >= 0 and y < height)   end   #--------------------------------------------------------------------------   # * Determine if Passable   #     x          : x-coordinate   #     y          : y-coordinate   #     d          : direction (0,2,4,6,8,10)   #                  *  0,10 = determine if all directions are impassable   #     self_event : Self (If event is determined passable)   #--------------------------------------------------------------------------   alias passable_mode7_game_map? passable?   def passable?(x, y, d, self_event = nil)     if !$game_system.mode7       passable_mode7_game_map?(x, y, d, self_event)       return(passable_mode7_game_map?(x, y, d, self_event))     end     unless valid?(x, y)       return false     end     bit = (1 << (d / 2 - 1)) & 0x0f     for event in events.values       if event.tile_id >= 0 and event != self_event and          event.x == x and event.y == y and not event.through         if @passages[event.tile_id] & bit != 0           return false         elsif @passages[event.tile_id] & 0x0f == 0x0f           return false         elsif @priorities[event.tile_id] == 0           return true         end       end     end     for i in [2, 1, 0]       tile_id = data[x % width, y % height, i] # handle map looping       if tile_id == nil         return false       elsif @passages[tile_id] & bit != 0         return false       elsif @passages[tile_id] & 0x0f == 0x0f         return false       elsif @priorities[tile_id] == 0         return true       end     end     return true   end   #--------------------------------------------------------------------------   # * Setup   #     map_id : map ID   #--------------------------------------------------------------------------   alias old_setup_mode7 setup   def setup(map_id)     old_setup_mode7(map_id)     if !$game_switches[$enable_mode7_number]       $game_system.mode7 = false       $game_system.mode7 = false       $game_system.loop_x = false       $game_system.loop_y = false       $game_system.always_scroll = false       $game_system.animated = false       $game_system.white_horizon = false       $game_system.angle = 0       $game_system.fixed_panorama = false       $game_system.ov = false       $game_system.ov_zoom = 0.6       $game_system.reset       return     end     map_data = $data_maps[$game_map.map_id]     for keyword in $mode7_maps_settings.keys       if map_data.name2.include?(keyword)         command_list = $mode7_maps_settings[keyword]         $game_system.mode7 = true         $game_system.loop_x = command_list.include?("X")         $game_system.loop_y = command_list.include?("Y")         $game_system.always_scroll = command_list.include?("C")         $game_system.animated = command_list.include?("A")         $game_system.white_horizon = command_list.include?("H")         $game_system.fixed_panorama = command_list.include?("P")         $game_system.ov = command_list.include?("OV")         for command in command_list           if command.include?("#")             $game_system.angle = (command.slice(1, 2)).to_i             $game_system.angle = [[$game_system.angle, 0].max, 89].min             break           end         end         return       end     end     $game_system.mode7 = map_data.name2.include?("[M7]")     $game_system.loop_x = map_data.name2.include?("[X]")     $game_system.loop_y = map_data.name2.include?("[Y]")     $game_system.always_scroll = map_data.name2.include?("[C]")     $game_system.animated = map_data.name2.include?("[A]")     $game_system.white_horizon = map_data.name2.include?("[H]")     $game_system.fixed_panorama = map_data.name2.include?("[P]")     $game_system.ov = map_data.name2.include?("[OV]")     if $game_system.mode7       map_data.name2 =~ /\[#[ ]*([00-99]+)\]/i       $game_system.angle = $1.to_i       $game_system.angle = [[$game_system.angle, 0].max, 89].min     end   end end #============================================================================ # ■ Game_Character #---------------------------------------------------------------------------- # “更新”的方法变通处理地图循环 #============================================================================ class Game_Character   attr_accessor :x   attr_accessor :y   attr_accessor :real_x   attr_accessor :real_y   attr_reader   :flat   attr_reader   :height   #--------------------------------------------------------------------------   # * Object Initialization   #--------------------------------------------------------------------------   alias initialize_mode7_game_character initialize   def initialize     initialize_mode7_game_character     @flat = false     @height = 0.0   end   #--------------------------------------------------------------------------   # * Update   #--------------------------------------------------------------------------   alias update_mode7_game_character update   def update     if !$game_system.mode7       update_mode7_game_character       return     end     # if x-coordinate is out of the map     if !(x.between?(0, $game_map.width - 1))       difference = 128 * x - real_x       if self.is_a?(Game_Player)         # increase or decrease map's number         self.map_number_x += difference / (difference.abs)       end       # x-coordinate is equal to its equivalent in the map       self.x %= $game_map.width       self.real_x = 128 * x - difference     end     # if y-coordinate is out of the map     if !(y.between?(0, $game_map.height - 1))       difference = 128 * y - real_y       if self.is_a?(Game_Player)         # increase or decrease map's number         self.map_number_y += difference / (difference.abs)       end       # y-coordinate is equal to its equivalent in the map       self.y %= $game_map.height       self.real_y = 128 * y - difference     end     update_mode7_game_character   end end #============================================================================== # ■ Game_Event #---------------------------------------------------------------------------- # Add methods to handle flat events and altitude for vertical event #============================================================================ class Game_Event < Game_Character   #--------------------------------------------------------------------------   #    *扫描事件的命令列表   #页：扫描网页（ RPG游戏：:活动：:页）   #--------------------------------------------------------------------------   def check_commands(page)     @height = 0.0     command_list = page.list     for k in 0..command_list.length - 2       command = command_list[k]       if (command.parameters[0].to_s).include?("Height")         @height = (command.parameters[0][7,command.parameters[0].length-1]).to_f       end       @flat = (command.parameters[0].to_s).include?("Flat")     end   end   #--------------------------------------------------------------------------   # * scan the event's commands list of the current page when refreshed   #--------------------------------------------------------------------------   alias refresh_mode7_game_character refresh   def refresh     refresh_mode7_game_character     check_commands(@page) if @page != nil   end end #============================================================================ # ■ Game_Player #---------------------------------------------------------------------------- # Add attributes to have a well-working panorama's scrolling #============================================================================ class Game_Player < Game_Character   attr_accessor :map_number_x # map's number with X-looping   attr_accessor :map_number_y # map's number with Y-looping   #--------------------------------------------------------------------------   # * Object Initialization   #--------------------------------------------------------------------------   alias initialize_mode7_game_player initialize   def initialize     initialize_mode7_game_player     self.map_number_x = 0     self.map_number_y = 0   end   #--------------------------------------------------------------------------   # * Handle the option : center around the hero   #--------------------------------------------------------------------------   alias center_mode7_game_player center   def center(x, y)     if !$game_system.loop_y and !$game_system.always_scroll#!$game_system.mode7       center_mode7_game_player(x, y)       return     end     $game_map.display_x = x * 128 - CENTER_X     $game_map.display_y = y * 128 - CENTER_Y   end end #============================================================================ # ■ Sprite #---------------------------------------------------------------------------- # Add attributes to work efficiently with scanlines sprites #============================================================================ class Sprite   attr_accessor :y_origin_bitmap # bitmap's y-coordinate for the "src_rect.set"   #method (float)   attr_accessor :x_origin_bitmap # bitmap's x-coordinate for the "src_rect.set"   #method (float)   attr_accessor :y_origin_bitmap_i # bitmap's y-coordinate for the   #"src_rect.set" method (integer)   attr_accessor :x_origin_bitmap_i # bitmap's x-coordinate for the   #"src_rect.set" method (integer)   attr_accessor :length # sprite's width end #============================================================================ # ■ Sprite_Character #---------------------------------------------------------------------------- # Calculate x-coordinate and y-coordinate for a mode7 map #============================================================================ class Sprite_Character < RPG::Sprite   attr_reader   :flat_indicator # true if the event is flat-drawn   #--------------------------------------------------------------------------   # * Object Initialization   #--------------------------------------------------------------------------   alias initialize_mode7_sprite_character initialize   def initialize(viewport, character = nil)     @flat_indicator = false     initialize_mode7_sprite_character(viewport, character)   end   #--------------------------------------------------------------------------   # * Update   #--------------------------------------------------------------------------   alias update_mode7_sprite_character update   def update     if !$game_system.mode7       update_mode7_sprite_character       return     end     if @flat_indicator       if ([email protected] or @character.moving? or         @tile_id != @character.tile_id or         @character_name != @character.character_name or         @character_hue != @character.character_hue)         @flat_indicator = @character.flat         # redraw the original ground         maps_list = $scene.spriteset.tilemap.maps_list         map_ground = $scene.spriteset.tilemap.map_ground         rect = Rect.new(@flat_x_map, @flat_y_map, @flat_width, @flat_height)         for map in maps_list           map.blt(@flat_x_map, @flat_y_map, map_ground, rect)           if $game_system.loop_x and @flat_x_map.between?(0, 19 * 32)             map.blt(@flat_x_map + 32 * $game_map.width, @flat_y_map, map_ground,             rect)           end         end       else         return       end     end     super     if @tile_id != @character.tile_id or        @character_name != @character.character_name or        @character_hue != @character.character_hue       @tile_id = @character.tile_id       @character_name = @character.character_name       @character_hue = @character.character_hue       if @tile_id >= 384         self.bitmap = RPG::Cache.tile($game_map.tileset_name,           @tile_id, @character.character_hue)         self.src_rect.set(0, 0, 32, 32)         self.ox = 16         self.oy = 32       else         self.bitmap = RPG::Cache.character(@character.character_name,           @character.character_hue)         @cw = bitmap.width / 4         @ch = bitmap.height / 4         self.ox = @cw / 2         self.oy = @ch         # pivot correction (intersection between the map and this sprite)         self.oy -= 4       end     end     self.visible = (not @character.transparent)     if @tile_id == 0       sx = @character.pattern * @cw       sy = (@character.direction - 2) / 2 * @ch       self.src_rect.set(sx, sy, @cw, @ch)     end     if @character.flat # event must be flat drawn       return if $scene.spriteset == nil       if @tile_id == 0         @flat_x_map = @character.real_x / 4 - (@cw - 32) / 2         @flat_y_map = @character.real_y / 4 - @ch + 32         @flat_x0 = sx         @flat_y0 = sy         @flat_width = @cw         @flat_height = @ch       else         @flat_x_map = @character.real_x / 4         @flat_y_map = @character.real_y / 4         @flat_x0 = 0         @flat_y0 = 0         @flat_width = 32         @flat_height = 32       end       # modify the maps graphics       maps_list = $scene.spriteset.tilemap.maps_list       rect = Rect.new(@flat_x0, @flat_y0, @flat_width, @flat_height)       for map in maps_list         map.blt(@flat_x_map, @flat_y_map, bitmap, rect, @character.opacity)         if $game_system.loop_x and @flat_x_map.between?(0, 19 * 32)           map.blt(@flat_x_map + 32 * $game_map.width, @flat_y_map, bitmap, rect,           @character.opacity)         end       end       @flat_indicator = true       self.opacity = 0       return     end     x_intermediate = @character.screen_x     y_intermediate = @character.screen_y     y_intermediate -= $game_temp.pivot + 4 if $game_system.mode7     # if vertical looping     if $game_system.loop_y       h = 32 * $game_map.height       y_intermediate = (y_intermediate + h / 2) % h - h / 2     end     # coordinates in a mode7 map     self.y = (($game_temp.distance_h * y_intermediate *     $game_temp.cos_angle).to_f / ($game_temp.distance_h - y_intermediate *     $game_temp.sin_angle) + $game_temp.pivot)     self.zoom_x = $game_temp.slope_value * y + $game_temp.corrective_value     self.zoom_y = zoom_x     self.x = 320 + zoom_x * (x_intermediate - 320)     # if horizontal looping     if $game_system.loop_x       offset = ($game_map.width >= 24 ? 64 * zoom_x : 0)       l = 32 * $game_map.width * zoom_x       self.x = (x + offset) % l - offset     end     if @character.is_a?(Game_Player)       # Overworld Sprite Resize       if $game_system.ov         self.zoom_x *= $game_system.ov_zoom         self.zoom_y *= $game_system.ov_zoom       end     end        self.z = @character.screen_z(@ch)     # hide the sprite if it is beyond the horizon's line     self.opacity = (y < $game_temp.height_limit ? 0 : @character.opacity)     self.y -= 32 * @character.height * zoom_y # height correction     self.blend_type = @character.blend_type     self.bush_depth = @character.bush_depth     if @character.animation_id != 0       animation = $data_animations[@character.animation_id]       animation(animation, true)       @character.animation_id = 0     end   end end #============================================================================ # ■ Sprite_V (Vertical Sprites) #---------------------------------------------------------------------------- #  Sprites corresponding to the vertical elements formed by tiles #============================================================================ class Sprite_V < Sprite   attr_accessor :x_map # sprite's x_coordinates (in squares) (Float)   attr_accessor :y_map # sprite's y_coordinates (in squares) (Float)   attr_accessor :square_y # sprite's y_coordinates (in squares) (Integer)   attr_accessor :priority # sprite's priority   attr_accessor :animated # True if animated   attr_accessor :list_bitmap # list of sprite's bitmaps (Bitmap)   #--------------------------------------------------------------------------   # * Update   #--------------------------------------------------------------------------   def update     square_y_corrected = square_y     y_intermediate = 32 * y_map - $game_temp.pivot - $game_map.display_y / 4     y_intermediate_reference = y_intermediate     # if vertical looping     if $game_system.loop_y       y_intermediate = (y_intermediate + $game_temp.height / 2) %       $game_temp.height - $game_temp.height / 2       if y_intermediate_reference < y_intermediate         square_y_corrected = square_y + $game_map.height       elsif y_intermediate_reference > y_intermediate         square_y_corrected = square_y - $game_map.height       end     end     self.y = ($game_temp.distance_h * y_intermediate *     $game_temp.cos_angle).to_f / ($game_temp.distance_h - y_intermediate *     $game_temp.sin_angle) + $game_temp.pivot     if y < $game_temp.height_limit       # hide the sprite if it is beyond the horizon's line       self.opacity = 0       return     end     self.opacity = 255     if $scene.spriteset != nil and $scene.spriteset.tilemap.is_a?(Tilemap_mode7)       opacity_values = $scene.spriteset.tilemap.opacity_values       tone_values = $scene.spriteset.tilemap.tone_values       if opacity_values.has_key?(y)         self.opacity = opacity_values[y]         self.tone = tone_values[y]       end     end     self.zoom_x = $game_temp.slope_value * y + $game_temp.corrective_value     self.zoom_y = zoom_x     x_intermediate = 32 * x_map - $game_map.display_x / 4     self.x = 320 + (zoom_x * (x_intermediate - 320))     # if horizontal looping     if $game_system.loop_x       offset = ($game_map.width >= 24 ? 64 * zoom_x : 0)       l = 32 * $game_map.width * self.zoom_x       self.x = (self.x + offset) % l - offset     end     self.z = (128 * square_y_corrected - $game_map.display_y + 3) / 4 +     32 + 32 * priority     return   end   #--------------------------------------------------------------------------   # * Update bitmap for animation   #     index  : 0..3 : animation's index   #--------------------------------------------------------------------------   def update_animated(index)     self.bitmap = @list_bitmap[index]   end end #============================================================================ # ■ Spriteset_Map #---------------------------------------------------------------------------- #  Modifications to call a mode7 map #============================================================================ class Spriteset_Map   attr_accessor :tilemap # just to be able to access the tilemap   #--------------------------------------------------------------------------   # * Initialize Object   #   Rewritten to call a map with mode7   #--------------------------------------------------------------------------   alias initialize_mode7_spriteset_map initialize   def initialize     if !$game_system.mode7       initialize_mode7_spriteset_map       return     end     @viewport1 = Viewport.new(0, 0, 640, 480)     @viewport2 = Viewport.new(0, 0, 640, 480)     @viewport3 = Viewport.new(0, 0, 640, 480)     @viewport2.z = 200     @viewport3.z = 5000     # mode7 map     @tilemap = Tilemap_mode7.new(@viewport1, self)     @panorama = Plane.new(@viewport1)     # sprites drawn at the horizon's level have a negative z, and with a z value     # of -100000 the panorama is still below     @panorama.z = ($game_system.mode7 ? -100000 : -1000)     @fog = Plane.new(@viewport1)     @fog.z = 3000     @character_sprites = []     for i in $game_map.events.keys.sort       sprite = Sprite_Character.new(@viewport1, $game_map.events)       @character_sprites.push(sprite)     end     @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))     @weather = RPG::Weather.new(@viewport1)     @picture_sprites = []     for i in 1..50       @picture_sprites.push(Sprite_Picture.new(@viewport2,         $game_screen.pictures))     end     @timer_sprite = Sprite_Timer.new     update   end   #--------------------------------------------------------------------------   # * Dispose   #--------------------------------------------------------------------------   def dispose     if @tilemap.tileset != nil       @tilemap.tileset.dispose       for i in 0..6         @tilemap.autotiles.dispose       end     end     @tilemap.dispose     @panorama.dispose     @fog.dispose     for sprite in @character_sprites       sprite.dispose     end     @weather.dispose     for sprite in @picture_sprites       sprite.dispose     end     @timer_sprite.dispose     @viewport1.dispose     @viewport2.dispose     @viewport3.dispose   end   #--------------------------------------------------------------------------   # * Update   #--------------------------------------------------------------------------   alias update_mode7_spriteset_map update   def update     if !$game_system.mode7       update_mode7_spriteset_map       return     end     if @panorama_name != $game_map.panorama_name or        @panorama_hue != $game_map.panorama_hue       @panorama_name = $game_map.panorama_name       @panorama_hue = $game_map.panorama_hue       if @panorama.bitmap != nil         @panorama.bitmap.dispose         @panorama.bitmap = nil       end       if @panorama_name != ""         @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue)       end       Graphics.frame_reset     end     if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue       @fog_name = $game_map.fog_name       @fog_hue = $game_map.fog_hue       if @fog.bitmap != nil         @fog.bitmap.dispose         @fog.bitmap = nil       end       if @fog_name != ""         @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue)       end       Graphics.frame_reset     end     # update animated tiles each 20 frames     if Graphics.frame_count % 20 == 0 and $game_system.animated       @tilemap.update_animated     end     @tilemap.update     # if the panorama is fixed     if $game_system.fixed_panorama       @panorama.ox = 0       @panorama.oy = 0     # if it is a mode7 map     else       # to have a fluent panorama scrolling       @panorama.ox = (128 * $game_map.width * $game_player.map_number_x +       $game_player.real_x) / 8       @panorama.oy = - (128 * $game_map.height * $game_player.map_number_y +       $game_player.real_y) / 32     end     @fog.zoom_x = $game_map.fog_zoom / 100.0     @fog.zoom_y = $game_map.fog_zoom / 100.0     @fog.opacity = $game_map.fog_opacity     @fog.blend_type = $game_map.fog_blend_type     @fog.ox = $game_map.display_x / 4 + $game_map.fog_ox     @fog.oy = $game_map.display_y / 4 + $game_map.fog_oy     @fog.tone = $game_map.fog_tone     for sprite in @character_sprites       sprite.update     end     @weather.type = $game_screen.weather_type     @weather.max = $game_screen.weather_max     @weather.ox = $game_map.display_x / 4     @weather.oy = $game_map.display_y / 4     @weather.update     for sprite in @picture_sprites       sprite.update     end     @timer_sprite.update     @viewport1.tone = $game_screen.tone     @viewport1.ox = $game_screen.shake     @viewport3.color = $game_screen.flash_color     @viewport1.update     @viewport3.update   end end

#============================================================================ #此脚本增加了一种深入的地图。 #作者MGCaladtogel #中文版（ 24/04/08 ） #============================================================================== # ■ Game_Switches #============================================================================== class Game_Switches   #--------------------------------------------------------------------------   # *对象初始化   #--------------------------------------------------------------------------   alias initialize_mode7_game_player initialize   def initialize     initialize_mode7_game_player     self[$enable_mode7_number] = true   end end #============================================================================ # ■ Scene_Map #============================================================================ class Scene_Map   attr_accessor :spriteset #只需要访问spriteset end #============================================================================ # ■ Data_Autotiles #---------------------------------------------------------------------------- # Creates the set of tiles from an autotile's file #============================================================================ class Data_Autotiles < Bitmap   # data list to form tiles from an atotiles file   Data_creation = [[27,28,33,34],[5,28,33,34],[27,6,33,34],[5,6,33,34],   [27,28,33,12],[5,28,33,12],[27,6,33,12],[5,6,33,12],[27,28,11,34],   [5,28,11,34],[27,6,11,34],[5,6,11,34],[27,28,11,12],[5,28,11,12],   [27,6,11,12],[5,6,11,12],[25,26,31,32],[25,6,31,32],[25,26,31,12],   [25,6,31,12],[15,16,21,22],[15,16,21,12],[15,16,11,22],[15,16,11,12],   [29,30,35,36],[29,30,11,36],[5,30,35,36],[5,30,11,36],[39,40,45,46],   [5,40,45,46],[39,6,45,46],[5,6,45,46],[25,30,31,36],[15,16,45,46],   [13,14,19,20],[13,14,19,12],[17,18,23,24],[17,18,11,24],[41,42,47,48],   [5,42,47,48],[37,38,43,44],[37,6,43,44],[13,18,19,24],[13,14,43,44],   [37,42,43,48],[17,18,47,48],[13,18,43,48],[13,18,43,48]]   attr_accessor :number # autotile's number to identify it   attr_accessor :animated # TRUE if the autotile is animated   #--------------------------------------------------------------------------   # * Initialize Object   #     file   : autotiles file's bitmap (Bitmap)   #     l      : 0..3 : pattern's number for animated autotiles   #--------------------------------------------------------------------------   def initialize(file, l)     super(8*32, 6*32)     create(file, l)   end   #--------------------------------------------------------------------------   # * Create the tiles set   #     file   : autotiles file's bitmap (Bitmap)   #     l      : 0..3 : pattern's number for animated autotiles   #--------------------------------------------------------------------------   def create(file, l)     l = (file.width > 96 ? l : 0)     self.animated = (file.width > 96)     for i in 0..5       for j in 0..7         data = Data_creation[8 * i + j]         for number in data           number -= 1           m = 16 * (number % 6)           n = 16 * (number / 6)           blt(32 * j + m % 32, 32 * i + n % 32, file,           Rect.new(m + 96 * l, n, 16, 16))         end       end     end   end end #============================================================================ # ■ Data_Vertical_Sprites #---------------------------------------------------------------------------- # Create a list of vertical sprites for the three layers of a map # "V" for "Vertical" in the script # "num" for "number" #============================================================================ class Data_Vertical_Sprites   attr_accessor  :list_sprites_V # list of vertical sprites   attr_accessor  :list_sprites_V_animated # list of animated vertical sprites   #--------------------------------------------------------------------------   # * A little method to compare terrain_tags   #     value  : tile's ID   #     num    : reference terrain_tag's value   #--------------------------------------------------------------------------   def suitable?(value, num)     return ($game_map.terrain_tags[value] == num)   end   #--------------------------------------------------------------------------   # * This algorithm scans each layer and create a sprites formed by tiles   #   in contact   #     viewport : Viewport   #--------------------------------------------------------------------------   def initialize(viewport)     @viewport = viewport     # lists initialization     self.list_sprites_V = []     self.list_sprites_V_animated = []     # @num_tiles : list of tiles coordinates that form a vertical sprite     @num_tiles = []     # create copy of map's data     @dataV = ($game_map.data).clone     # scan each layer     for h in 0..2       # scan each row       for i in 0..$game_map.height         # scan each column         for j in 0..$game_map.width           value = @dataV[j, i, h].to_i           # if tile's terrain tag is declared to give vertical sprites           if $terrain_tags_vertical_tiles.include?($game_map.terrain_tags[value])             @reference_terrain_tag = $game_map.terrain_tags[value]             @num_tiles.push([j, i])             # the following algorithm is so complex that I really don't know how             # it works exactly             list_end = 0             length = 0             while j + length + 1 < $game_map.width and               suitable?(@dataV[j +length+ 1, i, h].to_i, @reference_terrain_tag)               @num_tiles.push([j + length+ 1,i])               length += 1             end             list_start = j             list_end = length + j             indicator = true             row = 0             j2 = j             while indicator               row += 1               break if (i + row) == $game_map.height               list_start2 = j2               length2 = 0               indicator = false               if length >= 2                 for k in (j2 + 1)..(j2 + length -1)                   if suitable?(@dataV[k, i + row, h].to_i,                     @reference_terrain_tag)                     if !indicator                       list_start2 = k                     else                       length2 = k - list_start2                     end                     indicator = true                     @num_tiles.push([k, i + row])                   elsif !indicator                     length2 -= 1                   end                 end               end               if suitable?(@dataV[j2 + length, i + row, h].to_i,                 @reference_terrain_tag)                 length2 = j2 + length - list_start2                 indicator = true                 @num_tiles.push([j2 + length, i + row])                 length3 = 1                 while j2 + length + length3 < $game_map.width and                   suitable?(@dataV[j2 + length + length3, i + row, h].to_i,                   @reference_terrain_tag)                   @num_tiles.push([j2 + length + length3, i + row])                   length3 += 1                   length2 += 1                   if j2 + length + length3 > list_end                     list_end = j2 + length + length3                   end                 end               end               if suitable?(@dataV[j2, i + row, h].to_i, @reference_terrain_tag)                 list_start3 = list_start2 - j2                 length2 = length2 + list_start3                 list_start2 = j2                 indicator = true                 @num_tiles.push([j2, i + row])                 length3 = 1                 while j2 - length3 >= 0 and                   suitable?(@dataV[j2 - length3, i + row, h].to_i,                   @reference_terrain_tag)                   @num_tiles.push([j2 - length3, i + row])                   length3 += 1                   length2 += 1                   list_start2 -= 1                   if list_start2 < list_start                     list_start = list_start2                   end                 end               end               length = length2               j2 = list_start2             end             row -= 1             # create a bitmap and a sprite from the tiles listed in @num_tiles             create_bitmap(i, list_start, row, list_end - list_start, h)             # clear the used tiles             clear_data(h)             # reinitialize the list of tiles             @num_tiles = []           end         end       end     end   end   #--------------------------------------------------------------------------   # * Clear the used data to prevent from reusing them   #     layer  : current scanned layer   #--------------------------------------------------------------------------   def clear_data(layer)     for num in @num_tiles       @dataV[num[0], num[1], layer] = 0     end   end   #--------------------------------------------------------------------------   # * Create a Bitmap from the listed tiles in @num_tiles and its associated   #   sprite (Sprite_V)   #     row     : start row's value   #     column  : start column's value   #     height  : sprite's height (in tiles)   #     width   : sprite's width (in tiles)   #     layer   : current scanned layer   #--------------------------------------------------------------------------   def create_bitmap(row, column, height, width, layer)     bmp = Bitmap.new(32*(1+width), 32*(1+height))     rect = Rect.new(0, 0, 32, 32)     @num_tiles.sort! {|a, b|  -(a[1] - b[1])}     sprite = Sprite_V.new(@viewport)     # initialize sprite's attributes     sprite.animated = false     sprite.list_bitmap = []     # draw the bitmap     for tile_coordinates in @num_tiles       value = @dataV[tile_coordinates[0], tile_coordinates[1], layer].to_i       # if tile is a normal tile       if value > 383         bitmap = RPG::Cache.tile($game_map.tileset_name, value, 0)       else # tile is an autotile         file = (value / 48) - 1         num_file = 4 * file         if !sprite.animated           autotile_name = $game_map.autotile_names[file]           fichier = RPG::Cache.autotile(autotile_name)           sprite.animated = (fichier.width > 96 ? true : false)         end         bitmap = RPG::Cache.autotile_base(num_file, value)       end       bmp.blt(32 * (tile_coordinates[0] - column),       32 * (tile_coordinates[1] - row), bitmap, rect)     end     sprite.list_bitmap.push(bmp)     # create 3 additionnal bitmaps for animated sprites     if sprite.animated       for j in 1..3         bmp = Bitmap.new(32 * (1 + width), 32 * (1 + height))         for tile_coordinates in @num_tiles           value = @dataV[tile_coordinates[0], tile_coordinates[1], layer].to_i           if value > 383             bitmap = RPG::Cache.tile($game_map.tileset_name, value, 0)           else             num_file = 4 * ((value / 48) - 1)             bitmap = RPG::Cache.autotile_base(num_file + j, value)           end           bmp.blt(32 * (tile_coordinates[0] - column),           32 * (tile_coordinates[1] - row), bitmap, rect)         end         sprite.list_bitmap.push(bmp)       end     end     value = @dataV[@num_tiles[0][0], @num_tiles[0][1], layer].to_i     # set sprite's priority     sprite.priority = $game_map.priorities[value]     # set sprite's coordinates (in squares (32 * 32 pixels))     sprite.x_map = (column.to_f) + bmp.width / 64     sprite.x_map += 0.5 if width % 2 == 0     sprite.y_map = (row + height).to_f + 0.5     sprite.square_y = sprite.y_map.to_i # Integer     # set the y_pivot (intersection between the map and the sprite)     sprite.oy = bmp.height - 16     sprite.ox = bmp.width / 2     sprite.bitmap = sprite.list_bitmap[0]     self.list_sprites_V.push(sprite)     self.list_sprites_V_animated.push(sprite) if sprite.animated   end end #============================================================================ # ■ RPG::Cache_Tile #---------------------------------------------------------------------------- # The tiles resulting in a superimposing of several tiles are kept in memory # for a faster call # valueX : tile's ID #============================================================================ module RPG   module Cache_Tile     @cache = {}     #------------------------------------------------------------------------     # * Superimposing of two tiles, offset = pattern's number for animated     # autotiles     #------------------------------------------------------------------------     def self.load(value1, value2, offset=0)       if not @cache.include?([value1, value2, offset])         bitmap = Bitmap.new(32, 32)         rect = Rect.new(0, 0, 32, 32)         if value1 > 383 # normal tile           bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value1, 0),           rect)         else # autotile           num = 4*((value1 / 48) - 1) + offset           bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value1), rect)         end         if value2 > 383 # normal tile           bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value2, 0),           rect)         else # autotile           num = 4*((value2 / 48) - 1) + offset           bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value2), rect)         end         @cache[[value1, value2, offset]] = bitmap       end       @cache[[value1, value2, offset]]     end     #------------------------------------------------------------------------     # * Superimposing of three tiles     #------------------------------------------------------------------------     def self.load2(value1, value2, value3, offset = 0)       if not @cache.include?([value1, value2, value3, offset])         bitmap = Bitmap.new(32, 32)         rect = Rect.new(0, 0, 32, 32)         if value1 > 383 # normal tile           bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value1, 0),           rect)         else # autotile           num = 4*((value1 / 48) - 1) + offset           bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value1), rect)         end         if value2 > 383 # normal tile           bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value2, 0),           rect)         else # autotile           num = 4*((value2 / 48) - 1) + offset           bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value2), rect)         end         if value3 > 383 # normal tile           bitmap.blt(0, 0, RPG::Cache.tile($game_map.tileset_name, value3, 0),           rect)         else # autotile           num = 4*((value3 / 48) - 1) + offset           bitmap.blt(0, 0, RPG::Cache.autotile_base(num, value3), rect)         end         @cache[[value1, value2, value3, offset]] = bitmap       end       @cache[[value1, value2, value3, offset]]     end     #------------------------------------------------------------------------     # * Clear the Cache     #------------------------------------------------------------------------     def self.clear       @cache = {}       GC.start     end   end end #============================================================================ # ■ RPG::Cache_Carte #---------------------------------------------------------------------------- # Maps drawn with mode7 are kept in memory to have a faster call the next # times they need to be drawn #============================================================================ module RPG   module Cache_Carte     @cache = {}     #------------------------------------------------------------------------     # * Check if the map is in the Cache     #   map_id : map's ID     #------------------------------------------------------------------------     def self.in_cache(map_id)       return @cache.include?(map_id)     end     #------------------------------------------------------------------------     # * Return the map's drawing (Bitmap)     #   map_id : map's ID     #   num    : pattern's number for animated autotiles     #------------------------------------------------------------------------     def self.load(map_id, num = 0)       return @cache[map_id][num]     end     #------------------------------------------------------------------------     # * Save the map's drawing in the Cache     #   map_id : map's ID     #   bitmap    : map's drawing (Bitmap)     #   num    : pattern's number for animated autotiles     #------------------------------------------------------------------------     def self.save(map_id, bitmap, num = 0)       @cache[map_id] = [] if !self.in_cache(map_id)       @cache[map_id][num] = bitmap     end     #------------------------------------------------------------------------     # * Clear the Cache     #------------------------------------------------------------------------     def self.clear       @cache = {}       GC.start     end   end end #============================================================================ # ■ RPG::Cache #---------------------------------------------------------------------------- # The tiles from autotiles files are kept in memory for a faster call #============================================================================ module RPG   module Cache     #------------------------------------------------------------------------     # * Check if the map is in the Cache     #   num    : autotiles file's ID     #   value    : tile's ID     #------------------------------------------------------------------------     def self.autotile_base(num, value)       key = [num, value]       if not @cache.include?(key) or @cache[key].disposed?         @cache[key] = Bitmap.new(32, 32)         num_tile = value % 48         sx = 32 * (num_tile % 8)         sy = 32 * (num_tile / 8)         rect = Rect.new(sx, sy, 32, 32)         @cache[key].blt(0, 0, self.load_autotile(num), rect)       end         @cache[key]     end     #------------------------------------------------------------------------     # * Save the tile's drawing in the Cache     #   bitmap : tile's drawing (Bitmap)     #   key    : tile's ID     #------------------------------------------------------------------------     def self.save_autotile(bitmap, key)       @cache[key] = bitmap     end     #------------------------------------------------------------------------     # * Return the tile's drawing (Bitmap)     #   key    : tile's ID     #------------------------------------------------------------------------     def self.load_autotile(key)       @cache[key]     end   end end #============================================================================ # ■ RPG::MapInfo #============================================================================ class RPG::MapInfo   # defines the map's name as the name without anything within brackets,   # including brackets   def name     return @name.gsub(/\[.*\]/) {""}   end   #--------------------------------------------------------------------------   # the original name with the codes   def name2     return @name   end end #============================================================================ # ■ Game_Temp #---------------------------------------------------------------------------- # Add attributes to this class / Avoid using too many global variables #============================================================================ class Game_Temp   attr_accessor :pivot # screenline's number of the slant's pivot   attr_accessor :cos_angle # cosinus of the slant's angle   attr_accessor :sin_angle # sinus of the slant's angle   attr_accessor :height_limit # horizon's line   attr_accessor :distance_h # distance between the map's center and the vanishing point   attr_accessor :slope_value # intermediate value   attr_accessor :corrective_value # intermediate value   attr_accessor :height # map's height (in pixel)   #--------------------------------------------------------------------------   # * Object Initialization   #--------------------------------------------------------------------------   alias initialize_mode7_game_temp initialize   def initialize     initialize_mode7_game_temp     self.pivot = 0     self.cos_angle = 0.0     self.sin_angle = 0.0     self.height_limit = 0     self.distance_h = 0     self.slope_value = 0.0     self.corrective_value = 0.0     self.height = 0   end end

#=============================================================== # 本脚本来自www.66rpg.com # 功能：对于没有设置战斗背景的地图，直接用地图做战斗背景 #=============================================================== #============================================================================== # ■ Spriteset_Map #------------------------------------------------------------------------------ # 　处理地图画面活动块和元件的类。本类在 # Scene_Map 类的内部使用。 #============================================================================== class Spriteset_Map #-------------------------------------------------------------------------- # ● 初始化对像 #-------------------------------------------------------------------------- def initialize(flag = false)    # 生成显示端口    @viewport1 = Viewport.new(0, 0, 640, 480)    @viewport2 = Viewport.new(0, 0, 640, 480)    @viewport3 = Viewport.new(0, 0, 640, 480)    @viewport2.z = 200    @viewport3.z = 5000    # 生成元件地图    @tilemap = Tilemap.new(@viewport1)    @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)    for i in 0..6      autotile_name = $game_map.autotile_names      @tilemap.autotiles = RPG::Cache.autotile(autotile_name)    end    @tilemap.map_data = $game_map.data    @tilemap.priorities = $game_map.priorities    # 生成远景平面    @panorama = Plane.new(@viewport1)    @panorama.z = -1000    # 生成雾平面    @fog = Plane.new(@viewport1)    @fog.z = 3000    unless flag      # 生成角色活动块      @character_sprites = []      for i in $game_map.events.keys.sort        sprite = Sprite_Character.new(@viewport1, $game_map.events)        @character_sprites.push(sprite)      end      @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))    end    # 生成天气    @weather = RPG::Weather.new(@viewport1)    # 生成图片    @picture_sprites = []    for i in 1..50      @picture_sprites.push(Sprite_Picture.new(@viewport2,        $game_screen.pictures))    end    # 生成计时器块    @timer_sprite = Sprite_Timer.new    # 刷新画面    update end #-------------------------------------------------------------------------- # ● 释放 #-------------------------------------------------------------------------- def dispose(flag = false)    # 释放元件地图    @tilemap.tileset.dispose    for i in 0..6      @tilemap.autotiles.dispose    end    @tilemap.dispose    # 释放远景平面    @panorama.dispose    # 释放雾平面    @fog.dispose    unless flag      # 释放角色活动块      for sprite in @character_sprites        sprite.dispose      end    end    # 释放天候    @weather.dispose    # 释放图片    for sprite in @picture_sprites      sprite.dispose    end    # 释放计时器块    @timer_sprite.dispose    # 释放显示端口    @viewport1.dispose    @viewport2.dispose    @viewport3.dispose end #-------------------------------------------------------------------------- # ● 刷新画面 #-------------------------------------------------------------------------- def update    # 远景与现在的情况有差异发情况下    if @panorama_name != $game_map.panorama_name or       @panorama_hue != $game_map.panorama_hue      @panorama_name = $game_map.panorama_name      @panorama_hue = $game_map.panorama_hue      if @panorama.bitmap != nil        @panorama.bitmap.dispose        @panorama.bitmap = nil      end      if @panorama_name != ""        @panorama.bitmap = RPG::Cache.panorama(@panorama_name, @panorama_hue)      end      Graphics.frame_reset    end    # 雾与现在的情况有差异的情况下    if @fog_name != $game_map.fog_name or @fog_hue != $game_map.fog_hue      @fog_name = $game_map.fog_name      @fog_hue = $game_map.fog_hue      if @fog.bitmap != nil        @fog.bitmap.dispose        @fog.bitmap = nil      end      if @fog_name != ""        @fog.bitmap = RPG::Cache.fog(@fog_name, @fog_hue)      end      Graphics.frame_reset    end    # 刷新元件地图    @tilemap.ox = $game_map.display_x / 4    @tilemap.oy = $game_map.display_y / 4    @tilemap.update    # 刷新远景平面    @panorama.ox = $game_map.display_x / 8    @panorama.oy = $game_map.display_y / 8    # 刷新雾平面    @fog.zoom_x = $game_map.fog_zoom / 100.0    @fog.zoom_y = $game_map.fog_zoom / 100.0    @fog.opacity = $game_map.fog_opacity    @fog.blend_type = $game_map.fog_blend_type    @fog.ox = $game_map.display_x / 4 + $game_map.fog_ox    @fog.oy = $game_map.display_y / 4 + $game_map.fog_oy    @fog.tone = $game_map.fog_tone    if @character_sprites != nil      # 刷新角色活动块      for sprite in @character_sprites        sprite.update      end    end    # 刷新天候图形    @weather.type = $game_screen.weather_type    @weather.max = $game_screen.weather_max    @weather.ox = $game_map.display_x / 4    @weather.oy = $game_map.display_y / 4    @weather.update    # 刷新图片    for sprite in @picture_sprites      sprite.update    end    # 刷新计时器块    @timer_sprite.update    # 设置画面的色调与震动位置    @viewport1.tone = $game_screen.tone    @viewport1.ox = $game_screen.shake    # 设置画面的闪烁色    @viewport3.color = $game_screen.flash_color    # 刷新显示端口    @viewport1.update    @viewport3.update end end #=============================================================== class Scene_Battle alias battleback_map_main main def main @battleback_sprite = Spriteset_Map.new(true) battleback_map_main @battleback_sprite.dispose(true) end end #=============================================================== # 申请者：张永；脚本作者：bluefool 改进人：亿万星辰  完美化：IKKI #===============================================================

3d.rar (451.14 KB, 下载次数: 5)

2014-2-13 10:52 上传

点击文件名下载附件