Ruby Quellcode

#
#=============================|
# Minimapscript v.1.0         |
#=============================|
#
#------------------------------|
# Credits:                     |
# Bitmap.draw_circle: By Saiko |
# Rest: By Hindi               |
#------------------------------|
#
#
#-------------------------------------------------------------------------------
# Beschreibung:
#-------------------------------------------------------------------------------
=begin
  Dieses RGSS Skript erzeugt eine Minimap. Um es zu nutzen müsst ihr es zunächst
  im Script Editor oberhalb der Main einfügen. Anschließent könnt ihr mit dem
  Eventbefehl "Script" folgenden Code mit Parameter einfügen:
  Leichter Code:
  Mini.map.anzeigen_easy(x, y, width, height, zoom[, style])
  Forgeschritten:
  Mini.map.anzeigen(rect, zoom[, style])
 
  Es ist relativ egal, welchen der beiden Codes ihr hernehmt, im 
  Forgeschrittenen ist der einzigste unterschied, dass ihr ein Rect erstellen 
  müsst, im einfach wird hingegen einfach ein Rect von selbst erstellt.
=end
#
#
#
#-------------------------------------------------------------------------------
# Anleitugn:
#-------------------------------------------------------------------------------
=begin
  erstmal mich (Hindi) für das Minimap Script und Saiko für das draw_circle
  Script, in den Credits erwähnen, dann:
=end
=begin
  Zur Minimap:
 
  Als Beispiel will ich den leichten Code nehmen:
  Mini.map.anzeigen_easy(x, y, width, height, zoom[, style])
 
  Hier stehen X und Y für die Koordinaten wo ihr die Minimap anzeigen lassen 
  wollt.
 
  Width und height, müsst ihr standartgemäß auf 0 stellen, es sei denn, ihr wollt
  einen kleinen Radar erstellen, denn dann könnt ihr damit die größe der Minimap
  bestimmen.
 
  Zomm bestimmt die größe der Minimap in jedem Falle. Die Minimap ist im Standart
  genau so groß wie die richtige Map. Der zoom wird in % angegeben... So wollt ihr
  30% der orginal größe, so müsst ihr 0.3 einsetzen.
 
  Style ist standartgemäß auf 1 gestellt, d.h. es wird der Style "normal"
  angezeigt, wollt ihr einen anderen Style, dann setzt dort eine andere Zahl ein.
  Im moment gibt es bei dieser Version nur einen 2. Style (ihr könnt nur als
  alternative die Zahl 2 einsetzen).
 
  Weitere befehle:
 
  Mit
  Mini.map.zoom(zoom_x, zoom_y)
  könnt ihr auf der X und Y Achse die Größe der Minimap verändern.
 
  Mit
  Mini.map.mini
  könnt ihr abfragen ob die Minimap angezeigt wird, es wird True oder False
  zurrück gegeben.
 
  Mit
  Mini.map.viewport_on
  könnt ihr abfragen ob gerade ein Radar angezeigt wird oder die ganze Map.
  Fals der Radar angezeigt wird, wird True returnt, andernfalls False.
 
 
 
  Mit
  Mini.map.dispose
  könnt ihr die Minimap wieder verschwinden lassen.
 
  Zu Missionen:
 
  Mit
  Mini.map.add_mission(x, y[, id])
  könnt ihr auf der Minimap einen Punkt auf der Koordinate X und Y anzeigen
  lassen. ID könnt ihr optional mit einer ID von einem Event ersetzen, dessen
  X und Y Koordinate wird dann auf der Minimap Grau angezeigt.
 
  Mit
  Mini.map.sub_mission(x, y[, id])
  könnt ihr einen Missionspunkt von der Minimap verschwinden lassen, mit X, Y und
  ID müsst ihr das selbe machen wie bei add_mission schon beschriebenen.
 
  Mit
  Mini.map.aktiv_mission?(x, y[, id])
  Überprüft ihr ob auf X, Y gerade ein Missionspunkt ist. X, Y und ID sind wieder
  mit dem selben zu ersetzen wie bei den beiden vorherigen Erleuterungen.
=end
#
#
#-------------------------------------------------------------------------------
# Game_Map:
#-------------------------------------------------------------------------------
class Game_Map
  attr_accessor :map
  def field_passable?(x, y, d, self_event = nil)
    return $game_map.passable?(x, y, d, self_event)
  end
end
#-------------------------------------------------------------------------------
# Interpreter:
#-------------------------------------------------------------------------------
class Interpreter
  alias minimap_update command_201
  def command_201
    minimap_update
    Mini.map.update if Mini.map.mini
  end
end
#-------------------------------------------------------------------------------
# Game_Player:
#-------------------------------------------------------------------------------
class Game_Player
  alias minimap_update update
  def update
    minimap_update
    Mini.map.update if Input.dir4 != 0 && Mini.map.mini
  end
end
#-------------------------------------------------------------------------------
# Bitmap:
#-------------------------------------------------------------------------------
class Bitmap
  def draw_circle(ox, oy, r, color)
    r.times do |x|
      y = r - Math.sqrt((r / 2.0) ** 2 - (x - r / 2.0) ** 2) - r
      self.fill_rect(ox + x - r / 2, oy + y, 1, -y * 2, color)
    end
  end
end
#-------------------------------------------------------------------------------
# Minimap:
#-------------------------------------------------------------------------------
class Minimap
  # mini == true fals die Minimap angezeigt wird
  # mission == true fals eine Mission aktiv ist
  attr_reader :mini, :viewport_on
  attr_accessor :mission
  def anzeigen_easy(x, y, width, height, zoom, style=1)
    rect = Rect.new(x, y, width, height)
    anzeigen(rect, zoom, style)
  end
  def anzeigen(rect, zoom, style=1)
    @style = style
    # Pfad des Tiles
    @pfad = RPG::Cache.tileset($game_map.tileset_name)
    @pfad_autotiles = Array.new
    for i in 0..6
      @pfad_autotiles[i] = RPG::Cache.autotile($game_map.autotile_names[i])
    end
    zoom_x, zoom_y = zoom, zoom
    @mini = true
    # Arrays erstellen
    # Alle wichtigen Variablen
    @map_width, @map_height  = $game_map.map.width, $game_map.height
    @zoom_x, @zoom_y         = zoom_x, zoom_y
    @x, @y                   = rect.x, rect.y
    @rect                    = rect
    # Missionen Table erstellen
    @missionen = Table.new(@map_width, @map_height)
    # Erstelle den Viewport
    if rect.width != 0 && rect.height != 0
      @viewport_on = true
      @viewport = Viewport.new(rect)
    else
      @viewport_on = false
      @viewport = Viewport.new(rect.x, rect.y, @map_width * 32, @map_height * 32)
    end
    # Erstelle die Farben
    @blue_hell               = Color.new( 50,  50, 255, 100)
    @blue_dunkel             = Color.new(  0,   0, 100, 200)
    @red                     = Color.new(255,   0,   0, 200)
    @green                   = Color.new(  0, 255,   0, 200)
    @weiss                   = Color.new(  0,   0,   0, 255)
    @grau                    = Color.new(100, 100, 100)
    # Erstelle den Playerpunkt
    @player                  = Sprite.new
    @player.z                = 1
    @player.bitmap           = Bitmap.new(32, 32)
    @player.bitmap.draw_circle(16, 16, 32, @red)
    @player.zoom_x           = @zoom_x
    @player.zoom_y           = @zoom_y
    # Erstelle die Minimap
    @minimap                 = Sprite.new(@viewport)
    @minimap.bitmap          = Bitmap.new(@map_width * 32, @map_height * 32)
    show_minimap(style)
    update
  end
  def update
    show_minimap(@style)
    update_mission
    # Pfad des Tiles
    @pfad = RPG::Cache.tileset($game_map.tileset_name)
    if @viewport_on
    else
      # Berechnen der X und Y Koordinaten des Helden
      x = $game_player.x * 32 * @zoom_x
      y = $game_player.y * 32 * @zoom_y
      # Setzt den Playerpunkt neu
      @player.x = @rect.x * 2 + x
      @player.y = @rect.y * 2 + y
    end
  end
  def show_minimap(style)
    @minimap.bitmap.clear if @minimap.bitmap != nil
    # Erstellen der Minimap
    @minimap.x               = @rect.x
    @minimap.y               = @rect.y
    @minimap.zoom_x          = @zoom_x
    @minimap.zoom_y          = @zoom_y
    # Setzte die Minimap und den Playerpunkt an die richtige Stelle
    if @viewport_on == true
      @player.x = @rect.x + @rect.width / 2
      @player.y = @rect.y + @rect.height / 2
      x, y = $game_player.x * 32 * @zoom_x, $game_player.y * 32 * @zoom_y
      @minimap.x = @player.x - x - @rect.x
      @minimap.y = @player.y - y - @rect.y
    end
    case style
    when 1
      normal #<= Style "normal" aufrufen
    when 2
      classic #<= Style "classic" aufrufen
    end
    # Setzte die Eventpunkte
    for i in $game_map.events.keys
      x, y = $game_map.events[i].x * 32 * @zoom_x, $game_map.events[i].y * 32 * @zoom_y
      @minimap.bitmap.draw_circle(events_x(i), events_y(i), 16, @green) if @viewport_on == true
      @minimap.bitmap.draw_circle(@rect.x + x * 32, @rect.y + y * 32, 16, @green) if @viewport_on == false
    end
  end
  # Minimap im Normal - Style
  def normal
    @minimap.opacity = 200
    for x in 0..@map_width
      for y in 0..@map_height
        for z in 0..2
          if $game_map.data[x, y, z] != nil
            if $game_map.data[x, y, z] >= 384
              var = $game_map.data[x, y, z] - 384
              xx, yy = var % 8, var / 8
              @minimap.bitmap.blt(x * 32, y * 32, @pfad, Rect.new(xx * 32, yy * 32, 32, 32))
            end
          end
        end
      end
    end
  end
  # Minimap im Classic - Style
  def classic
    for xx in 0..@map_width
      for yy in 0..@map_height
        if $game_map.field_passable?(xx, yy, 0)
          @minimap.bitmap.fill_rect(xx * 32, yy * 32, 32, 32, @blue_hell)
        else
          @minimap.bitmap.fill_rect(xx * 32, yy * 32, 32, 32, @blue_dunkel)
        end
      end
    end
  end
  # Gibt X - Achse zurrück
  def events_x(i)
    x = $game_map.events[i].x
    return @rect.x + (x * 32)
  end
  # Gibt Y - Achse zurrück
  def events_y(i)
    y = $game_map.events[i].y
    return @rect.y + (y * 32)
  end
  # Verändert den Zoom
  def zoom(zoom_x, zoom_y)
    @minimap.zoom_x, @minimap.zoom_y = zoom_x, zoom_y
    @player.zoom_x, @player.zoom_y   = zoom_x, zoom_y
    @events.zoom_x, @events.zoom_y   = zoom_x, zoom_y
  end
  # Dispose alle Bilder die durch dieses Modul erzeugt wurden
  def dispose
    @mini = false # <= Minimap wird angezeigt == false
    @minimap.bitmap.dispose # <= Dispose Minimap
    @player.bitmap.dispose # <= Dispose Playerpunkt
  end
  #-----------------------------------------------------------------------------
  # Autotiles:
  #-----------------------------------------------------------------------------
  def autotiles(x, y, z)
    t_x = nil
    if $game_map.data[x, y, z] < 384 && $game_map.data[x, y, z] >= 336
      t_x = 6
      sub = $game_map.data[x, y, z] - 384 + 96 - 48
    elsif $game_map.data[x, y, z] < 336 && $game_map.data[x, y, z] >= 288
      t_x = 5
      sub = $game_map.data[x, y, z] - 336 + 96 - 48
    elsif $game_map.data[x, y, z] < 288 && $game_map.data[x, y, z] >= 240
      t_x = 4
      sub = $game_map.data[x, y, z] - 288 + 96 - 48
    elsif $game_map.data[x, y, z] < 240 && $game_map.data[x, y, z] >= 192
      t_x = 3
      sub = $game_map.data[x, y, z] - 240 + 96 - 48
    elsif $game_map.data[x, y, z] < 192 && $game_map.data[x, y, z] >= 144
      t_x = 2
      sub = $game_map.data[x, y, z] - 192 + 96 - 48
    elsif $game_map.data[x, y, z] < 144 && $game_map.data[x, y, z] >= 96
      t_x = 1
      sub = $game_map.data[x, y, z] - 144 + 96 - 48
    elsif $game_map.data[x, y, z] < 96 && $game_map.data[x, y, z] >= 48
      t_x = 0
      sub = $game_map.data[x, y, z] - 96 + 96 - 48
    end
    pfad = @pfad_autotiles[t_x] if t_x != nil
    x1, x2, x3, x4 = nil, nil, nil, nil
    y1, y2, y3, y4 = nil, nil, nil, nil
    case sub
    when 0
      x1, x2, x3, x4 = 1, 1.5,   1, 1.5
      y1, y2, y3, y4 = 2,   2, 2.5, 2.5
    when 1
      x1, x2, x3, x4 = 2, 1.5,   1, 1.5
      y1, y2, y3, y4 = 0,   2, 2.5, 2.5
    when 2
      x1, x2, x3, x4 = 1, 2.5,   1, 1.5
      y1, y2, y3, y4 = 2,   0, 2.5, 2.5
    when 3
      x1, x2, x3, x4 = 2, 2.5,   1, 1.5
      y1, y2, y3, y4 = 0,   0, 2.5, 2.5
    when 4
      x1, x2, x3, x4 = 1, 1.5,   1, 2.5
      y1, y2, y3, y4 = 2,   2, 2.5, 0.5
    when 5
      x1, x2, x3, x4 = 2, 1.5,   1, 2.5
      y1, y2, y3, y4 = 0,   2, 2.5, 0.5
    when 6
      x1, x2, x3, x4 = 1, 2.5,   1, 2.5
      y1, y2, y3, y4 = 2,   0, 2.5, 0.5
    when 7
      x1, x2, x3, x4 = 2, 2.5,   1, 2.5
      y1, y2, y3, y4 = 0,   0, 2.5, 0.5
    when 8
      x1, x2, x3, x4 = 1, 1.5,   1, 1.5
      y1, y2, y3, y4 = 2,   2, 2.5, 2.5
    when 9
      x1, x2, x3, x4 = 1, 1.5,   2, 1.5
      y1, y2, y3, y4 = 2,   2, 0.5, 2.5
    when 10
      x1, x2, x3, x4 = 2, 1.5,   2, 1.5
      y1, y2, y3, y4 = 0,   2, 0.5, 2.5
    when 11
      x1, x2, x3, x4 = 1, 2.5,   2, 1.5
      y1, y2, y3, y4 = 2,   0, 0.5, 2.5
    when 12
      x1, x2, x3, x4 = 1, 1.5,   1, 1.5
      y1, y2, y3, y4 = 2,   2, 2.5, 2.5
    end
    if pfad != nil
      @minimap.bitmap.blt(x * 32,      y * 32,      pfad, Rect.new(x1 * 32, y1 * 32, 16, 16)) if x1 != nil
      @minimap.bitmap.blt(x * 32 + 16, y * 32,      pfad, Rect.new(x2 * 32, y2 * 32, 16, 16)) if x2 != nil
      @minimap.bitmap.blt(x * 32,      y * 32 + 16, pfad, Rect.new(x3 * 32, y3 * 32, 16, 16)) if x3 != nil
      @minimap.bitmap.blt(x * 32 + 16, y * 32 + 16, pfad, Rect.new(x4 * 32, y4 * 32, 16, 16)) if x4 != nil
    end
  end
  #-----------------------------------------------------------------------------
  # Missionen:
  #-----------------------------------------------------------------------------
  # Missoin hinzufügen
  def add_mission(x, y, id=nil)
    if x == nil && y == nil
      x, y = $game_map.events[i].x, $game_map.events[i].y
    end
    @missionen[x, y] = 1
    update_mission
  end
  # Mission enfernen
  def sub_mission(x, y, id=nil)
    if x == nil && y == nil
      x, y = $game_map.events[i].x, $game_map.events[i].y
    end
    @missionen[x, y] = 0
    update
  end
  # Missionen updaten
  def update_mission
    for x in 0..@map_width
      for y in 0..@map_height
        if @missionen[x, y] == 1
          if @viewport_on
            xx, yy = x * 32, y * 32
            x = @rect.width  if xx > @rect.height
            y = @rect.height if yy > @rect.height
            x += @minimap.x - @viewport.rect.x  if @minimap.x - xx < @viewport.rect.x
            y = @rect.y                         if yy < @rect.y
            x += 32
            y += 32
          else
            x *= 32
            y *= 32
          end
          @minimap.bitmap.draw_circle(x + 16, y + 16, 32, @grau)
        end
      end
    end
  end
  # Überpfürft ob eine Mission auf X, Y aktiv ist
  def aktiv_mission?(x, y, id=nil)
    if x == nil && y == nil
      x, y = $game_map.events[i].x, $game_map.events[i].y
    end
    return @missionen[x, y] == 1
  end
end
#-------------------------------------------------------------------------------
# Modul in die, die Klasse "Minimap" gelegt wird:
#-------------------------------------------------------------------------------
module Mini
  class <<self
    attr_accessor :map
  end
end
# Öffnen der Minimap - Klasse
Mini.map = Minimap.new if Mini.map == nil