想问问一些关于地图截图的问题。

爆焰

请问我在画图时有没有办法截取全部的图片？也就是整张画好的地图截起。
而不是缩小了再截，这样效果不好。请问各位大虾能明白我的意思吗？

orochi2k

bitmap = NEOLITHIC_API::InitializeSuperBigBMP($game_map.width*32,$game_map.height*32)
for x in 0..$game_map.width
for y in 0..$game_map.height
for z in 0..2
   num = $game_map.data[x,y,z]
   if(num < 384)
     bitmap.DrawCurrentAutotile(x*32,y*32,num)
   else
     bitmap.DrawCurrentTile(x*32,y*32,num)
   end
end
end
end
bitmap.OutputAsPNG("weeeeeeeeeeee")

楼下负责翻译成人话

失落的乐章

插入此脚本，运行游戏，按下F6截取主角所在地图的全图

1. 
   
2.     #==============================================================================
   
3.     # ** Map Screenshot
   
4.     #==============================================================================
   
5.     #
   
6.     # - Credits: Cycleby for Bitmap to PNG
   
7.     #            SephirothSpawn for Tilemap
   
8.     #
   
9.     #
   
10.     # To take a screenshot simply be on the map and press F6. The file will be
    
11.     # created in your game directory under the maps name.
    
12.     #
    
13.     #==============================================================================
    
14. 
    
15. 
    
16.     #==============================================================================
    
17.     # ** Spriteset_Map
    
18.     #==============================================================================
    
19.     class Spriteset_Map
    
20.       #--------------------------------------------------------------------------
    
21.       # * Update
    
22.       #--------------------------------------------------------------------------
    
23.       alias :bit_to_png_up :update
    
24.       def update
    
25.         bit_to_png_up
    
26.         if Input.trigger?(Input::F6)
    
27.           map_infos = load_data("Data/MapInfos.rxdata")
    
28.           bit = @tilemap.bitmap
    
29.           exp_time = (bit.height * bit.width) * 0.00000664
    
30.           string = "Taking screenshot please wait.... \n" +
    
31.                   "Number of pixels: #{bit.height * bit.width} \n" +
    
32.                   "Estamated time: #{exp_time} seconds."
    
33.           print("#{string}")
    
34.           old_time = Time.now
    
35.           bit.make_png("#{map_infos[$game_map.map_id].name}")
    
36.           string = "#{map_infos[$game_map.map_id].name}.png was created. \n" +
    
37.                   "File size: width #{bit.width}, height #{bit.height}. \n" +
    
38.                   "Time taken: #{Time.now - old_time} seconds."
    
39.           print("#{string}")
    
40.         end
    
41.       end
    
42.     end
    
43. 
    
44.     #==============================================================================
    
45.     #                        Bitmap to PNG By Cycleby
    
46.     #==============================================================================
    
47.     #
    
48.     # Direct use of the Bitmap object.
    
49.     #    bitmap_obj.make_png(name[, path])
    
50.     #
    
51.     # Name: Save the file name
    
52.     # Path: path to save the
    
53.     #
    
54.     # Thanks 66, Shana, gold Guizi reminder and help!
    
55.     #==============================================================================
    
56.     module Zlib
    
57.       class Png_File < GzipWriter
    
58.         #--------------------------------------------------------------------------
    
59.         # ● Main
    
60.         #--------------------------------------------------------------------------
    
61.         def make_png(bitmap_Fx,mode)
    
62.           @mode = mode
    
63.           @bitmap_Fx = bitmap_Fx
    
64.           self.write(make_header)
    
65.           self.write(make_ihdr)
    
66.           self.write(make_idat)
    
67.           self.write(make_iend)
    
68.         end
    
69.         #--------------------------------------------------------------------------
    
70.         # ● PNG file header block
    
71.         #--------------------------------------------------------------------------
    
72.         def make_header
    
73.           return [0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a].pack("C*")
    
74.         end
    
75.         #--------------------------------------------------------------------------
    
76.         # ● PNG file data block header information (IHDR)
    
77.         #--------------------------------------------------------------------------
    
78.         def make_ihdr
    
79.           ih_size = [13].pack("N")
    
80.           ih_sign = "IHDR"
    
81.           ih_width = [@bitmap_Fx.width].pack("N")
    
82.           ih_height = [@bitmap_Fx.height].pack("N")
    
83.           ih_bit_depth = [8].pack("C")
    
84.           ih_color_type = [6].pack("C")
    
85.           ih_compression_method = [0].pack("C")
    
86.           ih_filter_method = [0].pack("C")
    
87.           ih_interlace_method = [0].pack("C")
    
88.           string = ih_sign + ih_width + ih_height + ih_bit_depth + ih_color_type +
    
89.                   ih_compression_method + ih_filter_method + ih_interlace_method
    
90.           ih_crc = [Zlib.crc32(string)].pack("N")
    
91.           return ih_size + string + ih_crc
    
92.         end
    
93.         #--------------------------------------------------------------------------
    
94.         # ● Generated image data (IDAT)
    
95.         #--------------------------------------------------------------------------
    
96.         def make_idat
    
97.           header = "\x49\x44\x41\x54"
    
98.           case @mode # please 54 ~
    
99.           when 1
    
100.             data = make_bitmap_data # 1
     
101.           else
     
102.             data = make_bitmap_data
     
103.           end
     
104.           data = Zlib::Deflate.deflate(data, 8)
     
105.           crc = [Zlib.crc32(header + data)].pack("N")
     
106.           size = [data.length].pack("N")
     
107.           return size + header + data + crc
     
108.         end
     
109.         #--------------------------------------------------------------------------
     
110.         # ● Requests from the Bitmap object 54 to generate image data in mode 1
     
111.         # (please 54 ~)
     
112.         #--------------------------------------------------------------------------
     
113.         def make_bitmap_data1
     
114.           w = @bitmap_Fx.width
     
115.           h = @bitmap_Fx.height
     
116.           data = []
     
117.           for y in 0...h
     
118.             data.push(0)
     
119.             for x in 0...w
     
120.               color = @bitmap_Fx.get_pixel(x, y)
     
121.               red = color.red
     
122.               green = color.green
     
123.               blue = color.blue
     
124.               alpha = color.alpha
     
125.               data.push(red)
     
126.               data.push(green)
     
127.               data.push(blue)
     
128.               data.push(alpha)
     
129.             end
     
130.           end
     
131.           return data.pack("C*")
     
132.         end
     
133.         #--------------------------------------------------------------------------
     
134.         # ● Bitmap object from the image data generated in mode 0
     
135.         #--------------------------------------------------------------------------
     
136.         def make_bitmap_data
     
137.           gz = Zlib::GzipWriter.open('hoge.gz')
     
138.           t_Fx = 0
     
139.           w = @bitmap_Fx.width
     
140.           h = @bitmap_Fx.height
     
141.           data = []
     
142.           for y in 0...h
     
143.             data.push(0)
     
144.             for x in 0...w
     
145.               t_Fx += 1
     
146.               if t_Fx % 10000 == 0
     
147.                 Graphics.update
     
148.               end
     
149.               if t_Fx % 100000 == 0
     
150.                 s = data.pack("C*")
     
151.                 gz.write(s)
     
152.                 data.clear
     
153.                 #GC.start
     
154.               end
     
155.               color = @bitmap_Fx.get_pixel(x, y)
     
156.               red = color.red
     
157.               green = color.green
     
158.               blue = color.blue
     
159.               alpha = color.alpha
     
160.               data.push(red)
     
161.               data.push(green)
     
162.               data.push(blue)
     
163.               data.push(alpha)
     
164.             end
     
165.           end
     
166.           s = data.pack("C*")
     
167.           gz.write(s)
     
168.           gz.close   
     
169.           data.clear
     
170.           gz = Zlib::GzipReader.open('hoge.gz')
     
171.           data = gz.read
     
172.           gz.close
     
173.           File.delete('hoge.gz')
     
174.           return data
     
175.         end
     
176.         #--------------------------------------------------------------------------
     
177.         # ● PNG end of the file data blocks (IEND)
     
178.         #--------------------------------------------------------------------------
     
179.         def make_iend
     
180.           ie_size = [0].pack("N")
     
181.           ie_sign = "IEND"
     
182.           ie_crc = [Zlib.crc32(ie_sign)].pack("N")
     
183.           return ie_size + ie_sign + ie_crc
     
184.         end
     
185.       end
     
186.     end
     
187.     #==============================================================================
     
188.     # ■ Bitmap
     
189.     #------------------------------------------------------------------------------
     
190.     # Related to the Bitmap.
     
191.     #==============================================================================
     
192.     class Bitmap
     
193.       #--------------------------------------------------------------------------
     
194.       # ● Related
     
195.       #--------------------------------------------------------------------------
     
196.       def make_png(name="like", path="",mode=0)
     
197.         make_dir(path) if path != ""
     
198.         Zlib::Png_File.open("temp.gz") {|gz|
     
199.           gz.make_png(self,mode)
     
200.         }
     
201.         Zlib::GzipReader.open("temp.gz") {|gz|
     
202.           $read = gz.read
     
203.         }
     
204.         f = File.open(path + name + ".png","wb")
     
205.         f.write($read)
     
206.         f.close
     
207.         File.delete('temp.gz')
     
208.         end
     
209.       #--------------------------------------------------------------------------
     
210.       # ● Save the path generated
     
211.       #--------------------------------------------------------------------------
     
212.       def make_dir(path)
     
213.         dir = path.split("/")
     
214.         for i in 0...dir.size
     
215.           unless dir == "."
     
216.             add_dir = dir[0..i].join("/")
     
217.             begin
     
218.               Dir.mkdir(add_dir)
     
219.             rescue
     
220.             end
     
221.           end
     
222.         end
     
223.       end
     
224.     end
     
225. 
     
226.     #==============================================================================
     
227.     # ** Tilemap (Basic)
     
228.     #------------------------------------------------------------------------------
     
229.     # SephirothSpawn
     
230.     # Version 1.0
     
231.     # 2007-05-30
     
232.     # SDK Version 2.2 + : Parts I & II
     
233.     #------------------------------------------------------------------------------
     
234.     # * Credits :
     
235.     #
     
236.     #  Thanks to Trickster for conversion formula for Hexidecimal to rgb.
     
237.     #  Thanks to trebor777 for helping with the priority bug from the 0.9 version.
     
238.     #------------------------------------------------------------------------------
     
239.     # * Description :
     
240.     #
     
241.     #  This script was designed to re-write the default RMXP Hidden Tileset class.
     
242.     #  The script has added many features and a new "Tilemap Settings" class,
     
243.     #  that can be unique if you create mini-maps using this system.
     
244.     #------------------------------------------------------------------------------
     
245.     # * Instructions :
     
246.     #
     
247.     #  Place The Script Below the SDK and Above Main.
     
248.     #------------------------------------------------------------------------------
     
249.     # * Syntax :
     
250.     #
     
251.     #  Get Autotile Tile Bitmap
     
252.     #    - RPG::Cache.autotile_tile(autotile_filename, tile_id[, hue[, frame_id]])
     
253.     #
     
254.     #      autotile_filename : Filename of autotile
     
255.     #      tile_id : ID of tile (Found from RPG::Map.data)
     
256.     #      hue (Optional) : Hue for tile
     
257.     #      frame_id (Optional) : Frame of tile (for animated autotiles)
     
258.     #
     
259.     # * Tilemap Syntax
     
260.     #
     
261.     #  Readable Attributes :
     
262.     #    - layers : Array of Sprites (or Planes)
     
263.     #
     
264.     #  Readable/Writable Attributes :
     
265.     #    - tileset (No long required) : Bitmap for Tileset
     
266.     #    - tileset_name : Name of Bitmap
     
267.     #    - autotiles (No long required) : Array of Autotile Bitmaps
     
268.     #    - autotiles_name : Array of Autotile Filenames
     
269.     #    - map_data : 3D Table of Tile ID Data
     
270.     #    - flash_data : 3D Table of Tile Flash Data
     
271.     #                  (Should match tilemap_settings.flash_data)
     
272.     #    - priorities : 3D Table of Tile Priorities
     
273.     #    - Visible : Tilemap Visible Flag
     
274.     #    - ox, oy : Tilemap layer offsets
     
275.     #    - tilemap_settings : Unique Special Settings Object (See Below)
     
276.     #    - refresh_autotiles : Refresh Autotiles on frame reset flag
     
277.     #
     
278.     # * Special Tilemap Settings
     
279.     #
     
280.     #  To make special settings easier to control for your game map and any other
     
281.     #  special tilemap sprites you wish to create, a special class was created
     
282.     #  to hold these settings. For your game tilemap, a Tilemap_Settings object
     
283.     #  was created in $game_map ($game_map.tilemap_settings). It is advised to
     
284.     #  modify $game_map.tilemap_settings.flash_data instead of tilemap.flash_data.
     
285.     #
     
286.     #  Readable/Writeable Attributes :
     
287.     #    - map : RPG::Map (Not required, but for additions)
     
288.     #    - is_a_plane : Boolean whether layers are Sprites or Planes
     
289.     #    - tone : Tone for all layers
     
290.     #    - hue : Hue for all layers
     
291.     #    - zoom_x, zoom_y : Zoom factor for all layers
     
292.     #    - tilesize : Tilesize displayed on map
     
293.     #    - flash_data : 3D Table of flash_data
     
294.     #==============================================================================
     
295. 
     
296.     #==============================================================================
     
297.     # ** Tilemap_Options
     
298.     #==============================================================================
     
299. 
     
300.     module Tilemap_Options
     
301.       #--------------------------------------------------------------------------
     
302.       # * Tilemap Options
     
303.       #
     
304.       #
     
305.       #  Print Error Reports when not enough information set to tilemap
     
306.       #    - Print_Error_Logs          = true or false
     
307.       #
     
308.       #  Number of autotiles to refresh at edge of viewport
     
309.       #  Number of Frames Before Redrawing Animated Autotiles
     
310.       #    - Animated_Autotiles_Frames = 16
     
311.       #
     
312.       #    - Viewport_Padding          = n
     
313.       #
     
314.       #  When maps are switch, automatically set
     
315.       #  $game_map.tileset_settings.flash_data (Recommended : False unless using
     
316.       #  flash_data)
     
317.       #    - Autoset_Flash_data        = true or false
     
318.       #
     
319.       #  Duration Between Flash Data Flashes
     
320.       #    - Flash_Duration            = n
     
321.       #
     
322.       #  Color of bitmap (Recommended to use low opacity value)
     
323.       #    - Flash_Bitmap_C            = Color.new(255, 255, 255, 50)
     
324.       #
     
325.       #  Update Flashtiles Default Setting
     
326.       #  Explanation : In the Flash Data Addition, because of lag, you may wish
     
327.       #  to toggle whether flash tiles flash or not. This is the default state.
     
328.       #    - Default_Update_Flashtiles = false
     
329.       #--------------------------------------------------------------------------
     
330.       Print_Error_Logs          = true
     
331.       Animated_Autotiles_Frames = 16
     
332.       Autoset_Flash_data        = true
     
333.       Viewport_Padding          = 2
     
334.       Flash_Duration            = 40
     
335.       Flash_Bitmap_C            = Color.new(255, 255, 255, 50)
     
336.       Default_Update_Flashtiles = false
     
337.     end
     
338. 
     
339.     #==============================================================================
     
340.     # ** RPG::Cache
     
341.     #==============================================================================
     
342.     module RPG::Cache
     
343.       #--------------------------------------------------------------------------
     
344.       # * Auto-Tiles
     
345.       #
     
346.       #  Auto-Tile 48 : First Auto-Tile, Constructed of tiles 27, 28, 33, 34
     
347.       #--------------------------------------------------------------------------
     
348.       Autotiles = [
     
349.         [[27, 28, 33, 34], [ 5, 28, 33, 34], [27,  6, 33, 34], [ 5,  6, 33, 34],
     
350.         [27, 28, 33, 12], [ 5, 28, 33, 12], [27,  6, 33, 12], [ 5,  6, 33, 12]],
     
351.         [[27, 28, 11, 34], [ 5, 28, 11, 34], [27,  6, 11, 34], [ 5,  6, 11, 34],
     
352.         [27, 28, 11, 12], [ 5, 28, 11, 12], [27,  6, 11, 12], [ 5,  6, 11, 12]],
     
353.         [[25, 26, 31, 32], [25,  6, 31, 32], [25, 26, 31, 12], [25,  6, 31, 12],
     
354.         [15, 16, 21, 22], [15, 16, 21, 12], [15, 16, 11, 22], [15, 16, 11, 12]],
     
355.         [[29, 30, 35, 36], [29, 30, 11, 36], [ 5, 30, 35, 36], [ 5, 30, 11, 36],
     
356.         [39, 40, 45, 46], [ 5, 40, 45, 46], [39,  6, 45, 46], [ 5,  6, 45, 46]],
     
357.         [[25, 30, 31, 36], [15, 16, 45, 46], [13, 14, 19, 20], [13, 14, 19, 12],
     
358.         [17, 18, 23, 24], [17, 18, 11, 24], [41, 42, 47, 48], [ 5, 42, 47, 48]],
     
359.         [[37, 38, 43, 44], [37,  6, 43, 44], [13, 18, 19, 24], [13, 14, 43, 44],
     
360.         [37, 42, 43, 48], [17, 18, 47, 48], [13, 18, 43, 48], [ 1,  2,  7,  8]]
     
361.       ]
     
362.       #--------------------------------------------------------------------------
     
363.       # * Autotile Cache
     
364.       #
     
365.       #  @autotile_cache = {
     
366.       #    filename => { [autotile_id, frame_id, hue] => bitmap, ... },
     
367.       #    ...
     
368.       #    }
     
369.       #--------------------------------------------------------------------------
     
370.       @autotile_cache = {}
     
371.       #--------------------------------------------------------------------------
     
372.       # * Autotile Tile
     
373.       #--------------------------------------------------------------------------
     
374.       def self.autotile_tile(filename, tile_id, hue = 0, frame_id = nil)
     
375.         # Gets Autotile Bitmap
     
376.         autotile = self.autotile(filename)
     
377.         # Configures Frame ID if not specified
     
378.         if frame_id.nil?
     
379.           # Animated Tiles
     
380.           frames = autotile.width / 96
     
381.           # Configures Animation Offset
     
382.           fc = Graphics.frame_count / Tilemap_Options::Animated_Autotiles_Frames
     
383.           frame_id = (fc) % frames * 96
     
384.         end
     
385.         # Creates list if already not created
     
386.         @autotile_cache[filename] = {} unless @autotile_cache.has_key?(filename)
     
387.         # Gets Key
     
388.         key = [tile_id, frame_id, hue]
     
389.         # If Key Not Found
     
390.         unless @autotile_cache[filename].has_key?(key)
     
391.           # Reconfigure Tile ID
     
392.           tile_id %= 48
     
393.           # Creates Bitmap
     
394.           bitmap = Bitmap.new(32, 32)
     
395.           # Collects Auto-Tile Tile Layout
     
396.           tiles = Autotiles[tile_id / 8][tile_id % 8]
     
397.           # Draws Auto-Tile Rects
     
398.           for i in 0...4
     
399.             tile_position = tiles[i] - 1
     
400.             src_rect = Rect.new(tile_position % 6 * 16 + frame_id,
     
401.               tile_position / 6 * 16, 16, 16)
     
402.             bitmap.blt(i % 2 * 16, i / 2 * 16, autotile, src_rect)
     
403.           end
     
404.           # Saves Autotile to Cache
     
405.           @autotile_cache[filename][key] = bitmap
     
406.           # Change Hue
     
407.           @autotile_cache[filename][key].hue_change(hue)
     
408.         end
     
409.         # Return Autotile
     
410.         return @autotile_cache[filename][key]
     
411.       end
     
412.     end
     
413. 
     
414.     #==============================================================================
     
415.     # ** Spriteset_Map
     
416.     #==============================================================================
     
417.     class Spriteset_Map
     
418.       #--------------------------------------------------------------------------
     
419.       # * Object Initialization
     
420.       #--------------------------------------------------------------------------
     
421.       def initialize
     
422.         # Make viewports
     
423.         @viewport1 = Viewport.new(0, 0, 640, 480)
     
424.         @viewport2 = Viewport.new(0, 0, 640, 480)
     
425.         @viewport3 = Viewport.new(0, 0, 640, 480)
     
426.         @viewport2.z = 200
     
427.         @viewport3.z = 5000
     
428.         # Make tilemap
     
429.         # Make tilemap
     
430.         @tilemap = Tilemap.new(@viewport1)
     
431.         @tilemap.tileset = RPG::Cache.tileset($game_map.tileset_name)
     
432.         for i in 0..6
     
433.           autotile_name = $game_map.autotile_names[i]
     
434.           @tilemap.autotiles[i] = RPG::Cache.autotile(autotile_name)
     
435.         end
     
436.         @tilemap.map_data = $game_map.data.dup
     
437.         @tilemap.priorities = $game_map.priorities
     
438.         # Set Tilemap Settings
     
439.         @tilemap.tileset_name = $game_map.tileset_name
     
440.         for i in 0..6
     
441.           @tilemap.autotiles_name[i] = $game_map.autotile_names[i]
     
442.         end
     
443.         @tilemap.tilemap_settings = $game_map.tilemap_settings
     
444.         # Setup Flash Data
     
445.         @tilemap.flash_data = $game_map.tilemap_settings.flash_data
     
446.         # Run Tilemap Setup
     
447.         @tilemap.setup
     
448.         # Make panorama plane
     
449.         @panorama = Plane.new(@viewport1)
     
450.         @panorama.z = -1000
     
451.         # Make fog plane
     
452.         @fog = Plane.new(@viewport1)
     
453.         @fog.z = 3000
     
454.         # Make character sprites
     
455.         @character_sprites = []
     
456.         for i in $game_map.events.keys.sort
     
457.           sprite = Sprite_Character.new(@viewport1, $game_map.events[i])
     
458.           @character_sprites.push(sprite)
     
459.         end
     
460.         @character_sprites.push(Sprite_Character.new(@viewport1, $game_player))
     
461.         # Make weather
     
462.         @weather = RPG::Weather.new(@viewport1)
     
463.         # Make picture sprites
     
464.         @picture_sprites = []
     
465.         for i in 1..50
     
466.           @picture_sprites.push(Sprite_Picture.new(@viewport2,
     
467.             $game_screen.pictures[i]))
     
468.         end
     
469.         # Make timer sprite
     
470.         @timer_sprite = Sprite_Timer.new
     
471.         # Frame update
     
472.         update
     
473.       end
     
474.     end
     
475. 
     
476.     #==============================================================================
     
477.     # ** Tilemap_Settings
     
478.     #==============================================================================
     
479.     class Tilemap_Settings
     
480.       #--------------------------------------------------------------------------
     
481.       # * Public Instance Variables
     
482.       #--------------------------------------------------------------------------
     
483.       attr_accessor :map
     
484.       attr_accessor :is_a_plane
     
485.       attr_accessor :tone
     
486.       attr_accessor :hue
     
487.       attr_accessor :zoom_x
     
488.       attr_accessor :zoom_y
     
489.       attr_accessor :tile_size
     
490.       attr_accessor :flash_data
     
491.       #--------------------------------------------------------------------------
     
492.       # * Object Initialization
     
493.       #--------------------------------------------------------------------------
     
494.       def initialize(map = nil)
     
495.         # Set Instance Variables
     
496.         @map, @is_a_plane, @tone, @hue, @zoom_x, @zoom_y, @tile_size,
     
497.           @flash_data = map, false, nil, 0, 1.0, 1.0, 32, nil
     
498.       end
     
499.     end
     
500. 
     
501.     #==============================================================================
     
502.     # ** Game_Map
     
503.     #==============================================================================
     
504.     class Game_Map
     
505.       #--------------------------------------------------------------------------
     
506.       # * Public Instance Variables
     
507.       #--------------------------------------------------------------------------
     
508.       attr_accessor :tilemap_settings
     
509.       #--------------------------------------------------------------------------
     
510.       # * Alias Listings
     
511.       #--------------------------------------------------------------------------
     
512.       alias_method :seph_tilemap_gmap_init, :initialize
     
513.       #--------------------------------------------------------------------------
     
514.       # * Object Initialization
     
515.       #--------------------------------------------------------------------------
     
516.       def initialize
     
517.         # Original Initialization
     
518.         seph_tilemap_gmap_init
     
519.         # Create Tilemap Settings
     
520.         @tilemap_settings = Tilemap_Settings.new
     
521.       end
     
522.       #--------------------------------------------------------------------------
     
523.       # * Load Map Data
     
524.       #--------------------------------------------------------------------------
     
525.       def setup_load
     
526.         # Reset Tilemap Flash Data
     
527.         if Tilemap_Options::Autoset_Flash_data
     
528.           @tilemap_settings.flash_data = Table.new(@map.width, @map.height)
     
529.         end
     
530.         @tilemap_settings.map = @map
     
531.       end
     
532.     end
     
533. 
     
534.     #==============================================================================
     
535.     # ** Tilemap
     
536.     #==============================================================================
     
537.     class Tilemap
     
538.       #--------------------------------------------------------------------------
     
539.       # * Public Instance Variables
     
540.       #--------------------------------------------------------------------------
     
541.       attr_reader  :layers
     
542.       attr_accessor :tileset
     
543.       attr_accessor :tileset_name
     
544.       attr_accessor :autotiles
     
545.       attr_accessor :autotiles_name
     
546.       attr_accessor :map_data
     
547.       attr_accessor :flash_data
     
548.       attr_accessor :priorities
     
549.       attr_accessor :visible
     
550.       attr_accessor :ox
     
551.       attr_accessor :oy
     
552.       attr_accessor :tilemap_settings
     
553.       attr_accessor :refresh_autotiles
     
554.       #--------------------------------------------------------------------------
     
555.       # * Object Initialization
     
556.       #--------------------------------------------------------------------------
     
557.       def initialize(viewport)
     
558.         # Saves Viewport
     
559.         @viewport = viewport
     
560.         # Creates Blank Instance Variables
     
561.         @layers            = []    # Refers to Array of Sprites or Planes
     
562.         @tileset          = nil  # Refers to Tileset Bitmap
     
563.         @tileset_name      = ''    # Refers to Tileset Filename
     
564.         @autotiles        = []    # Refers to Array of Autotile Bitmaps
     
565.         @autotiles_name    = []    # Refers to Array of Autotile Filenames
     
566.         @map_data          = nil  # Refers to 3D Array Of Tile Settings
     
567.         @flash_data        = nil  # Refers to 3D Array of Tile Flashdata
     
568.         @priorities        = nil  # Refers to Tileset Priorities
     
569.         @visible          = true  # Refers to Tilest Visibleness
     
570.         @ox                = 0    # Bitmap Offsets         
     
571.         @oy                = 0    # Bitmap Offsets
     
572.         @tilemap_settings  = nil  # Special Tilemap Settings
     
573.         @dispose          = false # Disposed Flag
     
574.         @refresh_autotiles = true  # Refresh Autotile Flag
     
575.       end
     
576.       #--------------------------------------------------------------------------
     
577.       # * Setup
     
578.       #--------------------------------------------------------------------------
     
579.       def setup
     
580.         # Print Error if Tilemap Settings not Found
     
581.         if Tilemap_Options::Print_Error_Logs
     
582.           if @tilemap_settings.nil?
     
583.             p 'Tilemap Settings have not been set. System will not crash.'
     
584.           end
     
585.           if @map_data.nil?
     
586.             p 'Map Data has not been set. System will crash.'
     
587.           end
     
588.         end
     
589.         # Creates Layers
     
590.         @layers = []
     
591.         for l in 0...3
     
592.           layer = @tilemap_settings.nil? || !@tilemap_settings.is_a_plane ?
     
593.             Sprite.new(@viewport) : Plane.new(@viewport)
     
594.           layer.bitmap = Bitmap.new(@map_data.xsize * 32, @map_data.ysize * 32)
     
595.           layer.z = l * 150
     
596.           layer.zoom_x = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_x
     
597.           layer.zoom_y = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_y
     
598.           unless @tilemap_settings.nil? || @tilemap_settings.tone.nil?
     
599.             layer.tone = @tilemap_settings.tone
     
600.           end
     
601.           @layers << layer
     
602.         end
     
603.         # Update Flags
     
604.         @refresh_data = nil
     
605.         @zoom_x  = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_x
     
606.         @zoom_y  = @tilemap_settings.nil? ? 1.0 : @tilemap_settings.zoom_y
     
607.         @tone    = @tilemap_settings.nil? ? nil : @tilemap_settings.tone
     
608.         @hue      = @tilemap_settings.nil? ? 0  : @tilemap_settings.hue
     
609.         @tilesize = @tilemap_settings.nil? ? 32  : @tilemap_settings.tile_size
     
610.       end
     
611.       #--------------------------------------------------------------------------
     
612.       # * Dispose
     
613.       #--------------------------------------------------------------------------
     
614.       def dispose
     
615.         # Dispose Layers (Sprites)
     
616.         @layers.each { |layer| layer.dispose }
     
617.         # Set Disposed Flag to True
     
618.         @disposed = true
     
619.       end
     
620.       #--------------------------------------------------------------------------
     
621.       # * Disposed?
     
622.       #--------------------------------------------------------------------------
     
623.       def disposed?
     
624.         return @disposed
     
625.       end
     
626.       #--------------------------------------------------------------------------
     
627.       # * Viewport
     
628.       #--------------------------------------------------------------------------
     
629.       def viewport
     
630.         return @viewport
     
631.       end
     
632.       #--------------------------------------------------------------------------
     
633.       # * Frame Update
     
634.       #--------------------------------------------------------------------------
     
635.       def update
     
636.         # Set Refreshed Flag to On
     
637.         needs_refresh = true
     
638.         # If Map Data, Tilesize or HueChanges
     
639.         if @map_data != @refresh_data || (@tilemap_settings != false &&
     
640.           @hue != @tilemap_settings.hue) || (@tilemap_settings != false &&
     
641.           @tilesize != @tilemap_settings.tile_size)
     
642.           # Refresh Bitmaps
     
643.           refresh
     
644.           # Turns Refresh Flag to OFF
     
645.           needs_refresh = false
     
646.         end
     
647.         # Zoom X, Zoom Y, and Tone Changes
     
648.         unless @tilemap_settings.nil?
     
649.           if @zoom_x != @tilemap_settings.zoom_x
     
650.             @zoom_x = @tilemap_settings.zoom_x
     
651.             @layers.each {|layer| layer.zoom_x = @zoom_x}
     
652.           end
     
653.           if @zoom_y != @tilemap_settings.zoom_y
     
654.             @zoom_y = @tilemap_settings.zoom_y
     
655.             @layers.each {|layer| layer.zoom_y = @zoom_y}
     
656.           end
     
657.           if @tone != @tilemap_settings.tone
     
658.             @tone = @tilemap_settings.tone.nil? ?
     
659.               Tone.new(0, 0, 0, 0) : @tilemap_settings.tone
     
660.             @layers.each {|layer| layer.tone = @tone}
     
661.           end
     
662.         end
     
663.         # Update layer Position offsets
     
664.         for layer in @layers
     
665.           layer.ox = @ox
     
666.           layer.oy = @oy
     
667.         end
     
668.         # If Refresh Autotiles, Needs Refreshed & Autotile Reset Frame
     
669.         if @refresh_autotiles && needs_refresh &&
     
670.           Graphics.frame_count % Tilemap_Options::Animated_Autotiles_Frames == 0
     
671.           # Refresh Autotiles
     
672.           refresh_autotiles
     
673.         end
     
674.       end
     
675.       #--------------------------------------------------------------------------
     
676.       # * Refresh
     
677.       #--------------------------------------------------------------------------
     
678.       def refresh
     
679.         # Saves Map Data & Tilesize
     
680.         @refresh_data = @map_data
     
681.         @hue      = @tilemap_settings.nil? ? 0  : @tilemap_settings.hue
     
682.         @tilesize = @tilemap_settings.nil? ? 32 : @tilemap_settings.tile_size
     
683.         # Passes Through Layers
     
684.         for z in 0...@map_data.zsize
     
685.           # Passes Through X Coordinates
     
686.           for x in 0...@map_data.xsize
     
687.             # Passes Through Z Coordinates
     
688.             for y in 0...@map_data.ysize
     
689.               # Collects Tile ID
     
690.               id = @map_data[x, y, z]
     
691.               # Skip if 0 tile
     
692.               next if id == 0
     
693.               # Passes Through All Priorities
     
694.               for p in 0..5
     
695.                 # Skip If Priority Doesn't Match
     
696.                 next unless p == @priorities[id]
     
697.                 # Cap Priority to Layer 3
     
698.                 p = 2 if p > 2
     
699.                 # Draw Tile
     
700.                 id < 384 ? draw_autotile(x, y, p, id) : draw_tile(x, y, p, id)
     
701.               end
     
702.             end
     
703.           end
     
704.         end
     
705.       end   
     
706.       #--------------------------------------------------------------------------
     
707.       # * Refresh Auto-Tiles
     
708.       #--------------------------------------------------------------------------
     
709.       def refresh_autotiles
     
710.         # Auto-Tile Locations
     
711.         autotile_locations = Table.new(@map_data.xsize, @map_data.ysize,
     
712.           @map_data.zsize)
     
713.         # Get X Tiles
     
714.         x1 = [@ox / @tilesize - Tilemap_Options::Viewport_Padding, 0].max.round
     
715.         x2 = [@viewport.rect.width / @tilesize +
     
716.               Tilemap_Options::Viewport_Padding, @map_data.xsize].min.round
     
717.         # Get Y Tiles
     
718.         y1 = [@oy / @tilesize - Tilemap_Options::Viewport_Padding, 0].max.round
     
719.         y2 = [@viewport.rect.height / @tilesize +
     
720.               Tilemap_Options::Viewport_Padding, @map_data.ysize].min.round
     
721.         # Passes Through Layers
     
722.         for z in 0...@map_data.zsize
     
723.           # Passes Through X Coordinates
     
724.           for x in x1...x2
     
725.             # Passes Through Y Coordinates
     
726.             for y in y1...y2
     
727.               # Collects Tile ID
     
728.               id = @map_data[x, y, z]
     
729.               # Skip if 0 tile
     
730.               next if id == 0
     
731.               # Skip If Non-Animated Tile
     
732.               next unless @autotiles[id / 48 - 1].width / 96 > 1 if id < 384
     
733.               # Passes Through All Priorities
     
734.               for p in 0..5
     
735.                 # Skip If Priority Doesn't Match
     
736.                 next unless p == @priorities[id]
     
737.                 # Cap Priority to Layer 3
     
738.                 p = 2 if p > 2
     
739.                 # If Autotile
     
740.                 if id < 384
     
741.                   # Draw Auto-Tile
     
742.                   draw_autotile(x, y, p, id)
     
743.                   # Draw Higher Tiles
     
744.                   for l in 0...@map_data.zsize
     
745.                     id_l = @map_data[x, y, l]
     
746.                     draw_tile(x, y, p, id_l)
     
747.                   end
     
748.                   # Save Autotile Location
     
749.                   autotile_locations[x, y, z] = 1
     
750.                 # If Normal Tile
     
751.                 else
     
752.                   # If Autotile Drawn
     
753.                   if autotile_locations[x, y, z] == 1
     
754.                     # Redraw Normal Tile
     
755.                     draw_tile(x, y, p, id)
     
756.                     # Draw Higher Tiles
     
757.                     for l in 0...@map_data.zsize
     
758.                       id_l = @map_data[x, y, l]
     
759.                       draw_tile(x, y, p, id_l)
     
760.                     end
     
761.                   end
     
762.                 end
     
763.               end
     
764.             end
     
765.           end
     
766.         end
     
767.       end     
     
768.       #--------------------------------------------------------------------------
     
769.       # * Draw Tile
     
770.       #--------------------------------------------------------------------------
     
771.       def draw_tile(x, y, z, id)
     
772.         # Gets Tile Bitmap
     
773.         bitmap = RPG::Cache.tile(@tileset_name, id, @hue)
     
774.         # Calculates Tile Coordinates
     
775.         x *= @tilesize
     
776.         y *= @tilesize
     
777.         # Draw Tile
     
778.         if @tilesize == 32
     
779.           @layers[z].bitmap.blt(x, y, bitmap, Rect.new(0, 0, 32, 32))
     
780.         else
     
781.           rect = Rect.new(x, y, @tilesize, @tilesize)
     
782.           @layers[z].bitmap.stretch_blt(rect, bitmap, Rect.new(0, 0, 32, 32))
     
783.         end
     
784.       end
     
785.       #--------------------------------------------------------------------------
     
786.       # * Draw Auto-Tile
     
787.       #--------------------------------------------------------------------------
     
788.       def draw_autotile(x, y, z, tile_id)
     
789.         # Gets Autotile Filename
     
790.         filename = @autotiles_name[tile_id / 48 - 1]
     
791.         # Reconfigure Tile ID
     
792.         tile_id %= 48
     
793.         # Gets Generated Autotile Bitmap Section
     
794.         bitmap = RPG::Cache.autotile_tile(filename, tile_id, @hue)
     
795.         # Calculates Tile Coordinates
     
796.         x *= @tilesize
     
797.         y *= @tilesize
     
798.         # If Normal Tile
     
799.         if @tilesize == 32
     
800.           @layers[z].bitmap.blt(x, y, bitmap, Rect.new(0, 0, 32, 32))
     
801.         # If Altered Dimensions
     
802.         else
     
803.           dest_rect = Rect.new(x, y, @tilesize, @tilesize)
     
804.           @layers[z].bitmap.stretch_blt(dest_rect, bitmap, Rect.new(0, 0, 32, 32))
     
805.         end
     
806.       end
     
807.       #--------------------------------------------------------------------------
     
808.       # * Collect Bitmap
     
809.       #--------------------------------------------------------------------------
     
810.       def bitmap
     
811.         # Creates New Blank Bitmap
     
812.         bitmap = Bitmap.new(@layers[0].bitmap.width, @layers[0].bitmap.height)
     
813.         # Passes Through All Layers
     
814.         for layer in @layers
     
815.           bitmap.blt(0, 0, layer.bitmap,
     
816.             Rect.new(0, 0, bitmap.width, bitmap.height))
     
817.         end
     
818.         # Return Bitmap
     
819.         return bitmap
     
820.       end
     
821.     end
     

复制代码