#============================================================================== # ** Drago - Custom Resolution # Version : 2.17 # Contact : littledrago.blogspot.com / forum.chaos-project.com #============================================================================== ($imported ||= {})[:drg_custom_resolution] = 2.17 #============================================================================== # # Introduction : # # Version 2 from previous Drago - Custom Resolution # # Issue : # # - Normal transition didn't work when resolution is more than 640x480 # - ALT+Enter is disabled by default # - Custom menu system will require an edit to match the new resolution # - Anything that modify Sprite_Character & Spriteset_Map will require an edit # # Script Call : # # Graphics.window # Graphics.fullscreen # Graphics.fullscreen? # returns true if game is fullscreen # # $game_map.start_zoom(X, Y, ZOOM_VALUE, DURATION = 20) # $game_map.zoom(X = nil, Y = nil, ZOOM_VALUE) # $game_map.zoom_in(X = nil, Y = nil, DURATION = 20) # $game_map.zoom_out(X = nil, Y = nil, DURATION = 20) # # $game_map.reverse(true / false) # Flip the map # # $game_map.start_tilemap_opacity(OPACITY = 255, DURATION = 20) # $game_map.start_tilemap_tone(TONE = Tone.new(0,0,0,0), DURATION = 0) # # # change_tilemap_tone(TONE,*CHARACTER) # change tilemap tone # change_character_tone(TONE,*CHARACTER) # change character tone without # changing the tilemap # # X, Y = Zoom focus # # ZOOM_VALUE = Integer from 1-12 # # OPACITY = Integer from 0-255 # # TONE = [R,G,B,A] or Tone.new(R,G,B,A) # # CHARACTER = $game_map.events.values # all events # = $game_map.events.keys # all events # = $game_player # player # = -1 # player # = 0 # this event # = [2,3,4,6] # events with selected id # = [-1,2,3,4,6] # player & events with selected id # = [0,2,3,4,6] # this event & events with selected id # = (1..99) # events in range # = [(1..8),20,25,(30..42)] # events in range # # * will not change the character tone if left out # # Links : # # - Fantasist's Transitions Pack # http://forum.chaos-project.com/index.php/topic,1390.0.html # - ForeverZer0's Add-ons # http://forum.chaos-project.com/index.php/topic,7862.0.html # - ThallionDarkshine's Add-ons # http://forum.chaos-project.com/index.php/topic,12655.0.html # - Drago Transition Pack # http://forum.chaos-project.com/index.php/topic,13488.0.html # # - Adjust Menu Position # http://forum.chaos-project.com/index.php/topic,13781.0.html # # - ThallionDarkshine's F12 Fix # http://forum.chaos-project.com/index.php/topic,13629.0.html # - Zeriab's F12 Pause with images # http://forum.chaos-project.com/index.php/topic,3613.0.html # # Special Thanks : # # - ForeverZer0 & KK20 for method used in this script # - Wecoc for autotile addon # #============================================================================== module LiTTleDRAgo SCREEN_SIZE = [640,490] # Define the resolution of the game screen. These values can be anything # within reason. Centering, viewports, etc. will all be taken care of, but it # is recommended that you use values divisible by 32 for best results. AUTOTILE_SPEED = {} AUTOTILE_SPEED[:map_id] = :speed AUTOTILE_SPEED[0] = 6 # default speed #AUTOTILE_SPEED[35] = 0 # unchanged autotile #AUTOTILE_SPEED[159] = 16 # Speed of the autotile based on map_id CONTROL_SCREEN_SIZE = false # Control screen size with a mouse HIGH_PRIORITY = true # Change Game process priority to high SPRITE_COMPACT = true # Keep the sprite to the very minimum number CHARACTER_Z_FIX = { '178-Switch01' => 0, '180-Switch03' => 0, '181-Switch04' => 0, '199-Support07' => 0, } # Fix the screen_z value for events based on Graphic name. # You can also define z value for event by inserting # on event name. # This way, flat events such as pitfall won't overlap with player z value. end core = "This script needs Drago - Core Engine ver 1.47 or above" rmvx = "This script not for RMVX" implemented = "%1$s has already implemented, Please remove the %1$s script" zoom = sprintf(implemented,"Map Zoom") tone = sprintf(implemented,"Tilemap Tone Changer" ) ($imported[:drg_core_engine] || 0) >= 1.47 || raise(core) LiTTleDRAgo::XP || LiTTleDRAgo::VXA || raise(rmvx) $imported[:drg_cr_map_zoom] && raise(zoom) $imported[:drg_tilemap_tone_changer] && raise(tone) #============================================================================== # ** Graphics #------------------------------------------------------------------------------ # This module handles all Graphics #============================================================================== class << Graphics #------------------------------------------------------------------------- # * Alias Listing #------------------------------------------------------------------------- alias_sec_method :zer0_graphics_transition, :transition alias_sec_method :drg_resolution_change_resize_screen, :resize_screen alias_sec_method :drg_resolution_change_update, :update #------------------------------------------------------------------------- # * Aliased method: resize_screen #------------------------------------------------------------------------- def resize_screen(width, height) width = (width / 32.0).round * 32 height = (height / 32.0).round * 32 if $game_map.respond_to?(:screen_size) $game_map.screen_size[0] = width $game_map.screen_size[1] = height end drg_resolution_change_resize_screen(width, height) end #------------------------------------------------------------------------- # * Aliased method: transition #------------------------------------------------------------------------- def transition(duration = 8, *args) if width <= 640 && height <= 480 return zer0_graphics_transition(duration, *args) end if duration > 0 viewport = Viewport.new(0,0,width,height) sprite = Sprite.new(viewport) sprite.bitmap = Graphics.snap_to_bitmap sprite2 = Sprite.new(viewport) sprite2.z = sprite.z - 10 sprite2.blend_type = 1 zer0_graphics_transition(0) fade = 255 / duration if (file = args.at(0)).is_a?(String) bitmap = Bitmap.new(file) sprite2.bitmap = bitmap.stretch(width,height) bitmap.dispose end duration.times {[sprite,sprite2].each {|s|s.opacity -= fade} && update } [sprite.bitmap, sprite2.bitmap, sprite, sprite2, viewport].dispose end zer0_graphics_transition(0) end #------------------------------------------------------------------------- # * Aliased method: update #------------------------------------------------------------------------- def update drg_resolution_change_update update_resolution_adjust end #------------------------------------------------------------------------- # * New method: update_resolution_adjust #------------------------------------------------------------------------- def update_resolution_adjust return unless LiTTleDRAgo::XP && $game_player return unless Game_Player.const_defined?(:CENTER_X) change = Game_Player.const_get(:CENTER_X) != $game_player.center_x change ||= Game_Player.const_get(:CENTER_Y) != $game_player.center_y return unless change resize_screen(width,height) $game_player.center($game_player.x,$game_player.y) end #------------------------------------------------------------------------- # * Overwriten method: fullscreen #------------------------------------------------------------------------- def fullscreen @fullscreen = true fill_monitor LiTTleDRAgo.hide_borders end #------------------------------------------------------------------------- # * Overwriten method: window #------------------------------------------------------------------------- def window @fullscreen = false LiTTleDRAgo.show_borders if $game_map && $game_map.screen_size.all? {|s| s.is_a?(Numeric)} x,y = $game_map.screen_size[0..1] x += ($game_map.screen_size[2] ||= 1) $game_map.screen_size[2] *= -1 drg_resolution_change_resize_screen(x,y) else x,y = LiTTleDRAgo::SCREEN_SIZE end resize_screen(x,y) end #------------------------------------------------------------------------- # * Overwriten method: fullscreen? #------------------------------------------------------------------------- define_method(:fullscreen?) { @fullscreen == true } end Graphics.window Graphics.disable_alt_enter Graphics.control_screen_size LiTTleDRAgo::CONTROL_SCREEN_SIZE Graphics.high_priority = LiTTleDRAgo::HIGH_PRIORITY GC.start #============================================================================== # ** Game_Map #------------------------------------------------------------------------------ # This class handles the map. It includes scrolling and passable determining # functions. Refer to "$game_map" for the instance of this class. #============================================================================== class Game_Map #-------------------------------------------------------------------------- # * Public Instance Variable #-------------------------------------------------------------------------- attr_sec_accessor :zoom_x, :zoom_y, 'Integer(1)' attr_sec_accessor :screen_size, 'LiTTleDRAgo::SCREEN_SIZE' attr_sec_accessor :tilemap_tone, 'Tone.new(0,0,0)' attr_sec_accessor :tilemap_opacity, 'Integer(255)' attr_sec_accessor :tilemap_hue, 'Integer(0)' #--------------------------------------------------------------------------- # * Redirect Listing #--------------------------------------------------------------------------- [:tilemap_tone,:tilemap_opacity].each do |meth| redirect_method :"#{meth}_changing?", "(@#{meth}_duration ||= 0) > 0" end #--------------------------------------------------------------------------- # * Define Sec Listing #--------------------------------------------------------------------------- define_sec_method(:zooming?) {(@zoom_duration ||= 0) > 0} define_sec_method(:screen_tile_x) {(Graphics.width / 32.0).ceil} define_sec_method(:screen_tile_y) {(Graphics.height / 32.0).ceil} #------------------------------------------------------------------------- # * Alias Listing #------------------------------------------------------------------------- alias_sec_method(:drg_scroll_right_adjust, :scroll_right) alias_sec_method(:drg_scroll_down_adjust, :scroll_down) alias_sec_method(:tilemap_effect_update, :update) alias_sec_method(:get_map_data, :data) #-------------------------------------------------------------------------- # * Aliased method: Scroll Down #-------------------------------------------------------------------------- def scroll_down(distance) times = vxa_map_multiplier if loop_vertical? @display_y += distance @display_y %= height * times @parallax_y += distance if @parallax_y && @parallax_loop_y else last_y = @display_y result = [@display_y + distance, (map_edge.at(1) / zoom_y)].min drg_scroll_down_adjust(distance) @display_y = result end end #-------------------------------------------------------------------------- # * Aliased method: Scroll Right #-------------------------------------------------------------------------- def scroll_right(distance) times = vxa_map_multiplier if loop_horizontal? @display_x += distance @display_x %= width * times @parallax_x += distance if @parallax_x && @parallax_loop_x else last_x = @display_x result = [@display_x + distance, (map_edge.at(0) / zoom_x)].min drg_scroll_right_adjust(distance) @display_x = result end end #-------------------------------------------------------------------------- # * New method: zoom #-------------------------------------------------------------------------- def zoom(*zoom) if zoom.size == 1 zoom = (zoom.first) elsif zoom.size == 3 x,y,zoom = zoom[0..2] end return unless zoom.is_a?(Numeric) old_zoom = @zoom_x @zoom_x = [[zoom,12].min, 1].max @zoom_y = [[zoom,12].min, 1].max $game_player.center(x,y) if x && y end #-------------------------------------------------------------------------- # * New method: zoom_in #-------------------------------------------------------------------------- def zoom_in(x = nil,y = nil, duration = 20) start_zoom(x,y, zoom_x >= 1 ? zoom_x + 1 : 1, duration) end #-------------------------------------------------------------------------- # * New method: zoom_out #-------------------------------------------------------------------------- def zoom_out(x = nil,y = nil,duration = 20) start_zoom(x,y, zoom_x - 1 >= 1 ? zoom_x - 1 : zoom_x - 0.5, duration) end #-------------------------------------------------------------------------- # * New method: map_edge #-------------------------------------------------------------------------- def map_edge times = vxa_map_multiplier [_w = [(width * zoom_x - screen_tile_x).ceil * times, 0].max, _h = [(height * zoom_y - screen_tile_y).ceil * times, 0].max] end #-------------------------------------------------------------------------- # * New method: autotile_speed #-------------------------------------------------------------------------- def autotile_speed(id = @map_id) speed = LiTTleDRAgo::AUTOTILE_SPEED @autotile_speed.is_a?(Array) || @autotile_speed = [] @autotile_speed[id] ||= (speed[id] || speed[0] || 0) end #-------------------------------------------------------------------------- # * New method: autotile_speed= #-------------------------------------------------------------------------- def autotile_speed=(*value) @autotile_speed.is_a?(Array) || @autotile_speed = [] @autotile_speed[@map_id] = [value.first,0].max if value.size == 1 @autotile_speed[value.first] = [value.at(1),0].max if value.size > 1 end #-------------------------------------------------------------------------- # * New method: vxa_map_multiplier #-------------------------------------------------------------------------- def vxa_map_multiplier LiTTleDRAgo::VXA ? 1 : 128 end #-------------------------------------------------------------------------- # * New method: screen_is_solid? #-------------------------------------------------------------------------- def screen_is_solid? tone = screen.tone.to_s.gsub(/([(),0 ])/i){''} return true if tone['255.255.255.'] return true if tone['255.-255.-255.'] return true if tone['-255.255.-255.'] return true if tone['-255.-255.255.'] return true if tone['255.255.-255.'] return true if tone['255.-255.255.'] return true if tone['-255.255.255.'] return true if tone['-255.-255.-255.'] end #-------------------------------------------------------------------------- # * Aliased method: data #-------------------------------------------------------------------------- def data data = self.reverse ? reverse_data : get_map_data data.make_changes = true data end #-------------------------------------------------------------------------- # * New method: reverse_data #-------------------------------------------------------------------------- def reverse_data @reverse_data ||= [] @reverse_data[@map_id] ||= get_map_data.reverse(true,false,false) end #-------------------------------------------------------------------------- # * New method: reverse= #-------------------------------------------------------------------------- def reverse=(val) return val if @reverse == val @reverse = ((@reverse_data||=[])[@map_id] = nil) || val spriteset && spriteset.reload_tilemap @reverse end #-------------------------------------------------------------------------- # * New method: reverse #-------------------------------------------------------------------------- def reverse @reverse && LiTTleDRAgo::XP end #-------------------------------------------------------------------------- # * New method: start_tilemap_tone #-------------------------------------------------------------------------- def start_tilemap_tone(tone = Tone.new(0,0,0,0), duration = 0) @tilemap_tone_target = tone.is_a?(Array) ? Tone.new(*tone) : tone.clone @tilemap_tone_duration = duration tilemap_tone_changing? || @tilemap_tone = @tilemap_tone_target.clone end #-------------------------------------------------------------------------- # * New method: start_tilemap_opacity #-------------------------------------------------------------------------- def start_tilemap_opacity(opacity = 255, duration = 0) @tilemap_opacity_target = opacity * 1.0 @tilemap_opacity_duration = duration tilemap_opacity_changing? || @tilemap_opacity = @tilemap_opacity_target end #-------------------------------------------------------------------------- # * New method: update_tilemap_tone #-------------------------------------------------------------------------- def update_tilemap_tone if tilemap_tone_changing? d = @tilemap_tone_duration target = @tilemap_tone_target @tilemap_tone.red = (@tilemap_tone.red * (d - 1) + target.red) / d @tilemap_tone.green = (@tilemap_tone.green * (d - 1) + target.green) / d @tilemap_tone.blue = (@tilemap_tone.blue * (d - 1) + target.blue) / d @tilemap_tone.gray = (@tilemap_tone.gray * (d - 1) + target.gray) / d @tilemap_tone_duration -= 1 tilemap_tone_changing? || @tilemap_tone = @tilemap_tone_target.clone end end #-------------------------------------------------------------------------- # * New method: update_tilemap_opacity #-------------------------------------------------------------------------- def update_tilemap_opacity if tilemap_opacity_changing? d = @tilemap_opacity_duration @tilemap_opacity = (@tilemap_opacity * (d - 1) + @tilemap_opacity_target) / d @tilemap_opacity_duration -= 1 tilemap_opacity_changing? || @tilemap_opacity = @tilemap_opacity_target end end #-------------------------------------------------------------------------- # * New method: start_zoom #-------------------------------------------------------------------------- def start_zoom(x,y, zoom_target, duration=20) @x_zoom = x @y_zoom = y @zoom_target = zoom_target * 1.0 @zoom_duration = @zoom_x == @zoom_target ? 0 : duration zooming? || zoom(@x_zoom,@y_zoom,@zoom_target) end #-------------------------------------------------------------------------- # * New method: update_zooming #-------------------------------------------------------------------------- def update_zooming if zooming? d = @zoom_duration power = (@zoom_x * (d - 1) + @zoom_target) / d @zoom_duration -= 1 zoom(@x_zoom,@y_zoom,power) zoom(@x_zoom,@y_zoom,@zoom_target) unless zooming? end end #-------------------------------------------------------------------------- # * Aliased method: update #-------------------------------------------------------------------------- def update(*args) tilemap_effect_update(*args) update_tilemap_tone update_tilemap_opacity update_zooming end end #============================================================================== # ** Interpreter #------------------------------------------------------------------------------ # This interpreter runs event commands. This class is used within the # Game_System class and the Game_Event class. #============================================================================== unless LiTTleDRAgo::VX class Interpreter #--------------------------------------------------------------------------- # * Redirect Listing #--------------------------------------------------------------------------- redirect_method :zoom, '$game_map.zoom' redirect_method :zoom_in, '$game_map.zoom_in' redirect_method :zoom_out, '$game_map.zoom_out' redirect_method :start_zoom, '$game_map.start_zoom' redirect_method :start_tilemap_opacity, '$game_map.start_tilemap_opacity' redirect_method :start_tilemap_tone, '$game_map.start_tilemap_tone' [:change_tilemap_tone,:change_character_tone].each do |meth| redirect_method :"#{meth}", :"$game_map.spriteset.#{meth}" end end end #============================================================================== # ** Game_Player #------------------------------------------------------------------------------ # This class handles the player. Its functions include event starting # determinants and map scrolling. Refer to "$game_player" for the one # instance of this class. #============================================================================== class Game_Player #--------------------------------------------------------------------------- # * Define Sec Listing #--------------------------------------------------------------------------- define_sec_method(:center_x) {((Graphics.width/2) / $game_map.zoom_x-16) * 4} define_sec_method(:center_y) {((Graphics.height/2) / $game_map.zoom_y-16) * 4} #------------------------------------------------------------------------- # * Alias Listing #------------------------------------------------------------------------- alias_sec_method(:drg_adjust_viewport_center, :center) #------------------------------------------------------------------------- # * Aliased method: center #------------------------------------------------------------------------- def center(x, y) if LiTTleDRAgo::XP Game_Player.const_set(:CENTER_X, center_x) Game_Player.const_set(:CENTER_Y, center_y) end drg_adjust_viewport_center(x, y) max_x = $game_map.map_edge.at(0) / $game_map.zoom_x max_y = $game_map.map_edge.at(1) / $game_map.zoom_y if LiTTleDRAgo::XP $game_map.display_x = [0, [(x * 32*4) - center_x, max_x.ceil].min].max $game_map.display_y = [0, [(y * 32*4) - center_y, max_y.ceil].min].max elsif $game_map.respond_to?(:set_display_pos) $game_map.set_display_pos(x - center_x, y - center_y) end end end #============================================================================== # ** Tilemap #------------------------------------------------------------------------------ # #============================================================================== class Tilemap #--------------------------------------------------------------------------- # * Public Instance Variables #--------------------------------------------------------------------------- method_defined?(:tileset) || attr_accessor(:tileset) method_defined?(:priorities)|| attr_accessor(:priorities) method_defined?(:autotiles) || attr_sec_accessor(:autotiles,'Array.new') end #============================================================================== # ** Table #------------------------------------------------------------------------------ # #============================================================================== class Table #-------------------------------------------------------------------------- # * Public Instance Variable #-------------------------------------------------------------------------- attr_sec_accessor :table_changes, :orig_value, 'Array.new' attr_accessor :make_changes #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias_sec_method :set_method, :"[]=" #-------------------------------------------------------------------------- # * Set Data #-------------------------------------------------------------------------- def []=(*args) if @make_changes table_changes.push([*args]) && orig_value.push(self[*args[0..-2]]) @make_changes = false end set_method(*args) end #-------------------------------------------------------------------------- # * Reverse #-------------------------------------------------------------------------- def reverse(rx=true,ry=true,rz=true) reverse = self.clone _x = (0...xsize).to_a _y = (0...ysize).to_a _z = (0...zsize).to_a _x.each do |x| _rx = rx ? _x[-1-x] : x ysize == 1 && (reverse[x] = self[_rx]) && next _y.each do |y| _ry = ry ? _y[-1-y] : y zsize == 1 && (reverse[x,y] = self[_rx,_ry]) && next _z.each do |z| _rz = rz ? _z[-1-z] : z reverse[x,y,z] = self[_rx,_ry,_rz] end end end reverse end end #============================================================================== # ** RPG::Cache #============================================================================== ModCache = LiTTleDRAgo.cache module ModCache #---------------------------------------------------------------------------- # * Self #---------------------------------------------------------------------------- class << self #-------------------------------------------------------------------------- # * Constant #-------------------------------------------------------------------------- AUTO_INDEX = [[ [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], [ 1, 2, 7, 8]], [[27,28,33,34], [49,50,55,56], [51,52,57,58], [49,52,55,58], [63,64,69,70], [65,66,71,72], [51,52,69,70], [ 5, 6,33,12], [61,62,67,68], [49,50,67,68], [53,54,59,60], [ 5, 6,11,34], [61,64,67,70], [ 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], [ 1, 2, 7, 8]] ].freeze #-------------------------------------------------------------------------- # * Public Instance Variable #-------------------------------------------------------------------------- attr_sec_reader :cache, 'Hash.new' #-------------------------------------------------------------------------- # * New method: autotile_cr_tilemap #-------------------------------------------------------------------------- def autotile_cr_tilemap(filename) key = "Graphics/Autotiles/CR#{filename}" if !@cache.include?(key) || @cache[key].disposed? @cache[key] = (filename=='') ? Bitmap.new(128,96) : autotile(filename) new_bm = self.format_autotiles(@cache[key], filename) @cache[key].dispose @cache[key] = new_bm @cache[key].instance_variable_set(:@autotile_name, filename) end return @cache[key] end #-------------------------------------------------------------------------- # * New method: include? #-------------------------------------------------------------------------- unless method_defined?(:include?) def include?(key) @cache[key] && !@cache[key].disposed? end end #-------------------------------------------------------------------------- # * New method: format_autotiles #-------------------------------------------------------------------------- def format_autotiles(bitmap, filename) if bitmap.height > 32 frames = bitmap.width / 96 index = bitmap.height == 192 ? AUTO_INDEX[1] : AUTO_INDEX[0] template = Bitmap.new(256*frames,192) frames.times {|a| (0...6).each { |i| (0...8).each { |j| index[8*i+j].each { |number| number -= 1 x, y = 16 * (number % 6), 16 * (number / 6) ox, oy = (32 * j + x % 32) + (a * 256), 32 * i + y % 32 rect = Rect.new(x + (a * 96), y, 16, 16) template.blt(ox, oy, bitmap, rect) }}}} return template else return bitmap end end #-------------------------------------------------------------------------- # * New method: tile #-------------------------------------------------------------------------- unless method_defined?(:format_tile) def format_tile(bitmap, tile_id, hue) filename = bitmap.pathname key = [filename, tile_id, hue] unless include?(key) @cache[key] = empty_bitmap x = (tile_id - 384) % 8 * 32 y = (tile_id - 384) / 8 * 32 rect = Rect.new(x, y, 32, 32) @cache[key].blt(0, 0, bitmap, rect) @cache[key].hue_change(hue) end @cache[key] end end #-------------------------------------------------------------------------- # * New method: clear_tile_cache #-------------------------------------------------------------------------- def clear_tile_cache @cache ||= {} @cache.reject! do |keys| keys.is_a?(Array) && keys.size == 3 && keys[0].is_a?(String) && keys[0].downcase["tilemap"] end GC.start end end end #============================================================================== # ** Bitmap #------------------------------------------------------------------------------ # 　 #============================================================================== class Bitmap #-------------------------------------------------------------------------- # * Public Instance Variable #-------------------------------------------------------------------------- attr_sec_accessor :pathname, 'String.new' #-------------------------------------------------------------------------- # ● Alias Method #-------------------------------------------------------------------------- $@ || alias_method(:cr_path_init, :initialize) #-------------------------------------------------------------------------- # ● Object Initialization #-------------------------------------------------------------------------- def initialize(*args) @pathname = args.at(0) if args.at(0).is_a?(String) cr_path_init(*args) end end #============================================================================== # ** RPG::Weather #------------------------------------------------------------------------------ # A class for weather effects (rain, storm, and snow). It is used within the # Spriteset_Map class. #============================================================================== CRWeather = LiTTleDRAgo::VX ? Spriteset_Weather : RPG::Weather class CRWeather #-------------------------------------------------------------------------- # * Public Instance Variable #-------------------------------------------------------------------------- attr_reader :viewport attr_accessor :zoom_x, :zoom_y #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- $@ || alias_method(:init_custom_resolution, :initialize) #-------------------------------------------------------------------------- # * Aliased method: initialize #-------------------------------------------------------------------------- def initialize(viewport) @viewport = viewport init_custom_resolution(@viewport) end #-------------------------------------------------------------------------- # * Overwriten method: update #-------------------------------------------------------------------------- def update return if @type == 0 return if $game_map && $game_map.screen_is_solid? update_screen if respond_to?(:update_screen) @sprites.each {|sprite| update_sprite(sprite) } end #-------------------------------------------------------------------------- # * Update Sprite #-------------------------------------------------------------------------- def update_sprite(sprite) sprite.ox = @ox sprite.oy = @oy case @type when 1, :rain then update_sprite_rain(sprite) when 2, :storm then update_sprite_storm(sprite) when 3, :snow then update_sprite_snow(sprite) end create_new_particle(sprite) if sprite.opacity < 64 end #-------------------------------------------------------------------------- # * Update Sprite [Rain] #-------------------------------------------------------------------------- def update_sprite_rain(sprite) sprite.bitmap = @rain_bitmap sprite.x -= 2 * sprite.zoom_x sprite.y += 16 * sprite.zoom_y sprite.opacity -= 8 end #-------------------------------------------------------------------------- # * Update Sprite [Storm] #-------------------------------------------------------------------------- def update_sprite_storm(sprite) sprite.bitmap = @storm_bitmap sprite.x -= 8 * sprite.zoom_x sprite.y += 16 * sprite.zoom_y sprite.opacity -= 12 end #-------------------------------------------------------------------------- # * Update Sprite [Snow] #-------------------------------------------------------------------------- def update_sprite_snow(sprite) sprite.bitmap = @snow_bitmap sprite.x -= 2 * sprite.zoom_x sprite.y += 8 * sprite.zoom_y sprite.opacity -= 8 end #-------------------------------------------------------------------------- # * Create New Particle #-------------------------------------------------------------------------- def create_new_particle(sprite) sprite.x = rand(Graphics.width + 100) - 100 + @ox sprite.y = rand(Graphics.height + 200) - 200 + @oy sprite.zoom_x = @zoom_x || 1 sprite.zoom_y = @zoom_y || 1 sprite.x *= sprite.zoom_x sprite.y *= sprite.zoom_y sprite.opacity = 160 + rand(96) end #--------------------------------------------------------------------------- # * New method: method_missing #--------------------------------------------------------------------------- def method_missing(val,*a,&b) en = @sprites.flatten.find_all {|s|s.respond_to?(val.to_sym)} if en.empty? text = "Undefined method #{val} at #{self.inspect}" raise(NoMethodError,text,caller(1)) end return en.map {|s| s.send(val.to_sym,*a,&b)} end end #============================================================================== # ** Plane #------------------------------------------------------------------------------ # This class is the rewrite of the default plane class #============================================================================== class CRPlane < Sprite #--------------------------------------------------------------------------- # * Public Instance Variable #--------------------------------------------------------------------------- attr_reader :bitmap #--------------------------------------------------------------------------- # * New method: z= #--------------------------------------------------------------------------- def z=(z) super(z * 1000) end #--------------------------------------------------------------------------- # * New method: ox= #--------------------------------------------------------------------------- def ox=(ox) return if $game_map && $game_map.screen_is_solid? return if bitmap.nil? || bitmap.disposed? super(ox % bitmap.width) if bitmap.is_a?(Bitmap) end #--------------------------------------------------------------------------- # * New method: oy= #--------------------------------------------------------------------------- def oy=(oy) return if $game_map && $game_map.screen_is_solid? return if bitmap.nil? || bitmap.disposed? super(oy % bitmap.height) if bitmap.is_a?(Bitmap) end #--------------------------------------------------------------------------- # * New method: dispose #--------------------------------------------------------------------------- def dispose @plane && (@plane.disposed? || @plane.dispose) super unless disposed? end #--------------------------------------------------------------------------- # * New method: bitmap= #--------------------------------------------------------------------------- def bitmap=(tile) return if @bitmap == tile @bitmap = tile if @bitmap.is_a?(Bitmap) xx = 1 + (Graphics.width.to_f / tile.width).ceil yy = 1 + (Graphics.height.to_f / tile.height).ceil @plane.dispose if @plane.respond_to?(:dispose) && @plane.not.disposed? @plane = Bitmap.new(@bitmap.width * xx, @bitmap.height * yy) (0..xx).each {|x| (0..yy).each {|y| @plane.blt(x * @bitmap.width, y * @bitmap.height, @bitmap, @bitmap.rect) }} super(@plane) else super(nil) end end #--------------------------------------------------------------------------- # * Undefine methods dealing with coordinates to do nothing. #--------------------------------------------------------------------------- undef :x, :x=, :y, :y= if method_defined?(:x) end #============================================================================== # ** Viewport #------------------------------------------------------------------------------ # #============================================================================== class Viewport #-------------------------------------------------------------------------- # * Overwriten method: update_viewport_sizes #-------------------------------------------------------------------------- def update_viewport_sizes map = $game_map w, h = Graphics.width, Graphics.height hor = $game_map.loop_horizontal? ver = $game_map.loop_vertical? _w = ($game_map.width * 32 * $game_map.zoom_x).floor _h = ($game_map.height * 32 * $game_map.zoom_y).floor dx = w > _w && !hor ? ((w - _w).floor.abs / 32) * 16 : 0 dw = hor ? w : [w, $game_map.width * 32 * $game_map.zoom_x].min dy = h > _h && !ver ? ((h - _h).floor.abs / 32) * 16 : 0 dh = ver ? h : [h, $game_map.height * 32 * $game_map.zoom_y].min resize(Rect.new(dx, dy, dw, dh)) end end #============================================================================== # ** ZTilemap #------------------------------------------------------------------------------ # This class is the rewrite of the default tilemap class #============================================================================== class ZTilemap #--------------------------------------------------------------------------- # * Public Instance Variables #--------------------------------------------------------------------------- attr_reader :map_data, :viewport attr_accessor :tileset, :tone, :priorities, :sprite_compact attr_sec_accessor :autotiles, 'Array.new' attr_sec_accessor :ox, :oy, :zoom_x, :zoom_y, :hue, 'Integer(1)' attr_sec_accessor :opacity, 'Integer(255)' attr_sec_reader :layers, :bitmap_layers, :extra_map_data, 'Array.new' #--------------------------------------------------------------------------- # * Redirect Listing #--------------------------------------------------------------------------- redirect_method :width, '$game_map.screen_tile_x + 2' redirect_method :height, '$game_map.screen_tile_y + 2' #--------------------------------------------------------------------------- # * Define Sec Listing #--------------------------------------------------------------------------- define_sec_method(:all_sprites) { layers.flatten.select {|s| is_sprite?(s)}} define_sec_method(:is_sprite?) { |s| s.is_a?(Sprite) && s.not.disposed? } #--------------------------------------------------------------------------- # * Alias Listing #--------------------------------------------------------------------------- alias_method :bitmaps, :autotiles #--------------------------------------------------------------------------- # * Object Initialization #--------------------------------------------------------------------------- def initialize(viewport) @viewport = viewport @sprite_compact = false#LiTTleDRAgo::SPRITE_COMPACT create_sprites create_carrot end #--------------------------------------------------------------------------- # * New method: create_sprites #--------------------------------------------------------------------------- def create_sprites 6.times do |i| layers[i] ||= [] (i % 6 == 0 ? 1 : height).times do |s| layers[i][s] = Sprite.new(@viewport) unless is_sprite?(layers[i][s]) end layers[i].each_with_index do |s,r| next unless is_sprite?(s) s.y = r * 32 * zoom_y s.z = (i % 6 == 0) ? 0 : (r * 32 + 32 + (i % 6) * 32) s.mirror = $game_map.reverse end end end #--------------------------------------------------------------------------- # * New method: create_carrot #--------------------------------------------------------------------------- def create_carrot @draw_tiles = carrot do |x,y,data,prio| [0,1,2].each do |r| if (id = data[x,y,r]).to_i == 0 || (layer = prio[id]).nil? next elsif @layer_clear && @layer_clear.not.include?(layer) @bitmap_layers[layer].fill_rect(x*32,y*32,32,32,Color.erase) @layer_clear.push(layer) end refresh_tiles(x,y,r,id) end end @change_tone = carrot {|s| all_sprites.tone = (@tone = s) } @change_opacity = carrot {|s| all_sprites.opacity = (@opacity = s)} @change_autotile_hue = carrot do |a,old,hue| [old.to_i != 0 && a.hue_change((old - 360).abs)] && a.hue_change(hue) end end #--------------------------------------------------------------------------- # * New method: ox=, oy=, zoom_x=, zoom_y= #--------------------------------------------------------------------------- [:ox, :oy, :zoom_x, :zoom_y].each do |a| meth = "def %1$s=(%1$s) (@%1$s != %1$s) && (@%1$s = %1$s) && %2$s end" module_eval(sprintf(meth, a ,'adjust_sprites')) end #--------------------------------------------------------------------------- # * New method: tone= #--------------------------------------------------------------------------- def tone=(*tone) new_tone = tone.flatten.size == 4 ? Tone.new(*tone.flatten) : tone.first.is_a?(Tone) ? tone.first : nil @tone.to_s == new_tone.to_s || @change_tone.call(new_tone.clone) end #--------------------------------------------------------------------------- # * New method: opacity= #--------------------------------------------------------------------------- def opacity=(opacity) opacity = [[opacity.round,255].min,0].max @opacity == opacity || @change_opacity.call(opacity) end #--------------------------------------------------------------------------- # * New method: hue= #--------------------------------------------------------------------------- def hue=(hue) return if @hue == (hue % 360) old = self.hue @hue = hue % 360 all_autotiles = @autotiles + extra_map_data.map {|m| m[:autotiles]}.flatten @change_autotile_hue.call(all_autotiles.uniq, old, @hue) refresh end #--------------------------------------------------------------------------- # * New method: Adjust Sprites #--------------------------------------------------------------------------- def adjust_sprites @times_compact ||= [] @layers_used && @layers.size.times do |i| layer = @layers[i] (i % 6 == 0 ? 1 : height).times do |r| sprite = layer[r] d = 32 _r = 32 + (i % 6) * 32 _y = r * 32 * zoom_y _z = i % 6 == 0 ? 0 : r * d + _r # (r * d + _r) unless is_sprite?(sprite) change = _y <= @viewport.height if @sprite_compact change &&= !char_out_range?(_r, (height-1)*d+_r) change &&= @layers_used[i] > 0 end change || next sprite = (layer[r] = Sprite.new(@viewport)) sprite.bitmap = bitmap_layers[i] sprite.tone = tone if tone sprite.opacity = opacity sprite.mirror = $game_map.reverse sprite.zoom_x, sprite.zoom_y = zoom_x, zoom_y else change = _y > @viewport.height if (@times_compact[i] ||= 0) < 10 && @sprite_compact change ||= (r > 0 && char_out_range?(_r, (height-1)*d+_r)) change ||= (r > 0 && @layers_used[i] == 0) end sprite.y, sprite.z = _y, _z.ceil change && [sprite.dispose, @times_compact[i] += 1] && next end sprite.y, sprite.z = _y, _z.ceil _wd = @viewport.width/zoom_x _ox = sprite.mirror ? (sprite.bitmap.width-ox)-_wd : (_wd+=10) && ox if layer.select { |s| is_sprite?(s) }.size == 1 sprite.src_rect.set(_ox, oy, _wd, @viewport.height/zoom_x + 10) else sprite.src_rect.set(_ox, (oy + r*32), _wd, 33) end sprite.zoom_x, sprite.zoom_y = zoom_x, zoom_y end end end #--------------------------------------------------------------------------- # * New method: char_out_range? #--------------------------------------------------------------------------- def char_out_range?(z1,z2) return false unless (s = $game_map.spriteset).is_a?(Spriteset_Map) s.character_sprites.all? do |d| d.not.disposed? && d.opacity > 0 && d.visible && (d.z).not.between?(z1,z2) end end #--------------------------------------------------------------------------- # * New method: Frame Dispose #--------------------------------------------------------------------------- def dispose all_sprites.each { |s| s.dispose } bitmap = bitmap_layers bitmap += extra_map_data.map {|m| m[:autotiles]}.flatten - @autotiles bitmap += extra_map_data.map {|m| m[:tileset]}.flatten bitmap.compact.each { |s| s.disposed? || s.dispose } @layers.clear GC.start end #--------------------------------------------------------------------------- # * New method: Change Map Data #--------------------------------------------------------------------------- def map_data=(data) return if @map_data == data @map_data = data @map_data_reverse = data.reverse(true,false,false) 6.times do |i| bitmap_layers[i].dispose if bitmap_layers[i] && bitmap_layers[i].disposed? bitmap_layers[i] = Bitmap.new($game_map.width*32,$game_map.height*32) layers[i].each { |s| is_sprite?(s) && s.bitmap = bitmap_layers[i] } end refresh end #--------------------------------------------------------------------------- # * New method: Map Data #--------------------------------------------------------------------------- def map_data $game_map.reverse ? @map_data_reverse : @map_data end #--------------------------------------------------------------------------- # * New method: Change priorities #--------------------------------------------------------------------------- def priorities=(priorities) return if @priorities == priorities @priorities = priorities refresh end #--------------------------------------------------------------------------- # * New method: Frame Refresh #--------------------------------------------------------------------------- def refresh return unless @priorities && @map_data LiTTleDRAgo.cache.clear_tile_cache @animated_tiles = [] @unrefreshed_tile = [] @layers_used = [] 7.times do |i| @total_frames = [] if i == 0 @current_frame = [] if i == 0 bm = (@current_frame[i] = @layers_used[i] = 0) && autotiles[i] bm.nil? && @total_frames[i] = 1 bm.nil? || @total_frames[i] = bm.width / (bm.height > 32 ? 256 : 32) extra_map_data.each do |data| data[:total_frames] = [] if i == 0 data[:current_frame] = [] if i == 0 bm = (data[:current_frame][i] = 0) && data[:autotiles][i] bm.nil? && data[:total_frames][i] = 1 bm.nil? || data[:total_frames][i] = bm.width / (bm.height>32 ? 256 : 32) end end _w = @viewport.width _h = @viewport.height layers[0][0].src_rect.set(ox, oy, _w/zoom_x, _h/zoom_y ) (0...map_data.xsize).each do |x| (0...map_data.ysize).each do |y| if in_range?(x,y) update_map_changes(x,y) else next if @unrefreshed_tile.include?([x,y]) @unrefreshed_tile.push([x,y]) @unrefreshed_tile.uniq! end end end adjust_sprites end #--------------------------------------------------------------------------- # * New method: Refresh Tiles #--------------------------------------------------------------------------- def refresh_tiles(x,y,z,i,d = nil) return if i.nil? || i == 0 i < 384 ? refresh_autotile(x,y,z,i,d) : refresh_regular_tile(x,y,z,i,d) end #--------------------------------------------------------------------------- # * New method: Refresh Autotile #--------------------------------------------------------------------------- def refresh_autotile(x,y,z,id,data) layer = data.nil? ? @priorities[id] : data[:priorities][id] tframe = data.nil? ? @total_frames : data[:total_frames] cframe = data.nil? ? @current_frame : data[:current_frame] bitmap = data.nil? ? @autotiles.at(id/48-1) : data[:autotiles].at(id/48-1) return if bitmap.nil? || layer.nil? div = (fid = id / 48 - 1) &&(id % 48) if @animated_tiles.not.include?([x,y]) && tframe[fid] > 1 @animated_tiles.push([x,y]) @animated_tiles.uniq! end rect = Rect.new((div % 8)*32 + cframe[fid] * 256, (div / 8)*32, 32, 32) bitmap_layers[layer].blt(x*32, y*32, bitmap, rect) @layers_used[layer] = [(@layers_used[layer] + 1) % 10000,1].max end #--------------------------------------------------------------------------- # * New method: Refresh Regular Tile #--------------------------------------------------------------------------- def refresh_regular_tile(x,y,z,id,data) tileset = data.nil? ? @tileset : data[:tileset] layer = data.nil? ? @priorities[id] : data[:priorities][id] return if layer.nil? || tileset.not.is_a?(Bitmap) bitmap = LiTTleDRAgo.cache.format_tile(tileset, id, hue) bitmap_layers[layer].blt(x*32, y*32, bitmap, Rect.new(0, 0, 32, 32)) @layers_used[layer] = [(@layers_used[layer] + 1) % 10000, 1].max end #--------------------------------------------------------------------------- # * New method: force_refresh #--------------------------------------------------------------------------- def force_refresh refresh (@unrefreshed_tile ||= []).each {|x,y| update_map_changes(x,y)} (@unrefreshed_tile.clear) end #--------------------------------------------------------------------------- # * New method: Frame Update #--------------------------------------------------------------------------- def update update_map_data update_autotile update_unrefreshed_tile end #--------------------------------------------------------------------------- # * New method: Update Unrefreshed Tile #--------------------------------------------------------------------------- def update_unrefreshed_tile if @unrefreshed_tile && @unrefreshed_tile.not.empty? unrefreshed = @unrefreshed_tile.select { |x,y| in_range?(x,y) } if unrefreshed.not.empty? (unrefreshed).each {|x,y| update_map_changes(x,y)} (@unrefreshed_tile -= unrefreshed) && adjust_sprites end end end #--------------------------------------------------------------------------- # * New method: Update Map Data #--------------------------------------------------------------------------- def update_map_data if map_data.table_changes.not.empty? map_data.table_changes.each do|item| x,y,z,tile_id = item update_map_changes(x,y) end map_data.table_changes.clear map_data.make_changes = false adjust_sprites end end #--------------------------------------------------------------------------- # * New method: Update the autotile #--------------------------------------------------------------------------- def update_autotile return if $game_map.screen_is_solid? speed = $game_map.autotile_speed total = [(@autotile_total || 0) / 10, 0].max if speed > 0 && Graphics.frame_count % (speed + total) == 0 7.times do |i| extra_map_data.each do |data| next if (total = data[:total_frames].at(i)) == 0 data[:current_frame][i] = (data[:current_frame].at(i) + 1) % total end next if (total = @total_frames.at(i)) == 0 @current_frame[i] = (@current_frame.at(i) + 1) % total end animated = @animated_tiles.select { |x,y| in_range?(x,y) } animated.each {|x,y| update_map_changes(x,y) } @autotile_total = animated.size end end #--------------------------------------------------------------------------- # * New method: in_range? #--------------------------------------------------------------------------- def in_range?(x=nil,y=nil) return false if layers[0].nil? || layers[0][0].nil? rect = @layers[0][0].src_rect _x = x && (x * 32).between?(rect.x-32, rect.x + rect.width) _y = y && (y * 32).between?(rect.y-32, rect.y + rect.height) return _x && _y if x && y return _x if x return _y if y return false end #--------------------------------------------------------------------------- # * New method: Update Map Changes #--------------------------------------------------------------------------- def update_map_changes(x,y) @layer_clear ||= [] @layer_clear.clear draw = [[x,y,map_data,priorities]] draw += extra_map_data.map {|data|[x,y,data[:map].data,data[:priorities]]} draw.each {|data| @draw_tiles.call(*data)} end end #============================================================================== # ** Game_Character #------------------------------------------------------------------------------ # This class deals with characters. It's used as a superclass for the # determinants and map scrolling. Refer to "$game_player" for the one # Game_Player and Game_Event classes. #============================================================================== class Game_Character #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias_sec_method(:screen_x_before_zoom, :screen_x) alias_sec_method(:screen_y_before_zoom, :screen_y) alias_sec_method(:screen_z_before_zoom, :screen_z) #-------------------------------------------------------------------------- # * Aliased method: screen_x #-------------------------------------------------------------------------- def screen_x(*args) screen_x_before_zoom(*args) * $game_map.zoom_x end #-------------------------------------------------------------------------- # * Aliased method: screen_y #-------------------------------------------------------------------------- def screen_y(*args) screen_y_before_zoom(*args) * $game_map.zoom_y end #-------------------------------------------------------------------------- # * Aliased method: screen_z #-------------------------------------------------------------------------- def screen_z(*args) if self.is_a?(Game_Event) return 999 if @always_on_top return $1.to_i if self.name[/\/i] return screen_z_tilemap_fix if screen_z_tilemap_fix.is_a?(Integer) end return screen_z_before_zoom(*args) end #-------------------------------------------------------------------------- # * New method: screen_z_tilemap_fix #-------------------------------------------------------------------------- def screen_z_tilemap_fix LiTTleDRAgo::CHARACTER_Z_FIX.each do |key,value| if value.is_a?(Array) && key.is_a?(Integer) return key if value.any?{|v|"#{v}".downcase == @character_name.downcase} elsif key.is_a?(Array) && value.is_a?(Integer) return value if key.any?{|v|"#{v}".downcase == @character_name.downcase} elsif (key.is_a?(String) || key.is_a?(Symbol)) && value.is_a?(Integer) return value if "#{key}".downcase == @character_name.downcase end end return nil end end #============================================================================== # ** Sprite_Character #------------------------------------------------------------------------------ # This sprite is used to display the character.It observes the Game_Character # class and automatically changes sprite conditions. #============================================================================== class Sprite_Character #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- alias_sec_method(:zoom_update_scrolling, :update) #-------------------------------------------------------------------------- # * Aliased method: update #-------------------------------------------------------------------------- def update(*args) if @old_character_zoom_x self.zoom_x = @old_character_zoom_x self.zoom_y = @old_character_zoom_y end zoom_update_scrolling(*args) @old_character_zoom_x = self.zoom_x @old_character_zoom_y = self.zoom_y self.zoom_x *= $game_map.zoom_x self.zoom_y *= $game_map.zoom_y end #-------------------------------------------------------------------------- # * New method: in_range? #-------------------------------------------------------------------------- unless method_defined?(:in_range?) def in_range? cw = self.src_rect ? self.src_rect.width : 32 ch = self.src_rect ? self.src_rect.height : 32 return @character.screen_x.round.between?(self.viewport.x - cw, self.viewport.x + self.viewport.width) && @character.screen_y.round.between?(self.viewport.y - ch, self.viewport.y + self.viewport.height) end end end #============================================================================== # ** Spriteset_Map #------------------------------------------------------------------------------ # This class brings together map screen sprites, tilemaps, etc. # It's used within the Scene_Map class. #============================================================================== class Spriteset_Map #--------------------------------------------------------------------------- # * Public Instance Variables #--------------------------------------------------------------------------- attr_reader :character_sprites, :tilemap attr_reader :viewport1, :viewport2, :viewport3 #-------------------------------------------------------------------------- # * Alias Listing #-------------------------------------------------------------------------- $@ || alias_method(:init_drgcr_tilemap, :initialize) alias_sec_method(:update_drgcr_tilemap, :update) #-------------------------------------------------------------------------- # * Aliased method: initialize #-------------------------------------------------------------------------- def initialize(*args) check_autotile_height init_drgcr_tilemap(*args) end #--------------------------------------------------------------------------- # * New method: check_autotile_height #--------------------------------------------------------------------------- def check_autotile_height return unless LiTTleDRAgo::XP $game_map.autotile_names.each do |autotile_name| bitmap = ModCache.autotile(autotile_name) [@force_tilemap_enabled = true] && break if bitmap.height == 192 end end #-------------------------------------------------------------------------- # * Aliased method: update #-------------------------------------------------------------------------- def update(*args) adjust_viewport adjust_tilemap adjust_old_zoom update_drgcr_tilemap(*args) update_tilemap_zoom end #--------------------------------------------------------------------------- # * New method: adjust_old_zoom #--------------------------------------------------------------------------- def adjust_old_zoom if @old_fog_zoom_x @fog.zoom_x = @old_fog_zoom_x @fog.zoom_y = @old_fog_zoom_y @panorama.zoom_x = @old_panorama_zoom_x @panorama.zoom_y = @old_panorama_zoom_y end end #--------------------------------------------------------------------------- # * New method: viewport_sprite #--------------------------------------------------------------------------- def viewport_sprite(*v) v.collect! {|s| s.is_a?(Symbol) ? instance_variable_get(:"@#{s}") : s } v.reject! {|s| s.not.is_a?(Viewport)} all = instance_variables.map {|s| instance_variable_get("#{s}")}.flatten all.select {|s| s.respond_to?(:viewport) && v.include?(s.viewport)} end #--------------------------------------------------------------------------- # * New method: change_tilemap_tone #--------------------------------------------------------------------------- def change_tilemap_tone(tone = Tone.new(0,0,0,0), *char) if tone.is_a?(Array) && (3..4) === tone.size result = $game_map.tilemap_tone = Tone.new(*tone) elsif tone.is_a?(Tone) result = $game_map.tilemap_tone = tone else return end sprite = viewport_sprite(:viewport1) sprite.reject! {|s| s.is_a?(Sprite_Character)} sprite.each {|s| s.tone = result if s.respond_to?(:tone=) } change_character_tone(tone, *char) unless char.empty? end #--------------------------------------------------------------------------- # * New method: change_character_tone #--------------------------------------------------------------------------- def change_character_tone(tone = Tone.new(0,0,0,0), *char) char = char.collect {|c| c.is_a?(Range) ? c.to_a : c}.flatten char = char.collect {|c| c.is_a?(Range) ? c.to_a : c}.flatten char.collect! {|c| c.is_a?(Game_Character) ? c : $game_map.interpreter.get_character(c)} sprite = viewport_sprite(:viewport1) sprite.reject! {|s| s.not.is_a?(Sprite_Character) } sprite.reject! {|s| char.not.include?(s.character)} if tone.is_a?(Array) && (3..4) === tone.size sprite.tone(:tone=, Tone.new(*tone)) elsif tone.is_a?(Tone) sprite.send(:tone=, tone) end end #-------------------------------------------------------------------------- # * New method: reload_tilemap #-------------------------------------------------------------------------- def reload_tilemap return [dispose_tilemap, create_tilemap] if LiTTleDRAgo::VXA @tilemap.respond_to?(:dispose) && @tilemap.dispose 7.times do |i| auto = @tilemap.autotiles[i] auto.respond_to?(:dispose) && (auto.disposed? || auto.dispose) end res = tilemap_enabled? ? ZTilemap : Tilemap @tilemap = res.new(@viewport1) @tilemap.tileset = ModCache.tileset($game_map.tileset_name) 7.times do |i| autotile_name = $game_map.autotile_names[i] @tilemap.autotiles[i] = @tilemap.is_a?(ZTilemap) ? ModCache.autotile_cr_tilemap(autotile_name) : ModCache.autotile(autotile_name) end update_tilemap_effect @tilemap.priorities = $game_map.priorities @tilemap.map_data = $game_map.data @tilemap.update @viewport_screen_width = 0 end #-------------------------------------------------------------------------- # * New method: reload_plane #-------------------------------------------------------------------------- def reload_plane z1 = @panorama.respond_to?(:z) ? @panorama.z : -1000 z2 = @fog.respond_to?(:z) ? @fog.z : 5000 z1 /= 1000 if @panorama.is_a?(CRPlane) z2 /= 1000 if @fog.is_a?(CRPlane) res = plane_enabled? ? CRPlane : Plane bitmap1 = @panorama.respond_to?(:bitmap) ? @panorama.bitmap : nil bitmap2 = @fog.respond_to?(:bitmap) ? @fog.bitmap : nil @panorama.respond_to?(:dispose) && @panorama.dispose @fog.respond_to?(:dispose) && @fog.dispose @panorama = res.new(@viewport1) @fog = res.new(@viewport1) @panorama.bitmap = bitmap1 if bitmap1.is_a?(Bitmap) @fog.bitmap = bitmap2 if bitmap2.is_a?(Bitmap) @panorama.z, @fog.z = z1, z2 @viewport_screen_width = 0 end #-------------------------------------------------------------------------- # * New method: update_tilemap_zoom #-------------------------------------------------------------------------- def update_tilemap_zoom @weather.zoom_x = $game_map.zoom_x @weather.zoom_y = $game_map.zoom_y @old_fog_zoom_x = @fog.zoom_x @old_fog_zoom_y = @fog.zoom_y @old_panorama_zoom_x = @panorama.zoom_x @old_panorama_zoom_y = @panorama.zoom_y @fog.zoom_x *= $game_map.zoom_x @fog.zoom_y *= $game_map.zoom_y @panorama.zoom_x *= $game_map.zoom_x @panorama.zoom_y *= $game_map.zoom_y update_tilemap_effect end #-------------------------------------------------------------------------- # * New method: update_tilemap_effect #-------------------------------------------------------------------------- def update_tilemap_effect return if @tilemap.not.is_a?(ZTilemap) @tilemap.zoom_x = $game_map.zoom_x @tilemap.zoom_y = $game_map.zoom_y @tilemap.opacity = $game_map.tilemap_opacity @tilemap.hue = $game_map.tilemap_hue @tilemap.tone = $game_map.tilemap_tone end #-------------------------------------------------------------------------- # * Overwriten method: viewport_size_change? #-------------------------------------------------------------------------- def viewport_size_change? return true if @viewport_map_width != $game_map.width * $game_map.zoom_x return true if @viewport_map_height != $game_map.height * $game_map.zoom_y return true if @viewport_screen_width != Graphics.width return true if @viewport_screen_height != Graphics.height end #-------------------------------------------------------------------------- # * New method: adjust_viewport #-------------------------------------------------------------------------- def adjust_viewport if viewport_size_change? @viewport_map_width = $game_map.width * $game_map.zoom_x @viewport_map_height = $game_map.height * $game_map.zoom_y @viewport_screen_width = Graphics.width @viewport_screen_height = Graphics.height [@viewport1,@viewport2,@viewport3].compact.update_viewport_sizes end end #-------------------------------------------------------------------------- # * New method: adjust_tilemap #-------------------------------------------------------------------------- def adjust_tilemap if LiTTleDRAgo::XP if tilemap_enabled? reload_tilemap if @tilemap.is_a?(Tilemap) else reload_tilemap if @tilemap.is_a?(ZTilemap) end end if plane_enabled? reload_plane if @panorama.is_a?(Plane) || @fog.is_a?(Plane) else reload_plane if @panorama.is_a?(CRPlane) || @fog.is_a?(CRPlane) end end #-------------------------------------------------------------------------- # * New method: tilemap_enabled? #-------------------------------------------------------------------------- def tilemap_enabled? return true if @force_tilemap_enabled return true unless LiTTleDRAgo::RGSS1 return true unless @viewport1.width <= 640 && @viewport1.height <= 480 return true unless (map = $game_map) && map.zoom_x * map.zoom_y == 1 return true unless map.tilemap_opacity >= 255 return true unless map.tilemap_hue <= 0 return true unless map.tilemap_tone.to_s.get_int == 0 return true if map.reverse return false end #-------------------------------------------------------------------------- # * New method: plane_enabled? #-------------------------------------------------------------------------- def plane_enabled? return true unless LiTTleDRAgo::RGSS1 return true unless @viewport1.width <= 640 && @viewport1.height <= 480 return false end end