Ruby Source code

#==============================================================================
# ** Static Object
#------------------------------------------------------------------------------
#  Ein Sprite, der an einer Stelle einer bestimmten Map geladen wird (kann ein 
#  Tileset-Tile sein oder ein Picture) und dort verbleibt und manipuliert
#  (angle, opacity) werden kann
# Danke an Irrlicht, Playm und schM0ggi! Ohne euch, wär das nix geworden!
#==============================================================================
 
#==============================================================================
# ** Map_Objekt
#==============================================================================
class Map_Object
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_reader :map_x
  attr_reader :map_y
  attr_reader :anchor
  attr_reader :priority
  attr_reader :graphic
  attr_accessor :opacity
  attr_reader :angle
  attr_reader :hue
  attr_reader :tilestx
  attr_reader :tilesety
  attr_reader :tilewidth
  attr_reader :tileheight
  attr_reader :pic
 
  # - Erweiterte Methoden für die Map-Objekte (setup/set):
  #   Alle Methoden die die Position/Größe des Sprites verändern können, müssen
  #   nun auch die Objekt-Tabelle aktualisieren.
  #   Dazu gehört auch  set_graphic, da Objekte mit leerer Grafik wie
  #   "nicht vorhanden" behandelt werden können.
 
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    @map_x = 0
    @map_y = 0
    @anchor = :top_left
    @priority = 0
    @opacity = 255
    @angle = 0
    @hue = 0
    @graphic = ""
    @tilestx = 0 
    @tilesety = 0 
    @tilewidth = 0
    @tileheight = 0
    @pic = true
  end  
  #--------------------------------------------------------------------------
  # * Setup Picture
  # 
  #   mapx = Starttile des Bildes X
  #   mapy = Starttile des Bildes Y
  #   anchor = Startpunkt des Bildes (oben links, unten links)
  #   piority = Priority des Bildes (1-5, je nach Tilehöhe)
  #--------------------------------------------------------------------------
  def setup_pic( mapx, mapy, anchor, priority, pic=true )
    @map_x = mapx
    @map_y = mapy
    @anchor = anchor
    @priority = priority
    @pic = pic
  end
  alias_method(:setup_pic_aliased_for_objecttable, :setup_pic)
  def setup_pic(*args)
    setup_pic_aliased_for_objecttable(*args)
    update_object_table_placement
  end
  #--------------------------------------------------------------------------
  # * Setup Tileset
  # 
  #   mapx = Starttile des Bildes X
  #   mapy = Starttile des Bildes Y
  #   anchor = Startpunkt des Bildes (oben links, unten links)
  #   piority = Priority des Bildes (1-5, je nach Tilehöhe)
  #   tilesetx = Startpunkt des Ausschnitts im Tileset x (Pixel)
  #   tilesety = Startpunkt des Ausschnitts im Tileset y (Pixel)
  #   tilewidth = Wieviele Pixel breit
  #   tileheight = Wieviele Pixel hoch
  #--------------------------------------------------------------------------
  def setup_til( mapx, mapy, anchor, priority, tilestx, tilesety, tilewidth, tileheight, pic=false )
    @map_x = mapx
    @map_y = mapy
    @anchor = anchor
    @priority = priority
    @tilestx = tilestx
    @tilesety = tilesety
    @tilewidth = tilewidth
    @tileheight = tileheight
    @pic = pic
  end
  alias_method(:setup_til_aliased_for_objecttable, :setup_til)
  def setup_til(*args)
    setup_til_aliased_for_objecttable(*args)
    update_object_table_placement
  end 
  #--------------------------------------------------------------------------
  # * Set Graphic
  #
  #     name           :Name der Grafik (Tileset oder Picture)
  #--------------------------------------------------------------------------
  def set_graphic( name )
    @graphic = name
  end
  alias_method(:set_graphic_aliased_for_objecttable, :set_graphic)
  def set_graphic(*args)
    set_graphic_aliased_for_objecttable(*args)
    update_object_table_placement
  end
 
  #--------------------------------------------------------------------------
  # * Screen-Berechnung
  #--------------------------------------------------------------------------
  SCREEN_WIDTH = 640
  SCREEN_HEIGHT = 480
 
  #--------------------------------------------------------------------------
  # * Object_Table
  #   Erlaubt das Zuweisen einer Objekt-Tabelle in die sich das Map-Objekt
  #   eintragen kann um das Aussortieren zu erleichtern.
  #--------------------------------------------------------------------------
  def object_table=(table)
    @object_table.remove(self)  if @object_table
    @object_table = table
    update_object_table_placement
  end
 
  #--------------------------------------------------------------------------
  # * Update_Object_Table_Placement
  #   update_object_table_placement dient dazu die Position des Map-Objekts
  #   in der Tabelle zu aktualisieren.
  #--------------------------------------------------------------------------
  def update_object_table_placement
    return  unless @object_table
    graphic.empty? ? @object_table.remove(self) : @object_table.place(self)
  end
 
  #--------------------------------------------------------------------------
  # * Bounds
  #   bounds fasst Position und Größe in einem Rechteck zusammen. Dieses
  #   bestimmt wann ein Objekt als "im Bildschirmbereich" erkannt wird.
  #--------------------------------------------------------------------------
  def bounds
    return Rect.new(start_x, start_y, tilewidth, tileheight)
  end
 
  #--------------------------------------------------------------------------
  # * Start_X
  #   start_x  und  start_y  bestimmen die Position des oberen linken Pixels
  #   des Objekts auf der Map. Muss bei Bedarf angepasst werden.
  #--------------------------------------------------------------------------
  def start_x
    # X-Koordinate des linken Objektrandes in Pixeln:
    return map_x * 32
  end
 
  #--------------------------------------------------------------------------
  # * Start_Y
  #   start_x  und  start_y  bestimmen die Position des oberen linken Pixels
  #   des Objekts auf der Map. Muss bei Bedarf angepasst werden.
  #-------------------------------------------------------------------------- 
  def start_y
    # Y-Koordinate des oberen Objektrandes in Pixeln:
    if anchor == :top_left
      return map_y * 32
    else
      return map_y * 32 - tileheight + 32
    end
  end
 
  #--------------------------------------------------------------------------
  # * Screen_Visible?
  #-------------------------------------------------------------------------- 
  def screen_visible?
    # Ist der Sprite auf dem Bildschirm sichtbar?
    return false  if graphic.empty?
    screen_x = start_x - ($game_map.display_x + 3) / 4
    return false  if screen_x >= SCREEN_WIDTH || (screen_x + tilewidth) <= 0
    screen_y = start_y - ($game_map.display_y + 3) / 4
    return false  if screen_y >= SCREEN_HEIGHT || (screen_y + tileheight) <= 0
    return true
  end  
end
 
#==============================================================================
# ** Game_Map
#==============================================================================
class Game_Map
  #--------------------------------------------------------------------------
  # * Static_Object
  #   Wenn ein neues Map-Objekt erstellt wird wird ihm nun auch die
  #   Objekt-Tabelle zugewiesen in die es sich eintragen kann.
  #-------------------------------------------------------------------------- 
  def static_object
    # wenn beim ersten Aufruf von $game_map.static_object der Array noch nicht
    # mit Werten gefüllt ist, fülle ihn erst mit Start-Werten auf
    if @static_object == nil
      @static_object = []
      for i in 0..2499
        @static_object[i] = Map_Object.new()
        @static_object[i].object_table = self.object_table
      end
    end
    # gib den Array zurück
    return @static_object 
  end
 
  #--------------------------------------------------------------------------
  # * Object_Table
  #   Die Map verwaltet nun neben dem Array mit Map-Objekten auch eine
  #   zugehörige Map-Objekt-Tabelle um Objekte schneller zu finden.
  #     @object_table ||= Map_Object_Table.new
  #   hat hier einen ähnlichen Effekt wie
  #     if !@object_table
  #       @object_table = Map_Object_Table.new
  #     end
  #   und erstellt die Tabelle sobald sie das erste Mal benötigt wird.
  #--------------------------------------------------------------------------
  def object_table
    @object_table ||= Map_Object_Table.new
  end
end
 
#==============================================================================
# ** Object_Sprite
#==============================================================================
class Object_Sprite < Sprite
  attr_reader :already_tilted
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(viewport, map_object)
    super(viewport)
    @object = map_object
    @already_tilted = false   
    if @object.opacity < 255
      self.opacity = 100
    end
    update
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
 
  #--------------------------------------------------------------------------
  # Methode Abbrechen, wenn Grafik leer
  #--------------------------------------------------------------------------
   if @object.graphic == "" || $game_switches[16] == false
    self.bitmap = nil
    return  # <- Brich die Methode an dieser Stelle ab
   end
 
  #--------------------------------------------------------------------------
  # Werte festlegen und errechnen
  #--------------------------------------------------------------------------
    @graphic_name = @object.graphic
    @tilestx = @object.tilestx
    @tilesety = @object.tilesety
    @tilewidth = @object.tilewidth
    @tileheight = @object.tileheight
    self.angle = @object.angle
    opacity = @object.opacity
    map_x = @object.map_x
    map_y = @object.map_y
    map_y2 = @object.map_y -1
    map_z = @object.priority
    middlewidth = @tilewidth / 2
    wert_für_mid = @tilewidth / 32
#    tile_ox = map_x+(middlewidth/32)
 
  #--------------------------------------------------------------------------
  # Opacity; wenn der Spieler unter dem Sprite ist 
  # (nur Bäume und Dächer [top_left)
  #--------------------------------------------------------------------------
    if @object.anchor == :top_left
      if $game_player.x >= map_x && $game_player.x <= map_x + (@tilewidth / 32) - 1 &&
       $game_player.y >= map_y && $game_player.y <= map_y2 + (@tileheight / 32) - 1
       opacity = 100
       @object.opacity = opacity
     else
       opacity = 255
       @object.opacity = opacity
      end    
    end  
 
  #--------------------------------------------------------------------------
  # Opacity; wenn die Opacity sich ändert  
  #--------------------------------------------------------------------------
    if self.opacity > @object.opacity
      self.opacity -= 10
    end
    if self.opacity < @object.opacity
      self.opacity += 10
    end
 
  #--------------------------------------------------------------------------
  # Setup; je nachdem welches Setup gewählt wurde
  #--------------------------------------------------------------------------
      if @graphic_name != ""
        if @object.pic == true
          self.bitmap = RPG::Cache.picture(@graphic_name)
        elsif @object.pic == false
          self.bitmap = RPG::Cache.tileset( @graphic_name )
          self.src_rect.set( @tilestx, @tilesety, @tilewidth, @tileheight)
        end
      else
        self.bitmap = nil
      end
 
  #--------------------------------------------------------------------------
  # Anchor; je nachdem welcher anchor gewählt wurde
  #--------------------------------------------------------------------------
    if @object.anchor == :top_left # Bäume, Dächer
      self.x = (map_x * 128 - $game_map.display_x + 3) / 4 
      self.y = (map_y * 128 - $game_map.display_y + 3) / 4     
    elsif @object.anchor == :bottom_left # ?
      self.ox = self.src_rect.width / 2
      self.x = ((map_x * 128 - $game_map.display_x + 3) / 4) + middlewidth 
      self.oy = self.src_rect.height
      self.y = ((map_y * 128 - $game_map.display_y + 3) / 4) -@tileheight + 32 + self.src_rect.height
    elsif @object.anchor == :bottom_mid # Gras + Feldfrüchte
      self.ox = self.src_rect.width / 2 
      a = self.ox/wert_für_mid
      self.x = ((map_x * 128 - $game_map.display_x + 3) / 4) + a
      self.oy = self.src_rect.height
      self.y = ((map_y * 128 - $game_map.display_y + 3) / 4) -@tileheight + 32 + self.src_rect.height
      $game_variables[21] = map_x
      $game_variables[22] = map_y  
      $game_variables[23] = self.x  
      $game_variables[24] = self.y 
    end
 
  #--------------------------------------------------------------------------
  # Priority, je nachdem welche Priority gewählt wurde
  #--------------------------------------------------------------------------
    if map_z == 0
      self.z = self.y + 16 
    elsif map_z == 1
      self.z = self.y + 16 +32
    elsif map_z == 2
      self.z = self.y + 16 +64
    elsif map_z == 3
      self.z = self.y + 16 +96
    elsif map_z == 4
      self.z = self.y + 16 +128
    elsif map_z == 5
      self.z = self.y + 16 +160
    elsif map_z == 6
      self.z = self.y + 16 +192
    end
 
 #--------------------------------------------------------------------------
 # Tilt; wenn getiltet wird (nur Gras und Feldfrüchte [bottom_left, bottom_mid]
 #--------------------------------------------------------------------------
#   if @object.anchor == :bottom_left
#    if @tilt_frames and not @tilt_frames.empty?
#      self.angle = @tilt_frames.shift
#      self.angle += 360 while self.angle < 0
#      self.angle %= 360
#    else
#      if !@already_tilted && $game_player.x == tile_ox && $game_player.y == map_y
#        @already_tilted = true  # <- Für das nächste Update speichern dass der Sprite schon getiltet wurde
#        case $game_player.direction
#          when 2 then self.tilt_left 
#          when 4 then self.tilt_left 
#          when 6 then self.tilt_right
#          when 8 then self.tilt_right
#      	end
#      end
#    end
#    if @already_tilted && ($game_player.x != tile_ox || $game_player.y != map_y)
#      @already_tilted = false  # <- Wenn der Spieler das Feld (wieder) verlassen hat setze die Variable zurück.
#    end    
#   end 
 
   if @object.anchor == :bottom_mid || @object.anchor == :bottom_left
    if @tilt_frames and not @tilt_frames.empty?
      self.angle = @tilt_frames.shift
      self.angle += 360 while self.angle < 0
      self.angle %= 360
    else
      if !@already_tilted && $game_player.x == map_x && $game_player.y == map_y
        @already_tilted = true  # <- Für das nächste Update speichern dass der Sprite schon getiltet wurde
        case $game_player.direction
          when 2 then self.tilt_left 
          when 4 then self.tilt_left 
          when 6 then self.tilt_right
          when 8 then self.tilt_right
      	end
      end
    end
    if @already_tilted && ($game_player.x != map_x || $game_player.y != map_y)
      @already_tilted = false  # <- Wenn der Spieler das Feld (wieder) verlassen hat setze die Variable zurück.
    end    
   end 
  end #def
 
  #--------------------------------------------------------------------------
  # * Tilt_Definition
  #--------------------------------------------------------------------------
  def tilt_left
    @tilt_frames = [5,10,20,15,10,5,0,-5,-10,0]
  end
  def tilt_right
    @tilt_frames = [-5,-10,-20,-15,-10,-5,0,5,10,0]
  end    
end
 
#==============================================================================
# ** Spriteset_Map
#==============================================================================
class Spriteset_Map
  attr_accessor :map_object_sprites
  attr_reader    :viewport1
  alias_method( :aliased_initialize_method, :initialize )
  alias_method( :aliased_update_method, :update )
  alias_method( :aliased_dispose_method, :dispose )
  # - Geänderte Spriteset-Methoden:
  #   Die bereits geänderten Methoden im Spriteset wurden nocheinmal 
  #   überarbeitet. Die Map-Objekt-Sprites werden nun in einem eigenen
  #   Spriteset verwaltet. (Dieser Schritt ist nicht unbedingt notwendig, 
  #   das was nun Spriteset_MapObjects tut könnte man auch in die
  #   Spriteset_Map - Klasse integrieren)
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------  
  def initialize
    aliased_initialize_method
    @map_objects = Spriteset_MapObjects.new(@viewport1)
  end
  #--------------------------------------------------------------------------
  # * Dispose
  #-------------------------------------------------------------------------- 
  def dispose
    aliased_dispose_method
    @map_objects.dispose  if @map_objects
  end
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    aliased_update_method
    @map_objects.update  if @map_objects
  end
end
 
#==============================================================================
# ** Interpreter
#==============================================================================
class Interpreter  
  #--------------------------------------------------------------------------
  # * change_opacity
  #     id             :ID des objektes
  #     wert           :Opacity-Wert
  #--------------------------------------------------------------------------
  def change_opacity(id, wert)
    static_object = $game_map.static_object
    if static_object[id].opacity != wert
    static_object[id].opacity = wert  
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * tilt_character
  #     id             :ID des objektes
  #     dir            :Richtung des tiltens
  #--------------------------------------------------------------------------
  def tilt_character(id, dir='left')
#print("tilt_character ", id, ", ", dir)    
    char = get_character(id)
    if char
      spriteset = $scene.instance_variable_get(:@spriteset)
      map_object_sprites = spriteset.instance_variable_get(:@map_object_sprites)
      sprite = map_object_sprites[ id ]
 
      	case $game_player.direction
        	when 2 then sprite.tilt_left
        	when 4 then sprite.tilt_left
        	when 6 then sprite.tilt_right
        	when 8 then sprite.tilt_right
      	end
    end
    return true
  end
 
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias_method( :aliased_update_method, :update )
  def update
    aliased_update_method
  end  
end
 
#==============================================================================
# ** Scene_Map
#==============================================================================
class Scene_Map
  attr_reader :spriteset
end 
 
#==============================================================================
# ** Map_Object_Table
#   Diese Klasse bietet Methoden für ein (hoffentlich) schnelleres Auswählen
#   der Map-Objekte in einem beliebigen Kartenausschnitt
#==============================================================================
class Map_Object_Table
 
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(section_size = 128)
    @sections = []
    @object_bounds = {}
    @section_size = section_size
    @mod_count = 0
  end
 
  #--------------------------------------------------------------------------
  # * On_Change
  #--------------------------------------------------------------------------
  def on_change
    @mod_count += 1
  end
 
  #--------------------------------------------------------------------------
  # * Iterate_Sektions
  #--------------------------------------------------------------------------
  def iterate_sections(rect)
    sx1 = rect.x / @section_size
    sx2 = (rect.x + rect.width - 1) / @section_size
    sy1 = rect.y / @section_size
    sy2 = (rect.y + rect.height - 1) / @section_size
    sx1.upto(sx2) { |sx|
      sy1.upto(sy2) { |sy|
        @sections[sx] ||= []
        @sections[sx][sy] ||= []
        yield @sections[sx][sy]
      }
    }
  end
 
  #--------------------------------------------------------------------------
  # * Addet_Objects_In_Slice
  #--------------------------------------------------------------------------
  def added_objects_in_slice(slice, rest)
    return objects_in_area(slice).select { |object|
        !@object_bounds[object].overlap?(rest)
    }
  end
 
  #--------------------------------------------------------------------------
  # * Version
  #--------------------------------------------------------------------------
  def version
    return @mod_count
  end
 
  #--------------------------------------------------------------------------
  # * Clear
  #--------------------------------------------------------------------------
  def clear
    return  if @object_bounds.empty?
    @sections.clear
    @object_bounds.clear
    on_change
  end
 
  #--------------------------------------------------------------------------
  # * Place
  #   Die Methoden  place / remove  aktualisieren die Position eines
  #   Objekts oder löschen es aus der Tabelle.
  #--------------------------------------------------------------------------
  def place(object)
    remove(object)
    bounds_rect = object.bounds
    return  unless bounds_rect
    @object_bounds[object] = bounds_rect
    iterate_sections(bounds_rect) { |section|
      section.push(object)
    }
    on_change
  end
 
  #--------------------------------------------------------------------------
  # * Remove
  #   Die Methoden  place / remove  aktualisieren die Position eines
  #   Objekts oder löschen es aus der Tabelle.
  #--------------------------------------------------------------------------
  def remove(object)
    bounds_rect = @object_bounds[object]
    return  unless bounds_rect
    @object_bounds.delete(object)
    iterate_sections(bounds_rect) { |section|
      section.delete(object)
    }
    on_change
  end
 
  #--------------------------------------------------------------------------
  # * Objects_In_Area
  #   Mit  objects_in_area  können alle Objekte erfasst werden die sich etwa
  #   im Bildschirmbereich befinden.
  #--------------------------------------------------------------------------
  def objects_in_area(rect)
    result = []
    iterate_sections(rect) { |section| result.concat(section) }
    return result.uniq.select { |object| @object_bounds[object].overlap?(rect) }
  end
 
  #--------------------------------------------------------------------------
  # * Exclusive_Objects
  #   Mit  exclusive_objects  können alle Objekte erfasst werden die in einem
  #   Bereich neu hinzugekommen/verschwunden sind wenn sich der 
  #   Bildschirmbereich nur wenig bewegt hat.
  #--------------------------------------------------------------------------
  def exclusive_objects(new_rect, old_rect)
    if !old_rect || !new_rect.overlap?(old_rect)
      return objects_in_area(new_rect)
    else
      result = []
      rest = new_rect
      if rest.x < old_rect.x
        left_slice, rest = rest.cut_horizontally(old_rect.x)
        result.concat(added_objects_in_slice(left_slice, rest))
      end
      if rest.end_x > old_rect.end_x
        rest, right_slice = rest.cut_horizontally(old_rect.end_x)
        result.concat(added_objects_in_slice(right_slice, rest))
      end
      if rest.y < old_rect.y
        top_slice, rest = rest.cut_vertically(old_rect.y)
        result.concat(added_objects_in_slice(top_slice, rest))
      end
      if rest.end_y > old_rect.end_y
        rest, bottom_slice = rest.cut_vertically(old_rect.end_y)
        result.concat(added_objects_in_slice(bottom_slice, rest))
      end
      return result
    end
  end
end
 
#==============================================================================
# ** Spriteset_MapObjects
#   Diese Klasse übernimmt die Funktion von Spriteset_Map wenn es um das
#   Verwalten der Object-Sprites geht.
#==============================================================================
class Spriteset_MapObjects
 
  #--------------------------------------------------------------------------
  # * Initialze
  #--------------------------------------------------------------------------  
  def initialize(viewport)
    @viewport = viewport
    @sprites = {}
    refresh_object_sprites
  end
 
  #--------------------------------------------------------------------------
  # * Object_Table
  #--------------------------------------------------------------------------  
  def object_table
    $game_map.object_table
  end
 
  #--------------------------------------------------------------------------
  # * Visible_Area
  #--------------------------------------------------------------------------  
  def visible_area
    x = $game_map.display_x / 4 - (@viewport ? @viewport.ox : 0)
    y = $game_map.display_y / 4 - (@viewport ? @viewport.oy : 0)
    w = @viewport ? @viewport.rect.width : 640
    h = @viewport ? @viewport.rect.height : 480
    return Rect.new(x, y, w, h)
  end
 
  #--------------------------------------------------------------------------
  # * Refresh_Object_Sprites
  #--------------------------------------------------------------------------  
  def refresh_object_sprites
    if @last_version != object_table.version
      @last_version = object_table.version
      @last_area = visible_area
      dispose_sprites(@sprites.keys)
      create_sprites(object_table.objects_in_area(@last_area))
    elsif @last_area != visible_area
      new_area = visible_area
      dispose_sprites(object_table.exclusive_objects(@last_area, new_area))
      create_sprites(object_table.exclusive_objects(new_area, @last_area))
      @last_area = new_area
    end
  end
 
  #--------------------------------------------------------------------------
  # * Dispose_Sprites
  #--------------------------------------------------------------------------  
  def dispose_sprites(objects)
    objects.each { |object|
      @sprites[object].dispose  if @sprites[object]
      @sprites.delete(object)
    }
  end
 
  #--------------------------------------------------------------------------
  # * Create_Sprites
  #--------------------------------------------------------------------------  
  def create_sprites(objects)
    objects.each { |object|
      @sprites[object] ||= Object_Sprite.new(@viewport, object)
    }
  end
 
  #--------------------------------------------------------------------------
  # * Update
  #   update  aktualisiert alle sichtbaren Sprites (und erstellt/löscht)
  #--------------------------------------------------------------------------  
  def update
    refresh_object_sprites
    @sprites.each_value { |sprite| sprite.update }
  end
 
  #--------------------------------------------------------------------------
  # * Dispose
  #   dispose  löscht alle Sprites wenn die Map verlassen wird.
  #--------------------------------------------------------------------------  
  def dispose
    @sprites.each_value { |sprite| sprite.dispose }
  end
end
 
#==============================================================================
# ** Rect
#   Die Rect-Klasse fasst eine Startposition, Breite und Höhe in einem Objekt
#   zusammen. Sie wird hier um ein paar Methoden erweitert um im Rest des
#   Skripts ein paar Zeilen zu sparen:
#==============================================================================
class Rect
 
  #--------------------------------------------------------------------------
  # * Overlap? 
  #   overlap?  bestimmt ob sich zwei Rechtecke überlagern (zum Beispiel
  #   der Bereich eines Map-Objekts und der Bildschirmbereich)
  #--------------------------------------------------------------------------
  def overlap?(rect)
    return rect.x < end_x && rect.end_x > x && rect.y < end_y && rect.end_y > y
  end
 
  #--------------------------------------------------------------------------
  # * End_X
  #   end_x / end_y  bestimmen die (ausschließliche) Endpositionen des Rechtecks 
  #--------------------------------------------------------------------------
  def end_x
    x + width
  end
 
  #--------------------------------------------------------------------------
  # * End_Y
  #   end_x / end_y  bestimmen die (ausschließliche) Endpositionen des Rechtecks 
  #--------------------------------------------------------------------------
  def end_y
    y + height
  end
 
  #--------------------------------------------------------------------------
  # * Cut_Horizontally
  #   cut_horizontally / cut_vertically  teilen ein Rechteck an einer 
  #   gegebenen Position in zwei Teile auf. (Wird in der Map-Objekt-Tabelle 
  #   in  exclusive_objects  verwendet um die Unterschiede zwischen den zwei 
  #   Bereichen herauszufiltern)
  #--------------------------------------------------------------------------
  def cut_horizontally(position)
    cut_x = (position < x) ? x : (position > end_x) ? end_x : position
    rect1 = Rect.new(x, y, cut_x - x, height)
    rect2 = Rect.new(position, y, end_x - cut_x, height)
    return rect1, rect2
  end
 
  #--------------------------------------------------------------------------
  # * Cut_Vertically
  #   cut_horizontally / cut_vertically  teilen ein Rechteck an einer 
  #   gegebenen Position in zwei Teile auf. (Wird in der Map-Objekt-Tabelle 
  #   in  exclusive_objects  verwendet um die Unterschiede zwischen den zwei 
  #   Bereichen herauszufiltern)
  #--------------------------------------------------------------------------
  def cut_vertically(position)
    cut_y = (position < y) ? y : (position > end_y) ? end_y : position
    rect1 = Rect.new(x, y, width, cut_y - y)
    rect2 = Rect.new(x, position, width, end_y - cut_y)
    return rect1, rect2
  end
end