Урок по созданию безграничного пространства

#============================================================================ # ** Tilemap Enchance v.0.75 (RGSS3 Version) #============================================================================ # # Dieses Script ersetzt die Standard Tilemap-Klasse komplett und ermöglicht # Zugriff auf die einzelnen Layer, bietet aber auch einige spezielle Features. # Das Script funktioniert grundsätzlich einwandfrei, anders als die meisten # Tilemap-Rewrites. # # 1. Benutzung # # Fügt das Script über main und unter den Standardscripten ein. # # Falls ihr den RGSS3-Player für den XP verwendet, sucht nach "RGSS3", kommentiert # die 3 Zeilen aus (# entfernen) und fügt ein "#" vor die jeweils darüberliegende # Zeile. # # 2. Funktionsweise # # Das Script lädt beim Betreten einer Map statt der Klasse Tilemap die neue Klasse # Tilemap_New. Es wird für jede Zeile der Map, als in Y-Richtung von 0 bis # zum unteren Ende der Map, ein Sprite mit Bitmap erstellt. Dabei wird noch # zwischen den einzelnen Priorty-Settings und Tiles/Autotiles unterschieden. # Die Tiles werden also im vorhinein geladen und nicht während dem Spiel # neu gezeichnet. Das verbraucht eine Menge RAM und erhöht die Ladezeit pro Map # etwas, erhöht aber gleichzeitig die Performance! # # 3. Nutzen # # Man kann jetzt aktiv in den Darstellungsprozess der Tiles eingreifen, bzw. # die Tile-Grafiken selber manipulieren. Drei eingebaute Features sind : # Blend-Types für Autotiles (zu Normal kommt noch Add und Sub dazu; nützlich z.B # für bestimmte Wasser/Licht-Effekte), variable Animationsgeschwindigkeit # für Autotiles sowie ein Color-Tone für die Tilemap alleine. Andere # Verwendungszwecke wären z.B. für ein Screen-Size-Script. Meine Tilemap-Klasse # eignet sich dafür besonders, da die Performance mit zunehmender # Bildgröße nur geringfügig abnehmen würde,wenn überhaupt. # # 4. Verwendung # # Das Script wird automatisch nach Einbau verwendet, jedoch muss man die # besonderen Features extra aktivieren: # # - Autotile blend_type/speed: # Wird über das module Autotile direkt unter der # Einleitung konfiguriert. Mögliche Werte für blend_type sind 0 (Normal), # 1 (Add), 2 (Sub), für speed kann jede Ganzzahl verwendet werden. Kleinere # Zahlen bedeuten schnellere Animation (0 = jedes Frame). # Konfiguriert wird: MAP_ID=>{AUTOTILE_ID=>BLEND_TYPE/BLEND_SPEED} im jeweiligen # Abschnitt BLEND_TYPE bzw. SPEED, Beispiele vorhanden. ID geht von 0 bis 6 # (links nach rechts im Tileset) # # DEFAULT_SPEED ist die Geschwindgkeit die verwendet wird, wenn in SPEED für # eine Map oder ein Autotile keine Angabe gemacht wurde. # # - Tilemap-Tone: # Kann per Callscript oder in einem Script selbst mit dem Befehl # # $game_map.start_tone_change(Tone,Dauer) # # aufgerufen werden, wobei Tone = Tone.new(r,g,b,gr). Dieser Tone wirkt sich # dann nur auf die Tiles und Autotiles aus, der Screen-Color-Tone kann immer # noch über alles gelegt werden. # # 5. Beschränkungen # # - Nachträgliche Änderung von Tile-Daten im Script hat in der jetzigen Version # noch keine Auswirkungen (z.B. über $game_map.data) # # - Höherer RAM-Verbrauch. Je nach Größe der Map und Verwendung von Autotiles # kann der RAM-Verbrauch an die 800 Mb betragen. (200*200 Map mit 1 Layer voll # normalen Tiles und 1 Layer voll 4 Frames Autotile) # Realistischer Verbrauch liegt bei max. 500 MB, 512 MB RAM sollten bei Maps größer # als 100*100 vorhanden sein! # # - Längere Ladezeit. Abhängig von der Map-Größe und Verwendung von Autotiles # pendelt die Ladezeit zwischen 0 und 6 Sekunden. Kleine Maps (30*30) Instant- # Load, 60*60 mit Autotiles ca. 1 Sekunde, 100*100 mit Autotiles 2 Sekunden, # 200*200 Map mit 1 Layer voll normaler Tiles und 1 Layer voll animierter # Autotiles 6 Sekunden # # - Ein Teleport auf derselben Map führt zu einem Grafikfehler. # # 6. Vorteile # # - Voller Zugriff auf die Sprites der Map # - Autotile-Blend_types und variable Geschwindigkeit # - höhere Performance zu Lasten von RAM # - Volle Funktionalität (Ausnahme siehe Beschränkungen) gegeben # - Lag skaliert nicht mit Fenster-Größe (Verwendung für Screen-Script+) # # # 7. Credits # # Credits an GodLike für die RPG::Cache-Erweiterung # Verwendung/Modifizierung steht frei, bei Nutzung jedoch bitte Credit-Vergabe. # # 8. Changelog # # V 0.75: # # - Kompatibilität mit dem RGSS3-Mod für den XP # - Ladgeschwindigkeit leicht verbessert # - Allgemeine Performance verbessert # - Kleine Darstellungsfehler bei bestimmten Autotile-Kombinationen behoben # # 9. Kontakt # # Bei Fragen, Anregungen, Bugmeldungen, bitt eine E-Mail an admin@envile-media.at # # #============================================================================ #============================================================================== # ** Module Autotile #------------------------------------------------------------------------------ # # Mit diesem Modul werden die Autotile-Eigenschaften konfiguriert. # #============================================================================== module AUTOTILE #MAP_ID=>{AUTOTILE_ID=>BLEND_TYPE,..} BLEND_TYPE = { 4=>{5=>1,6=>2}, } #MAP_ID=>{AUTOTILE_ID=>SPEED,..} SPEED = { 4=>{4=>2}, } #DEFAULT_SPEED DEFAULT_SPEED = 4 end #============================================================================== # ** Sprite_Auto NEW #------------------------------------------------------------------------------ # # Die Klasse zum Verwalten der Autotile-Layer. Jeder Layer enthält mehrere # Sprites, eines für jede Autotile-Spalte. Erzeugt auch die jeweiligen Bitmaps # für den Layer. # #============================================================================== class Sprite_Auto attr_reader :cache2 #-------------------------------------------------------------------------- # * Initialize (Tiles auslesen, Sprites & Bitmaps erzeugen) #-------------------------------------------------------------------------- def initialize(viewport,tiles,speed,autotile_frames,priority,blend_type) # Store autotile data @tiles = tiles @tileset_id = $game_map.map.tileset_id @tileset = RPG::Cache.tileset($game_map.tileset_name) @speed = speed @priority = priority @autotile_frames = autotile_frames @frames = autotile_frames[tiles[0]] @priorities = $game_map.priorities @blend_type = blend_type @viewport = viewport # Animation variables @time = 0 @state = -1 # Get number of tiles on x/y axis @width = $game_map.width @height = $game_map.height # Set layer border variables to l<->r and u<->d (changed max/min values) @border_lx = @width @border_ty = @height @border_rx = 0 @border_by = 0 # Set row borders @border_lx_row = @width @border_rx_row = 0 # Create table for row borders @rows = Table.new(@height,2) # Hash for sprites & cache @sprites = {} @cache = {} @cache2 = {} # If special blend_type if @blend_type != 0 # Setup tiles accordingly setup_tiles_blend # Else: normal blendig else # Setup tiles setup_tiles end # Return if not valid return if !valid? # Otherwise, create sprites & bitmaps create_sprites # If special blend_type if @blend_type != 0 # Draw blended tiles draw_tiles_blend else # Draw tiles draw_tiles end @tileset = nil end #-------------------------------------------------------------------------- # * Valid? (Überprüft ob in Tiles für diesen Layer gefunden wurden) #-------------------------------------------------------------------------- def valid? # If right border greater or equal to left border and # top border greater or equal to bottom border then true return @border_rx >= @border_lx && @border_by >= @border_ty end #-------------------------------------------------------------------------- # * Row_valid? (Überprüft ob in Tiles in Spalte Y gefunden wurden) #-------------------------------------------------------------------------- def row_valid?(y) # If right border of row equal or greater to left border of row # then true return @rows[y,1] > @rows[y,0] end #-------------------------------------------------------------------------- # * Setup_tiles_blend (Liest Tiles für diesen Layer aus und bestimmt die # Grenzen. Verwendet spezielle Regeln beim auslesen) #-------------------------------------------------------------------------- def setup_tiles_blend # Get pre-sorted tile data with priority of the layer @data_link = $game_map.priority_data(@priority) # Clone hashs, needed for functionally interation while deleting stuff # from the data @data = @data_link.dup @data_link.each_pair do |dx,data_x| dat_x = @data[dx] dat_x = data_x.dup data_x.each_pair do |dz,data_z| dat_x[dz] = data_z.dup end end tiles_found = false layer = 0 # Iterate through sorted tiles on y-axis @data.each_pair do |y,data_y| # Iterate through sorted tiles on x-axis data_y.each_pair do |x,data_x| # Iterate through map editor layers downwards data_x.each_pair do |z,t| # Get Tile ID # Skip to next if there no tile next if t == nil # If tile fits properties of layer, only true if t is a autotile if @tiles.include?(t/48-1) # Add tile id to cache @cache[y] = {} if @cache[y] == nil @cache[y][x] = {} if @cache[y][x] == nil @cache[y][x][z] = t # Extend borders border(x,y) # Delete from map data list @data_link[y][x].delete(z) @data_link[y].delete(x) if @data_link[y][x].size == 0 @data_link.delete(y) if @data_link[y].size == 0 tiles_found = true layer = z end end if tiles_found == true if layer == 0 for z in [1,2] t = data_x[z] next if t == nil || t < 384 || @priorities[t] != @priority @cache2[y] = {} if @cache2[y] == nil @cache2[y][x] = {} if @cache2[y][x] == nil @cache2[y][x][z] = t @data_link[y][x].delete(z) @data_link[y].delete(x) if @data_link[y][x].size == 0 @data_link.delete(y) if @data_link[y].size == 0 end elsif layer == 1 t = data_x[2] next if t == nil || t < 384 || @priorities[t] != @priority @cache2[y] = {} if @cache2[y] == nil @cache2[y][x] = {} if @cache2[y][x] == nil @cache2[y][x][z] = t @data_link[y][x].delete(z) @data_link[y].delete(x) if @data_link[y][x].size == 0 @data_link.delete(y) if @data_link[y].size == 0 end end end # Set row borders @rows[y,0] = @border_lx_row @rows[y,1] = @border_rx_row # Re-Initialize row border temporaries for next iteraton @border_lx_row = @width/32 @border_rx_row = 0 end end #-------------------------------------------------------------------------- # * Setup_tiles (Liest Tiles für diesen Layer aus und bestimmt die # Grenzen. Verwendet spezielle Regeln beim auslesen) #-------------------------------------------------------------------------- def setup_tiles # Get pre-sorted tile data with priority of the layer @data_link = $game_map.priority_data(@priority) # Clone hashs, needed for functionally interation while deleting stuff # from the data @data = @data_link.dup @data_link.each_pair do |dx,data_x| dat_x = @data[dx] dat_x = data_x.dup data_x.each_pair do |dz,data_z| dat_x[dz] = data_z.dup end end # Iterate through sorted tiles on y-axis @data.each_pair do |y,data_y| # Iterate through sorted tiles on x-axis data_y.each_pair do |x,data_x| # Initialize autotile found flag to false autotile_found = false # Iterate through map editor layers downwards data_x.each_pair do |z,t| # Iterate through map editor layers # Get tile id # Store whether tile fits layer properties or not # only true if t is a autotile tiles_include = @tiles.include?(t/48-1) # If tile is included or tile is from tileset or tile is autotile # with 1 frame if tiles_include || (t >= 384 || @autotile_frames[t/48-1] <= 1) # Store in cache @cache[y] = {} if @cache[y] == nil @cache[y][x] = {} if @cache[y][x] == nil @cache[y][x][z] = t # If tile is a autotile and is included if t < 384 && tiles_include # Delete from map data list @data_link[y][x].delete(z) @data_link[y].delete(x) if @data_link[y][x].size == 0 @data_link.delete(y) if @data_link[y].size == 0 # Extend borders border(x,y) # Set autotile found flag to true autotile_found = true end end end # If no autotile was found & row at y is not empty and x-position is not empty if autotile_found == false && @cache[y] != nil && @cache[y][x] != nil # Delete all tiles on x-position from cache @cache[y].delete(x) @cache.delete(y) if @data_link[y].size == 0 end end # Set row borders @rows[y,0] = @border_lx_row @rows[y,1] = @border_rx_row # Re-Initialize row border temporaries for next iteration @border_lx_row = @width/32 @border_rx_row = 0 end end #-------------------------------------------------------------------------- # * Create_Sprites (Erzeugt Sprites & Bitmaps für jeden Zeile) #-------------------------------------------------------------------------- def create_sprites # Iterate through tiles on y-axis for y in @cache.keys # If row is not valid if !row_valid?(y) # skip to next next end # Calculate row width distx = @rows[y,1] - @rows[y,0] # Create sprite sprite = Sprite.new(@viewport) # Create bitmap with row-width*count of frames sprite.bitmap = Bitmap.new(distx*32*@frames,32) sprite.x = @rows[y,0]*32-$game_map.display_x/4 sprite.y = y*32-$game_map.display_y/4 # Set source rect to frame 0 sprite.src_rect = Rect.new(0,0,distx*32,32) sprite.blend_type = @blend_type # If priority equals 0 if @priority == 0 # Set z to 0, always beyond later created layers sprite.z = 0 else # Set z to base + priority + dosition - display-Position sprite.z = 32 + 32*@priority + 32*y - $game_map.display_y/4 end # Add sprite to hash @sprites[y] = sprite end end #-------------------------------------------------------------------------- # * Border (Erweitert die Grenzen des Layers und der aktuellen Zeile #-------------------------------------------------------------------------- def border(x,y) # If X is outside left border if x < @border_lx # Extend left border to x @border_lx = x end # If X is outside right border if x > @border_rx # Extend right border to x+1 @border_rx = x+1 end # If Y is outside top border if y < @border_ty # Extend top border to y @border_ty = y end # If Y is outside bottom border if y > @border_by # Extend bottom_border to y @border_by = y end # If X is outside left row border if x < @border_lx_row # Extend left row border to x @border_lx_row = x end # If X is outside right row border if x+1 > @border_rx_row # Extend right row border to y @border_rx_row = x+1 end end #-------------------------------------------------------------------------- # * Update (Aktualisiert die Position der Zeilen im Bild sowie die # Animation) #-------------------------------------------------------------------------- def update(ox,oy) # Get first and last row 1 outside screen dy = oy/32.0 l = [dy.to_i-1,@border_ty].max r = [dy.to_i+17,@border_by].min # If time exceedes speed if @time > @speed # Reinit time, advance state @time = 0 @state += 1 # Iterate through every row on screen for i in l..r # Skip to next If row has no sprite sprite = @sprites[i] next if sprite == nil # Set sprite properties sprite.tone = $game_map.tone# if @blend_type == 0 sprite.x = @rows[i,0]*32-ox sprite.y = i*32-oy # If priority equals 0 if @priority == 0 # Set Z to 0, always beyond later created tiles sprite.z = 0 else # Set Z to Base + Priority + Position - Tilemap position sprite.z = 32 + 32*@priority + i*32 - oy end # Get row width lx = @rows[i,0] w = @rows[i,1] - lx # Set animation frame sprite.src_rect = Rect.new(@state*w*32,0,w*32,32) end # If state exceeded frame count if @state >= @frames-1 # Reset state @state = -1 end # Else: just update position else # Iterate through every row on screen for i in l..r # Skip to next if row has no sprite sprite = @sprites[i] next if sprite == nil # Set sprite properties sprite.tone = $game_map.tone# if @blend_type == 0 sprite.x = @rows[i,0]*32-ox sprite.y = i*32-oy # If priority equals 0 if @priority == 0 # Set Z to 0, always beyond later created tiles sprite.z = 0 else # Set Z to Base + Priority + Position - Tilemap position sprite.z = 32 + 32*@priority + i*32 - oy end end end # Advance time @time += 1 end #-------------------------------------------------------------------------- # * Refresh (Erneuert die Eigenschaften aller Reihen) #-------------------------------------------------------------------------- def refresh # Iterate through all sprites for y in @cache.keys # Skip if sprite doesn't exist sprite = @sprites[y] next if sprite == nil sprite.tone = $game_map.tone # If priority equals 0 sprite.x = @rows[y,0]*32-$game_map.display_x/4 sprite.y = y*32-$game_map.display_y/4 if @priority == 0 # Set z to 0, always beyond sprite.z = 0 else # Set Z to Base + Priority + Position - Screen Position sprite.z = 32+32*@priority+y*32-$game_map.display_y/4 end end end #-------------------------------------------------------------------------- # * Draw_tiles_blend (Zeichnet den kompletten Layer in die einzelnen Zeilen. # Wendet spezielle Regeln für 1/2-Blended Autotiles an.) #-------------------------------------------------------------------------- def draw_tiles_blend # Iterate through cached tiles on y axis @cache.each_pair do |y,cache_y| sprite = @sprites[y] next if cache_y == nil lx = @rows[y,0] w = @rows[y,1]-lx cache_y.each_pair do |x,cache_x| cache_x.values.each do |t| #cache_x.values.reverse.each do |t| #RGSS3 file = (t / 48) - 1 a = t - (file+1)*48 for f in 0...@frames autotile = RPG::Cache.atile($game_map.autotile_names[file],a,f) sprite.bitmap.blt(-lx*32+x*32+f*w*32,0,autotile,autotile.rect) end end end end RPG::Cache.clear_auto end def draw_tiles @cache.each_pair do |y,cache_y| sprite = @sprites[y] lx = @rows[y,0] w = @rows[y,1]-lx cache_y.each_pair do |x,cache_x| cache_x.keys.each do |z| #cache_x.keys.reverse.each do |z| #RGSS3 t = cache_x[z] if t < 384 file = (t / 48) - 1 a = t - (file+1)*48 for f in 0...@frames autotile = RPG::Cache.atile($game_map.autotile_names[file],a,f) sprite.bitmap.blt(-lx*32+x*32+f*w*32,0,autotile,autotile.rect) end if @autotile_frames[file] <= 1 @data_link[y][x].delete(z) @data_link[y].delete(x) if @data_link[y][x].size == 0 @data_link.delete(y) if @data_link[y].size == 0 end else t -=384 xt = t%8 yt = t/8 r = Rect.new(xt*32,yt*32,32,32) for f in 0...@frames sprite.bitmap.blt(-lx*32+x*32+f*w*32,0,@tileset,r) end @data_link[y][x].delete(z) @data_link[y].delete(x) if @data_link[y][x].size == 0 @data_link.delete(y) if @data_link[y].size == 0 end end end end RPG::Cache.clear_auto end def dispose for sprite in @sprites.values sprite.dispose end end end module RPG module Cache @auto_cache = {} [[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]] AUTOTILES = [26, 27, 32, 33, 4, 27, 32, 33, # 1 26, 5, 32, 33, 4, 5, 32, 33, # 3 26, 27, 32, 11, 4, 27, 32, 11, # 5 26, 5, 32, 11, 4, 5, 32, 11, # 7 26, 27, 10, 33, 4, 27, 10, 33, # 9 26, 5, 10, 33, 4, 5, 10, 33, # 11 26, 27, 10, 11, 4, 27, 10, 11, # 13 26, 5, 10, 11, 4, 5, 10, 11, # 15 24, 25, 30, 31, 24, 5, 30, 31, # 17 24, 25, 30, 11, 24, 5, 30, 11, # 19 14, 15, 20, 21, 14, 15, 20, 11, # 21 14, 15, 10, 21, 14, 15, 10, 11, # 23 28, 29, 34, 35, 28, 29, 10, 35, # 25 4, 29, 34, 35, 4, 29, 10, 35, # 27 38, 39, 44, 45, 4, 39, 44, 45, # 29 38, 5, 44, 45, 4, 5, 44, 45, # 31 24, 29, 30, 35, 14, 15, 44, 45, # 33 12, 13, 18, 19, 12, 13, 18, 11, # 35 16, 17, 22, 23, 16, 17, 10, 23, # 37 40, 41, 46, 47, 40, 41, 46, 47, # 39 36, 37, 42, 43, 36, 5, 42, 43, # 41 12, 17, 18, 23, 12, 13, 42, 43, # 43 36, 41, 42, 47, 16, 17, 46, 47, # 45 12, 17, 42, 47, 0, 1, 6, 7] # 47 module_function def atile(file, id , offset) if @auto_cache[[file,id,offset]] == nil autotile_bitmap = Bitmap.new(32, 32) autotiles_bitmap = autotile(file) if autotiles_bitmap.height == 32 if offset*32 >= autotiles_bitmap.width autotile_bitmap.blt(0,0,autotiles_bitmap,Rect.new(0,0,32,32)) else autotile_bitmap.blt(0,0,autotiles_bitmap,Rect.new(offset*32,0,32,32)) end @auto_cache[[file,id,offset]] = autotile_bitmap return autotile_bitmap end real_id = id*4 off = offset*96 if off>=autotiles_bitmap.width off = 0 end auto1 = AUTOTILES[real_id + 0] auto2 = AUTOTILES[real_id + 1] auto3 = AUTOTILES[real_id + 2] auto4 = AUTOTILES[real_id + 3] rect1 = Rect.new(auto1 % 6 * 16 + off, auto1 / 6 * 16, 16, 16) rect2 = Rect.new(auto2 % 6 * 16 + off, auto2 / 6 * 16, 16, 16) rect3 = Rect.new(auto3 % 6 * 16 + off, auto3 / 6 * 16, 16, 16) rect4 = Rect.new(auto4 % 6 * 16 + off, auto4 / 6 * 16, 16, 16) autotile_bitmap.blt(0, 0, autotiles_bitmap, rect1) autotile_bitmap.blt(16, 0, autotiles_bitmap, rect2) autotile_bitmap.blt(0, 16, autotiles_bitmap, rect3) autotile_bitmap.blt(16, 16, autotiles_bitmap, rect4) @auto_cache[[file,id,offset]] = autotile_bitmap return autotile_bitmap else return @auto_cache[[file,id,offset]] end end def clear_auto for bitmap in @auto_cache.values bitmap.dispose end @auto_cache.clear #GC.start end end end #============================================================================== # ** Sprite_Layer NEW #------------------------------------------------------------------------------ # # Die Klasse zum Verwalten der Tile-Layer. Jeder Layer enthält mehrere # Sprites, eines für jede Tile-Spalte. Erzeugt auch die jeweiligen Bitmaps # für den Layer. # #============================================================================== class Sprite_Layer #-------------------------------------------------------------------------- # * Initialize (Tiles auslesen, Sprites & Bitmaps erzeugen) #-------------------------------------------------------------------------- def initialize(viewport,priority,autotile_frames,cache=nil) # Get Tileset ID @tileset_id = $game_map.map.tileset_id # Class variables @priority = priority @autotile_frames = autotile_frames @viewport = viewport # Calculate number of tiles on x and y axis @width = $game_map.width @height = $game_map.height # Cache for the tiles if cache == nil @cache = {} else @cache = cache end # Set layer border variables to l<->r and u<->d (changed max/min values) @border_lx = @width @border_ty = @height @border_rx = 0 @border_by = 0 # Row border @border_lx_row = @width @border_rx_row = 0 # Table to store left and right border of every row @rows = Table.new(@height,2) # Hash for the sprites @sprites = {} # Setup tiles if @cache.size == 0 setup_tiles else setup_tiles_cache end # If not valid, return return if !valid? # Otherwise, create sprites create_sprites # Get tileset graphic @tileset = RPG::Cache.tileset($game_map.tileset_name) # Draw tiles draw_tiles @tileset = nil end #-------------------------------------------------------------------------- # * Valid? (Überprüft ob in Tiles für diesen Layer gefunden wurden) #-------------------------------------------------------------------------- def valid? # If right border greater or equal to left border and # top border greater or equal to bottom border then true return @border_rx >= @border_lx && @border_by >= @border_ty end #-------------------------------------------------------------------------- # * Row_valid? (Überprüft ob in Tiles in Spalte Y gefunden wurden) #-------------------------------------------------------------------------- def row_valid?(y) # If right row border is greater than left row border true return @rows[y,1]>@rows[y,0] end #-------------------------------------------------------------------------- # * Setup_tiles (Liest Tiles für diesen Layer aus und bestimmt die Grenzen) #-------------------------------------------------------------------------- def setup_tiles # Get pre-sorted Tile data with priority of the layer @data_link = $game_map.priority_data(@priority) # Clone hashs, needed for functionally interation while deleting stuff # from the data @data = @data_link.clone @data_link.each_pair do |dx,data_x| dat_x = @data[dx] dat_x = data_x.dup data_x.each_pair do |dz,data_z| dat_x[dz] = data_z.dup end end # Iterate through sorted tiles on y-axis @data.each_pair do |y,data_y| # Iterate through sorted tiles on x-axis data_y.each_pair do |x,data_x| # Iterate through map editor layers downwards data_x.each_pair do |z,t| # Get Tile ID # If tile is from tileset or autotile with 1 frame if t >= 384 || @autotile_frames[t/48-1] <= 1 # Store in cache @cache[y] = {} if @cache[y] == nil @cache[y][x] = {} if @cache[y][x] == nil @cache[y][x][z] = t # Extend border border(x,y) # Delete from sorted tile list #@data_link[y][x].delete(z) #@data_link[y].delete(x) if @data_link[y][x].size == 0 #@data_link.delete(y) if @data_link[y].size == 0 end end end # Set row borders @rows[y,0] = @border_lx_row @rows[y,1] = @border_rx_row # Re-Initialize row borders for next iteration @border_lx_row = @width/32 @border_rx_row = 0 end end def setup_tiles_cache # Get pre-sorted Tile data with priority of the layer @data_link = $game_map.priority_data(@priority) # Clone hashs, needed for functionally interation while deleting stuff # from the data @data = @data_link.clone @data_link.each_pair do |dx,data_x| dat_x = @data[dx] dat_x = data_x.dup data_x.each_pair do |dz,data_z| dat_x[dz] = data_z.dup end end # Iterate through sorted tiles on y-axis @cache.each_pair do |y,cache_y| # Iterate through sorted tiles on x-axis cache_y.each_pair do |x,cache_x| # Iterate through map editor layers border(x,y) if cache_x.size > 0 end # Set row borders @rows[y,0] = @border_lx_row @rows[y,1] = @border_rx_row # Re-Initialize row borders for next iteration @border_lx_row = @width/32 @border_rx_row = 0 end end #-------------------------------------------------------------------------- # * Create_Sprites (Erzeugt Sprites & Bitmaps für jeden Zeile) #-------------------------------------------------------------------------- def create_sprites # Iterate from upper border to lower border for y in @border_ty..@border_by # If row is not valid if !row_valid?(y) # Skip to next next end # Otherwise, calculate distance from left to right border distx = @rows[y,1] - @rows[y,0] # Create sprite sprite = Sprite.new(@viewport) # Create bitmap in row-size sprite.bitmap = Bitmap.new(distx*32,32) # Set x-coordinate to left border sprite.x = @rows[y,0]*32-$game_map.display_x/4 # Set y-coordinate to row y sprite.y = y*32-$game_map.display_y/4 sprite.blend_type = 0 # If priority equals 0 if @priority == 0 # Set Z to 0, Sprite always beyond later created sprite.z = 0 else # Set Z to Base + Priority + Position - Screen Position sprite.z = 32 + 32*@priority + y*32 - $game_map.display_y/4 end # Add sprite to hash @sprites[y] = sprite end end #-------------------------------------------------------------------------- # * Border (Erweitert die Grenzen des Layers und der aktuellen Zeile #-------------------------------------------------------------------------- def border(x,y) # If X is outside left border if x < @border_lx # Extend left border to x @border_lx = x end # If X is outside right border if x > @border_rx # Extend right border to x+1 @border_rx = x+1 end # If Y is outside top border if y < @border_ty # Extend top border to y @border_ty = y end # If Y is outside bottom border if y > @border_by # Extend bottom_border to y @border_by = y end # If X is outside left row border if x < @border_lx_row # Extend left row border to x @border_lx_row = x end # If X is outside right row border if x+1 > @border_rx_row # Extend right row border to y @border_rx_row = x+1 end end #-------------------------------------------------------------------------- # * Update (Aktualisiert die Position der Zeilen im Bild) #-------------------------------------------------------------------------- def update(ox,oy) # Get uppermost row 1 block outside of screen y = [((oy*4-224)/128).to_i,@border_ty].max # Get lowermost row 1 block outside of screen y2 = [y+17,@border_by].min # Iterate from uppermost to lowermost row for i in y..y2 # Skip if row has no sprite sprite = @sprites[i] next if sprite == nil sprite.tone = $game_map.tone # If priority equals 0 sprite.x = @rows[i,0]*32-ox sprite.y = i*32-oy if @priority == 0 # Set z to 0, always beyond sprite.z = 0 else # Set Z to Base + Priority + Position - Screen Position sprite.z = 32+32*@priority+i*32-oy end end end #-------------------------------------------------------------------------- # * Refresh (Erneuert die Eigenschaften aller Sprites) #-------------------------------------------------------------------------- def refresh # Iterate through all sprites for y in @cache.keys sprite = @sprites[y] # Skip if sprite doesn't exist next if sprite == nil sprite.tone = $game_map.tone # If priority equals 0 sprite.x = @rows[y,0]*32-$game_map.display_x/4 sprite.y = y*32-$game_map.display_y/4 if @priority == 0 # Set z to 0, always beyond sprite.z = 0 else # Set Z to Base + Priority + Position - Screen Position sprite.z = 32+32*@priority+y*32-$game_map.display_y/4 end end end #-------------------------------------------------------------------------- # * Draw_tiles (Zeichnet den kompletten Layer in die einzelnen Zeilen) #-------------------------------------------------------------------------- def draw_tiles # Iterate through all cached tiles on y-axis @cache.each_pair do |y,cache_y| # Iterate through all cached tiles on x-axis sprite = @sprites[y] cache_y.each_pair do |x,cache_x| # Iterate through all cached tile layers (map-editor) # ! Lowest z first ! cache_x.values.each do |t| #cache_x.values.reverse.each do |t| #RGSS3 # Get tile ID from cache # Get left border of row lx = @rows[y,0] # If tile is from tileset if t >= 384 # Calculate x/y-position on tileset t -= 384 xt = t%8 yt = t/8 # Source rect r = Rect.new(xt*32,yt*32,32,32) # Blt tile from tileset to row on -border+x sprite.bitmap.blt(-lx*32+x*32,0,@tileset,r) # Else: Tile is an autotile (with 1 frame) else # Calculate file id and autotile id file = (t / 48) - 1 a = t - (file+1)*48 # Get autotile bitmap from RPG::Cache autotile = RPG::Cache.atile($game_map.autotile_names[file],a,0) # Blt autotile to row on -border+x sprite.bitmap.blt(-lx*32+x*32,0,autotile,autotile.rect) end end end end # Clear autotile cache RPG::Cache.clear_auto end #-------------------------------------------------------------------------- # * Dispose (Zeilen-Sprites löschen) #-------------------------------------------------------------------------- def dispose # Dispose every sprite for sprite in @sprites.values sprite.dispose end end end #============================================================================== # ** Tilemap_New NEW #------------------------------------------------------------------------------ # # Das Kernstück des Scripts, die neue Tilemap-Klasse. Besitzt im Moment # Methoden zum Updaten und Löschen, verwaltet sich großteils selbst. # Erzeugt bis zu 5 Layer und 6 Autotile-Layer. Layer werden abhängig von der # Priority und dem Mapping erzeugt, Autotile-Layer je nach Eigenschaften der # Autotiles (Speed,Frames,Blend-Mode) # #============================================================================== class Tilemap_New attr_accessor :tileset,:autotiles,:viewport attr_reader :autotile_frames #-------------------------------------------------------------------------- # * Initialize (Layer erzeugen) #-------------------------------------------------------------------------- def initialize(viewport,tileset,autotiles) # Save tileset & autotiles @viewport = viewport @tileset = tileset @autotiles = autotiles # Get number of frames per autotile @autotile_frames = [] for autotile in @autotiles # If autotiles height exceeds 32 if autotile.height > 32 @autotile_frames << autotile.width/96 # Else: autotiles in X*32 format else @autotile_frames << autotile.width/32 end end # Tileset ID id = $game_map.map.tileset_id # Temporaries autotiles = [] done = [] autotiles_later = {} # Class variables @autotile_layers = [] @layers = [] @ox = 0 @oy = 0 # Iterate through autotiles for i in 0..6 # Get frames frames = @autotile_frames[i] # If onty one frame => static, skip next if frames <= 1 || done.include?(i) # Get properties speed = AUTOTILE::SPEED[id][i] if AUTOTILE::SPEED[id] != nil speed = AUTOTILE::DEFAULT_SPEED if speed == nil blend_type = AUTOTILE::BLEND_TYPE[id][i] if AUTOTILE::BLEND_TYPE[id] != nil blend_type = 0 if blend_type == nil priority = $game_map.priorities[(i+1)*48] # Iterate through all autotiles >= current one # Batches similar autotiles in the same layer -> less memody/lag for j in i..6 # Get 2nd autotile properties speed2 = AUTOTILE::SPEED[id][j] if AUTOTILE::SPEED[id] != nil speed2 = AUTOTILE::DEFAULT_SPEED if speed2 == nil frames2 = @autotile_frames[j] blend_type2 = AUTOTILE::BLEND_TYPE[id][j] if AUTOTILE::BLEND_TYPE[id] != nil blend_type2 = 0 if blend_type2 == nil priority2 = $game_map.priorities[(j+1)*48] # If properties of both autotiles match if speed2 == speed && frames2 == frames && blend_type2 == blend_type && priority2 == priority # Store autotile id autotiles << j # Store properties speed3 = speed frames3 = frames priority3 = priority blend_type3 = blend_type # Autotile id is done done << j end end # If special blended autotiles if blend_type3 >= 1 # Store autotile ids & properties for later creation (z-priority) autotiles_later[priority3] = [] if autotiles_later[priority3] == nil autotiles_later[priority3] << Command_Autotile.new(autotiles,speed3,@autotile_frames,priority3,blend_type3) # Else : Normal blended tile else # Create autotile-Layer @autotile_layers << Sprite_Auto.new(@viewport,autotiles,speed3,@autotile_frames,priority3,blend_type3) # Delete if not valid @autotile_layers.delete_at(@autotile_layers.size-1) if !@autotile_layers[@autotile_layers.size-1].valid? end autotiles.clear end # Iterate through all priority layers for i in 0..5 # Create layer sprite sprite = Sprite_Layer.new(@viewport,i,@autotile_frames) # Keep sprite onty if valid? @layers << sprite if sprite.valid? # If blended autotile waits for creation at current priority if autotiles_later[i] != nil # Iterate through autotile commands for c in autotiles_later[i] # Create autotile-layer @autotile_layers << Sprite_Auto.new(@viewport,c.autotiles,c.speed,c.frames,c.priority,c.blend_type) # Delete if not valid @autotile_layers.delete_at(@autotile_layers.size-1) if !@autotile_layers[@autotile_layers.size-1].valid? end # Delete command layer autotiles_later.delete(i) end end end #-------------------------------------------------------------------------- # * Ox (Gibt Tilemap-X-Position zurück) #-------------------------------------------------------------------------- def ox return @ox end #-------------------------------------------------------------------------- # * Oy (Gibt Tilemap-Y-Position zurück) #-------------------------------------------------------------------------- def oy return @oy end #-------------------------------------------------------------------------- # * Ox= (Setzt Tilemap-X-Position) #-------------------------------------------------------------------------- def ox=(ox) # Return if position is equal to new position return if @ox == ox @ox = ox end #-------------------------------------------------------------------------- # * Oy= (Setzt Tilemap-Y-Position) #-------------------------------------------------------------------------- def oy=(oy) # Return if position is equal to new position return if @oy == oy @oy = oy end #-------------------------------------------------------------------------- # * Initialize (Position,Frames,Z-Position) #-------------------------------------------------------------------------- def update # Update viewport. Corrupts standard x/y positions of fog,characters,weather, # panorama, corrected in the corresponding method #@viewport.ox = $game_map.display_x/4 #@viewport.oy = $game_map.display_y/4 # Update autotile_layers for autotile_layer in @autotile_layers autotile_layer.update(@ox,@oy) end # Update_layers for layer in @layers layer.update(@ox,@oy) end end #-------------------------------------------------------------------------- # * Dispose (Layer&Autotile-Layer löschen) #-------------------------------------------------------------------------- def dispose # Dispose autotile layers for layer in @autotile_layers layer.dispose end @autotile_layers = nil # Dispose layers for layer in @layers layer.dispose end @layers = nil end #-------------------------------------------------------------------------- # * Initialize (Updated alle Reihen aller Layer) #-------------------------------------------------------------------------- def refresh for layer in @autotile_layers layer.refresh end for layer in @layers layer.refresh end end end #============================================================================== # ** Command_Autotile NEW #------------------------------------------------------------------------------ # Klasse zum Speichern von Autotile-Daten. Benutzt um Autotiles mit Blend-Mode # 1/2 erst nach den normalen Tile-Layer zu erzeugen. #============================================================================== class Command_Autotile attr_reader :autotiles,:speed,:frames,:blend_type,:priority #-------------------------------------------------------------------------- # * Initialize #-------------------------------------------------------------------------- def initialize(autotiles,speed,frames,priority,blend_type) @autotiles = autotiles.clone #Autotile list @speed = speed #Animation speed @frames = frames #Nr. of frames @blend_type = blend_type #Blend type @priority = priority #Priority end end #============================================================================== # ** Game_Temp EDIT #------------------------------------------------------------------------------ # Erweiterung zum Speichern der Tilemap beim Szenenwechseln. #============================================================================== class Game_Temp attr_accessor :store_tilemap attr_accessor :tilemap #-------------------------------------------------------------------------- # * Alias Initialize EDIT (Flag & Slot zum temporären Speichern der Tilemap) #-------------------------------------------------------------------------- alias init_later initialize def initialize init_later @store_tilemap = false # Storage flag @tilemap = nil # Storage slot end end #============================================================================== # ** Spriteset_Map EDIT #------------------------------------------------------------------------------ # Erweitert die Klasse Spriteset_Map. Erzeugt ein Objekt der Klasse # Tilemap new. Überschreibt die Methoden Initialize, Dispose und Update # #============================================================================== class Spriteset_Map attr_reader :tilemap attr_reader :viewport1 #-------------------------------------------------------------------------- # * Initialize EDIT (neue Tilemap erzeugen/laden,funktioniert) #-------------------------------------------------------------------------- def initialize @viewport2 = Viewport.new(0, 0, 640, 480) @viewport3 = Viewport.new(0, 0, 640, 480) @viewport2.z = 200 @viewport3.z = 5000 # If no tilemap is stored if $game_temp.tilemap == nil # Make Viewport1 @viewport1 = Viewport.new(0, 0, 640, 480) autotiles = [] for i in 0..6 autotile_name = $game_map.autotile_names[i] autotiles << RPG::Cache.autotile(autotile_name) end tileset = RPG::Cache.tileset($game_map.tileset_name) # Make Tilemap @tilemap = Tilemap_New.new(@viewport1,tileset,autotiles) # Else: Tilemap is stored else # Load Tilemap & Viewport @tilemap = $game_temp.tilemap @viewport1 = @tilemap.viewport # Remove tilemap from storage $game_temp.tilemap = nil end @panorama = Plane.new(@viewport1) @panorama.z = -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[i]) @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[i])) end @timer_sprite = Sprite_Timer.new update end #-------------------------------------------------------------------------- # * Dispose EDIT (Tilemap speichern wenn nötig, sonst dispose) #-------------------------------------------------------------------------- def dispose @tilemap.tileset.dispose for i in 0..6 @tilemap.autotiles[i].dispose end # If tilemap should be stored if $game_temp.store_tilemap == true # Store tilemap $game_temp.tilemap = @tilemap # Disable storage flag $game_temp.store_tilemap = false # Else else # Dispose tilemap & viewport @tilemap.dispose @viewport1.dispose end @panorama.dispose @fog.dispose for sprite in @character_sprites sprite.dispose end @weather.dispose for sprite in @picture_sprites sprite.dispose end # Dispose of viewports except 1 @viewport2.dispose @viewport3.dispose end end #============================================================================== # ** Game_Map EDIT #------------------------------------------------------------------------------ # Erweitert die Klasse Game_Map um Attribute und Methoden zum Vorsortieren von # Tiles nach Priority, außerdem für den Tilemap-Tone. #============================================================================== class Game_Map attr_reader :map #Map-Daten attr_reader :tone #Color-Tone #-------------------------------------------------------------------------- # * Alias initialize (Variablen für Tilemap-Tone) #-------------------------------------------------------------------------- alias init_later initialize def initialize init_later @tone = Tone.new(0,0,0,0) # Tilemap-tone @tone_duration = 0 # Tone-duration end alias setup_later setup def setup(map_id) setup_later(map_id) # Sort tiles after setup sort end #-------------------------------------------------------------------------- # * Sort (sortiert Tile-IDs nach Priority zum späteren Auslesen #-------------------------------------------------------------------------- def sort # One hash for every priority @priority0 = {} @priority1 = {} @priority2 = {} @priority3 = {} @priority4 = {} @priority5 = {} # Iterate through tiles on x-axis for x in 0...width # Iterate through tiles on y-axis for y in 0...height # Check layers from map editor top->bottom for z in [2,1,0] # Tile ID tile = data[x,y,z] # If tile is not empty if tile != 0 # Get & check priority for tile, set in according hash case @priorities[tile] when 0 @priority0[y] = {} if @priority0[y] == nil @priority0[y][x] = {} if @priority0[y][x] == nil @priority0[y][x][z] = tile when 1 @priority1[y] = {} if @priority1[y] == nil @priority1[y][x] = {} if @priority1[y][x] == nil @priority1[y][x][z] = tile when 2 @priority2[y] = {} if @priority2[y] == nil @priority2[y][x] = {} if @priority2[y][x] == nil @priority2[y][x][z] = tile when 3 @priority3[y] = {} if @priority3[y] == nil @priority3[y][x] = {} if @priority3[y][x] == nil @priority3[y][x][z] = tile when 4 @priority4[y] = {} if @priority4[y] == nil @priority4[y][x] = {} if @priority4[y][x] == nil @priority4[y][x][z] = tile when 5 @priority5[y] = {} if @priority5[y] == nil @priority5[y][x] = {} if @priority5[y][x] == nil @priority5[y][x][z] = tile end end end end end end #-------------------------------------------------------------------------- # * Priority-Data (gibt die vorher sortierten Tiles zurück) #-------------------------------------------------------------------------- def priority_data(priority) # Check priority and return appropriate sorted hash case priority when 0 return @priority0 when 1 return @priority1 when 2 return @priority2 when 3 return @priority3 when 4 return @priority4 when 5 return @priority5 else # Invalid priority: return hash 0 return @priority0 end end #-------------------------------------------------------------------------- # * Start tone change (wie in Game_Screen, aber für die Tilemap!) #-------------------------------------------------------------------------- def start_tone_change(tone, duration) @tone_target = tone.clone @tone_duration = duration if @tone_duration == 0 @tone = @tone_target.clone end end alias upd_later update #-------------------------------------------------------------------------- # * Alias update (führt den Tone-Wechsel aus) #-------------------------------------------------------------------------- def update if @tone_duration >= 1 d = @tone_duration @tone.red = (@tone.red * (d - 1) + @tone_target.red) / d @tone.green = (@tone.green * (d - 1) + @tone_target.green) / d @tone.blue = (@tone.blue * (d - 1) + @tone_target.blue) / d @tone.gray = (@tone.gray * (d - 1) + @tone_target.gray) / d @tone_duration -= 1 end upd_later end end #============================================================================== # ** Scene_Map EDIT #------------------------------------------------------------------------------ # Überschreibt die Main-Methode, um das Spriteset im Fall eines Szenewechsels # zu speichern. #============================================================================== class Scene_Map #-------------------------------------------------------------------------- # * Main overwrite (setzt die store-tileset-flag im Fall eines Szenenwechsels) #-------------------------------------------------------------------------- def main @spriteset = Spriteset_Map.new @message_window = Window_Message.new Graphics.transition loop do Graphics.update Input.update update if $scene != self break end end Graphics.freeze # Set store tilemap flag to true $game_temp.store_tilemap = true @spriteset.dispose @message_window.dispose if $scene.is_a?(Scene_Title) Graphics.transition Graphics.freeze end end #-------------------------------------------------------------------------- # * Alias transfer_player (sorgt für fehlerfreien Teleport auf derselben Map) #-------------------------------------------------------------------------- alias transfer_later transfer_player def transfer_player # If old and new_map are the same if $game_map.map_id == $game_temp.player_new_map_id # Set store tilemap flag $game_temp.store_tilemap = true end transfer_later # Refresh tilemap @spriteset.tilemap.refresh end end