Rpg Maker Developers Group

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/
#_/    ◆ ミニマップ - KMS_MiniMap ◆ VX Ace ◆
#_/    ◇ Last update : 2012/02/12  (TOMY@Kamesoft) ◇
#_/----------------------------------------------------------------------------
#_/  ミニマップ表示機能を追加します。
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#==============================================================================
# ★ 設定項目 - BEGIN Setting ★
#==============================================================================

module KMS_MiniMap
  # ◆ ミニマップ表示切替ボタン
  #  nil にするとボタン切り替え無効。
  SWITCH_BUTTON = nil

  # ◆ ミニマップ表示位置・サイズ (X, Y, 幅, 高さ)
  MAP_RECT = Rect.new(5, 5, 130, 130)
  # ◆ ミニマップの Z 座標
  #  大きくしすぎると色々なものに被ります。
  MAP_Z = 0
  # ◆ １マスのサイズ
  #  3 以上を推奨。
  GRID_SIZE = 3

  # ◆ ミニマップカラー
  FOREGROUND_COLOR = Color.new(192, 192, 224, 160)  # 前景色 (通行可)
  BACKGROUND_COLOR = Color.new(  0,   0, 160, 160)  # 背景色 (通行不可)
  POSITION_COLOR   = Color.new(255,   0,   0, 192)  # 現在位置
  MOVE_EVENT_COLOR = Color.new(255, 160,   0, 192)  # マップ移動イベント
  VEHICLE_COLOR    = Color.new( 96, 128,   0, 192)  # 乗り物

  # ◆ オブジェクトの色
  #  要素の先頭から順に OBJ1, OBJ2, ... に対応。
  OBJECT_COLOR = [
    Color.new(  0, 200,   0, 192),  # OBJ 1
    Color.new(  0, 255, 255, 192),  # OBJ 2
    Color.new(255, 170,   0, 192),  # OBJ 3
    Color.new(200, 0,   0, 192),  # OBJ 4
    Color.new(200, 0,   200, 192),  # OBJ 5
  ]  # ← この ] は消さないこと！

  # ◆ アイコンの点滅の強さ
  #  5 ～ 8 あたりを推奨。
  BLINK_LEVEL = 7

  # ◆ マップのキャッシュ数
  #  この数を超えると、長期間参照していないものから削除。
  CACHE_NUM = 1
end

#==============================================================================
# ☆ 設定ここまで - END Setting ☆
#==============================================================================

$kms_imported = {} if $kms_imported == nil
$kms_imported["MiniMap"] = true

module KMS_MiniMap
  # ミニマップ非表示
  REGEX_NO_MINIMAP_NOTE = /<(?:ミニマップ|MINIMAP)\s*(?:非表示|HIDE)>/i
  REGEX_NO_MINIMAP_NAME = /\[NOMAP\]/i

  # 障害物
  REGEX_WALL_EVENT = /<(?:ミニマップ|MINIMAP)\s*(?:壁|障害物|WALL)>/i

  # 移動イベント
  REGEX_MOVE_EVENT = /<(?:ミニマップ|MINIMAP)\s*(?:移動|MOVE)>/i

  # オブジェクト
  REGEX_OBJECT = /<(?:ミニマップ|MINIMAP)\s+OBJ(?:ECT)?\s*(\d+)>/i
end

# *****************************************************************************

#==============================================================================
# □ KMS_Commands
#==============================================================================

module KMS_Commands
  module_function
  #--------------------------------------------------------------------------
  # ○ ミニマップを表示
  #--------------------------------------------------------------------------
  def show_minimap
    $game_temp.minimap_manual_visible = true
    $game_system.minimap_show         = true
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップを隠す
  #--------------------------------------------------------------------------
  def hide_minimap
    $game_system.minimap_show = false
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップ表示状態の取得
  #--------------------------------------------------------------------------
  def minimap_showing?
    return $game_system.minimap_show
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップをリフレッシュ
  #--------------------------------------------------------------------------
  def refresh_minimap
    return unless SceneManager.scene_is?(Scene_Map)

    $game_map.refresh if $game_map.need_refresh
    SceneManager.scene.refresh_minimap
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップのオブジェクトを更新
  #--------------------------------------------------------------------------
  def update_minimap_object
    return unless SceneManager.scene_is?(Scene_Map)

    $game_map.refresh if $game_map.need_refresh
    SceneManager.scene.update_minimap_object
  end
end

#==============================================================================
# ■ Game_Interpreter
#==============================================================================

class Game_Interpreter
  # イベントコマンドから直接コマンドを叩けるようにする
  include KMS_Commands
end

#==============================================================================
# ■ RPG::Map
#==============================================================================

class RPG::Map
  #--------------------------------------------------------------------------
  # ○ ミニマップのキャッシュ生成
  #--------------------------------------------------------------------------
  def create_minimap_cache
    @__minimap_show = true

    note.each_line { |line|
      if line =~ KMS_MiniMap::REGEX_NO_MINIMAP_NOTE  # マップ非表示
        @__minimap_show = false
      end
    }
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップ表示
  #--------------------------------------------------------------------------
  def minimap_show?
    create_minimap_cache if @__minimap_show.nil?
    return @__minimap_show
  end
end

#==============================================================================
# ■ RPG::MapInfo
#==============================================================================

class RPG::MapInfo
  #--------------------------------------------------------------------------
  # ● マップ名取得
  #--------------------------------------------------------------------------
  def name
    return @name.gsub(/\[.*\]/) { "" }
  end
  #--------------------------------------------------------------------------
  # ○ オリジナルマップ名取得
  #--------------------------------------------------------------------------
  def original_name
    return @name
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップのキャッシュ生成
  #--------------------------------------------------------------------------
  def create_minimap_cache
    @__minimap_show = !(@name =~ KMS_MiniMap::REGEX_NO_MINIMAP_NAME)
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップ表示
  #--------------------------------------------------------------------------
  def minimap_show?
    create_minimap_cache if @__minimap_show == nil
    return @__minimap_show
  end
end

#==============================================================================
# ■ Game_Temp
#==============================================================================

class Game_Temp
  #--------------------------------------------------------------------------
  # ○ 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :minimap_manual_visible  # ミニマップ手動表示切り替えフラグ
  #--------------------------------------------------------------------------
  # ○ オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KMS_MiniMap initialize
  def initialize
    initialize_KMS_MiniMap

    @minimap_manual_visible = true
  end
end

#==============================================================================
# ■ Game_System
#==============================================================================

class Game_System
  #--------------------------------------------------------------------------
  # ○ 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :minimap_show  # ミニマップ表示フラグ
  #--------------------------------------------------------------------------
  # ○ オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KMS_MiniMap initialize
  def initialize
    initialize_KMS_MiniMap

    @minimap_show = true
  end
end

#==============================================================================
# ■ Game_Map
#==============================================================================

class Game_Map
  #--------------------------------------------------------------------------
  # ○ 定数
  #--------------------------------------------------------------------------
  MINIMAP_FADE_NONE = 0  # ミニマップ フェードなし
  MINIMAP_FADE_IN   = 1  # ミニマップ フェードイン
  MINIMAP_FADE_OUT  = 2  # ミニマップ フェードアウト
  #--------------------------------------------------------------------------
  # ○ 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :minimap_fade
  #--------------------------------------------------------------------------
  # ○ ミニマップを表示するか
  #--------------------------------------------------------------------------
  def minimap_show?
    return $data_mapinfos[map_id].minimap_show? && @map.minimap_show?
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップをフェードイン
  #--------------------------------------------------------------------------
  def fadein_minimap
    @minimap_fade = MINIMAP_FADE_IN
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップをフェードアウト
  #--------------------------------------------------------------------------
  def fadeout_minimap
    @minimap_fade = MINIMAP_FADE_OUT
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  alias refresh_KMS_MiniMap refresh
  def refresh
    refresh_KMS_MiniMap

    SceneManager.scene.refresh_minimap if SceneManager.scene_is?(Scene_Map)
  end
end

#==============================================================================
# ■ Game_Event
#==============================================================================

class Game_Event < Game_Character
  #--------------------------------------------------------------------------
  # ○ ミニマップ用のキャッシュを作成
  #--------------------------------------------------------------------------
  def __create_minimap_cache
    @__last_page = @page
    @__minimap_wall_event  = false
    @__minimap_move_event  = false
    @__minimap_object_type = -1

    return if @page.nil?

    @page.list.each { |cmd|
      # 注釈以外に到達したら離脱
      break unless [108, 408].include?(cmd.code)

      # 正規表現判定
      case cmd.parameters[0]
      when KMS_MiniMap::REGEX_WALL_EVENT
        @__minimap_wall_event = true
      when KMS_MiniMap::REGEX_MOVE_EVENT
        @__minimap_move_event = true
      when KMS_MiniMap::REGEX_OBJECT
        @__minimap_object_type = $1.to_i
      end
    }
  end
  private :__create_minimap_cache
  #--------------------------------------------------------------------------
  # ○ グラフィックがあるか
  #--------------------------------------------------------------------------
  def graphic_exist?
    return (character_name != "" || tile_id > 0)
  end
  #--------------------------------------------------------------------------
  # ○ 障害物か
  #--------------------------------------------------------------------------
  def is_minimap_wall_event?
    if @__minimap_wall_event.nil? || @__last_page != @page
      __create_minimap_cache
    end

    return @__minimap_wall_event
  end
  #--------------------------------------------------------------------------
  # ○ 移動イベントか
  #--------------------------------------------------------------------------
  def is_minimap_move_event?
    if @__minimap_move_event.nil? || @__last_page != @page
      __create_minimap_cache
    end

    return @__minimap_move_event
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップオブジェクトか
  #--------------------------------------------------------------------------
  def is_minimap_object?
    if @__minimap_object_type.nil? || @__last_page != @page
      __create_minimap_cache
    end

    return @__minimap_object_type > 0
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップオブジェクトタイプ
  #--------------------------------------------------------------------------
  def minimap_object_type
    if @__minimap_object_type.nil? || @__last_page != @page
      __create_minimap_cache
    end

    return @__minimap_object_type
  end
end

#==============================================================================
# □ Game_MiniMap
#------------------------------------------------------------------------------
#   ミニマップを扱うクラスです。
#==============================================================================

class Game_MiniMap
  #--------------------------------------------------------------------------
  # ○ 構造体
  #--------------------------------------------------------------------------
  Point = Struct.new(:x, :y)
  Size  = Struct.new(:width, :height)
  PassageCache = Struct.new(:map_id, :table, :scan_table)
  #--------------------------------------------------------------------------
  # ○ クラス変数
  #--------------------------------------------------------------------------
  @@passage_cache = []  # 通行フラグテーブルキャッシュ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  def initialize(tilemap)
    @map_rect  = KMS_MiniMap::MAP_RECT
    @grid_size = [KMS_MiniMap::GRID_SIZE, 1].max

    @x = 0
    @y = 0
    @grid_num = Point.new(
      (@map_rect.width  + @grid_size - 1) / @grid_size,
      (@map_rect.height + @grid_size - 1) / @grid_size
    )
    @draw_grid_num    = Point.new(@grid_num.x + 2, @grid_num.y + 2)
    @draw_range_begin = Point.new(0, 0)
    @draw_range_end   = Point.new(0, 0)
    @tilemap = tilemap

    @last_x = $game_player.x
    @last_y = $game_player.y

    @showing = false
    @hiding  = false

    create_sprites
    refresh

    unless $game_temp.minimap_manual_visible
      self.opacity = 0
    end
  end
  #--------------------------------------------------------------------------
  # ○ スプライト作成
  #--------------------------------------------------------------------------
  def create_sprites
    @viewport   = Viewport.new(@map_rect)
    @viewport.z = KMS_MiniMap::MAP_Z

    # ビットマップサイズ計算
    @bmp_size = Size.new(
      (@grid_num.x + 2) * @grid_size,
      (@grid_num.y + 2) * @grid_size
    )
    @buf_bitmap = Bitmap.new(@bmp_size.width, @bmp_size.height)

    # マップ用スプライト作成
    @map_sprite   = Sprite.new(@viewport)
    @map_sprite.x = -@grid_size
    @map_sprite.y = -@grid_size
    @map_sprite.z = 0
    @map_sprite.bitmap = Bitmap.new(@bmp_size.width, @bmp_size.height)

    # オブジェクト用スプライト作成
    @object_sprite   = Sprite_MiniMapIcon.new(@viewport)
    @object_sprite.x = -@grid_size
    @object_sprite.y = -@grid_size
    @object_sprite.z = 1
    @object_sprite.bitmap = Bitmap.new(@bmp_size.width, @bmp_size.height)

    # 現在位置スプライト作成
    @position_sprite   = Sprite_MiniMapIcon.new
    @position_sprite.x = @map_rect.x + @grid_num.x / 2 * @grid_size
    @position_sprite.y = @map_rect.y + @grid_num.y / 2 * @grid_size
    @position_sprite.z = @viewport.z + 2
    bitmap = Bitmap.new(@grid_size, @grid_size)
    bitmap.fill_rect(bitmap.rect, KMS_MiniMap::POSITION_COLOR)
    @position_sprite.bitmap = bitmap
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  def dispose
    @buf_bitmap.dispose
    @map_sprite.bitmap.dispose
    @map_sprite.dispose
    @object_sprite.bitmap.dispose
    @object_sprite.dispose
    @position_sprite.bitmap.dispose
    @position_sprite.dispose
    @viewport.dispose
  end
  #--------------------------------------------------------------------------
  # ○ 可視状態取得
  #--------------------------------------------------------------------------
  def visible
    return @map_sprite.visible
  end
  #--------------------------------------------------------------------------
  # ○ 可視状態設定
  #--------------------------------------------------------------------------
  def visible=(value)
    @viewport.visible        = value
    @map_sprite.visible      = value
    @object_sprite.visible   = value
    @position_sprite.visible = value
  end
  #--------------------------------------------------------------------------
  # ○ 不透明度取得
  #--------------------------------------------------------------------------
  def opacity
    return @map_sprite.opacity
  end
  #--------------------------------------------------------------------------
  # ○ 不透明度設定
  #--------------------------------------------------------------------------
  def opacity=(value)
    @map_sprite.opacity      = value
    @object_sprite.opacity   = value
    @position_sprite.opacity = value
  end
  #--------------------------------------------------------------------------
  # ○ リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    update_draw_range
    update_passage_table
    update_object_list
    update_position
    draw_map
    draw_object
    Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # ○ フェードイン
  #--------------------------------------------------------------------------
  def fadein
    @showing = true
    @hiding  = false
  end
  #--------------------------------------------------------------------------
  # ○ フェードアウト
  #--------------------------------------------------------------------------
  def fadeout
    @showing = false
    @hiding  = true
  end
  #--------------------------------------------------------------------------
  # ○ キー入力更新
  #--------------------------------------------------------------------------
  def update_input
    return if KMS_MiniMap::SWITCH_BUTTON.nil?

    if Input.trigger?(KMS_MiniMap::SWITCH_BUTTON)
      if opacity < 255 && !@showing
        $game_temp.minimap_manual_visible = true
        fadein
      elsif opacity > 0 && !@hiding
        $game_temp.minimap_manual_visible = false
        fadeout
      end
    end
  end
  #--------------------------------------------------------------------------
  # ○ 描画範囲更新
  #--------------------------------------------------------------------------
  def update_draw_range
    range = []
    (2).times { |i| range[i] = @draw_grid_num[i] / 2 }

    @draw_range_begin.x = $game_player.x - range[0]
    @draw_range_begin.y = $game_player.y - range[1]
    @draw_range_end.x   = $game_player.x + range[0]
    @draw_range_end.y   = $game_player.y + range[1]
  end
  #--------------------------------------------------------------------------
  # ○ 通行可否テーブル更新
  #--------------------------------------------------------------------------
  def update_passage_table
    cache = get_passage_table_cache
    @passage_table      = cache.table
    @passage_scan_table = cache.scan_table

    update_around_passage_table
  end
  #--------------------------------------------------------------------------
  # ○ 通行可否テーブルのキャッシュを取得
  #--------------------------------------------------------------------------
  def get_passage_table_cache
    map_id = $game_map.map_id
    cache  = @@passage_cache.find { |c| c.map_id == map_id }

    # キャッシュミスしたら新規作成
    if cache == nil
      cache = PassageCache.new(map_id)
      cache.table      = Table.new($game_map.width, $game_map.height)
      cache.scan_table = Table.new(
        ($game_map.width  + @draw_grid_num.x - 1) / @draw_grid_num.x,
        ($game_map.height + @draw_grid_num.y - 1) / @draw_grid_num.y
      )
    end

    # 直近のキャッシュは先頭に移動し、古いキャッシュは削除
    @@passage_cache.unshift(cache)
    @@passage_cache.delete_at(KMS_MiniMap::CACHE_NUM)

    return cache
  end
  #--------------------------------------------------------------------------
  # ○ 通行可否テーブルのキャッシュをクリア
  #--------------------------------------------------------------------------
  def clear_passage_table_cache
    return if @passage_scan_table == nil

    table = @passage_scan_table
    @passage_scan_table = Table.new(table.xsize, table.ysize)
  end
  #--------------------------------------------------------------------------
  # ○ 通行可否テーブルの探索
  #     x, y : 探索位置
  #--------------------------------------------------------------------------
  def scan_passage(x, y)
    dx = x / @draw_grid_num.x
    dy = y / @draw_grid_num.y

    # 探索済み
    return if @passage_scan_table[dx, dy] == 1

    # マップ範囲外
    return unless dx.between?(0, @passage_scan_table.xsize - 1)
    return unless dy.between?(0, @passage_scan_table.ysize - 1)

    rx = (dx * @draw_grid_num.x)...((dx + 1) * @draw_grid_num.x)
    ry = (dy * @draw_grid_num.y)...((dy + 1) * @draw_grid_num.y)
    mw = $game_map.width  - 1
    mh = $game_map.height - 1

    # 探索範囲内の通行テーブルを生成
    rx.each { |x|
      next unless x.between?(0, mw)
      ry.each { |y|
        next unless y.between?(0, mh)

        # 通行方向フラグ作成
        # (↓、←、→、↑ の順に 1, 2, 4, 8 が対応)
        flag = 0
        [2, 4, 6, 8].each{ |d|
          flag |= 1 << (d / 2 - 1) if $game_map.passable?(x, y, d)
        }
        @passage_table[x, y] = flag
      }
    }
    @passage_scan_table[dx, dy] = 1
  end
  #--------------------------------------------------------------------------
  # ○ 周辺の通行可否テーブル更新
  #--------------------------------------------------------------------------
  def update_around_passage_table
    gx = @draw_grid_num.x
    gy = @draw_grid_num.y
    dx = $game_player.x - gx / 2
    dy = $game_player.y - gy / 2
    scan_passage(dx,      dy)
    scan_passage(dx + gx, dy)
    scan_passage(dx,      dy + gy)
    scan_passage(dx + gx, dy + gy)
  end
  #--------------------------------------------------------------------------
  # ○ オブジェクト一覧更新
  #--------------------------------------------------------------------------
  def update_object_list
    events = $game_map.events.values

    # WALL
    @wall_events = events.find_all { |e| e.is_minimap_wall_event? }

    # MOVE
    @move_events = events.find_all { |e| e.is_minimap_move_event? }

    # OBJ
    @object_list = events.find_all { |e| e.is_minimap_object? }
  end
  #--------------------------------------------------------------------------
  # ○ 位置更新
  #--------------------------------------------------------------------------
  def update_position
    # 移動量算出
    pt = Point.new($game_player.x, $game_player.y)
    ox = ($game_player.real_x - pt.x) * @grid_size
    oy = ($game_player.real_y - pt.y) * @grid_size

    @viewport.ox = ox
    @viewport.oy = oy

    # 移動していたらマップ再描画
    if pt.x != @last_x || pt.y != @last_y
      draw_map
      @last_x = pt.x
      @last_y = pt.y
    end
  end
  #--------------------------------------------------------------------------
  # ○ 描画範囲内判定
  #--------------------------------------------------------------------------
  def in_draw_range?(x, y)
    rb = @draw_range_begin
    re = @draw_range_end
    return (x.between?(rb.x, re.x) && y.between?(rb.y, re.y))
  end
  #--------------------------------------------------------------------------
  # ○ マップ範囲内判定
  #--------------------------------------------------------------------------
  def in_map_range?(x, y)
    mw = $game_map.width
    mh = $game_map.height
    return (x.between?(0, mw - 1) && y.between?(0, mh - 1))
  end
  #--------------------------------------------------------------------------
  # ○ マップ描画
  #--------------------------------------------------------------------------
  def draw_map
    update_around_passage_table

    bitmap  = @map_sprite.bitmap
    bitmap.fill_rect(bitmap.rect, KMS_MiniMap::BACKGROUND_COLOR)

    draw_map_foreground(bitmap)
    draw_map_move_event(bitmap)
  end
  #--------------------------------------------------------------------------
  # ○ 通行可能領域の描画
  #--------------------------------------------------------------------------
  def draw_map_foreground(bitmap)
    range_x = (@draw_range_begin.x)..(@draw_range_end.x)
    range_y = (@draw_range_begin.y)..(@draw_range_end.y)
    map_w   = $game_map.width  - 1
    map_h   = $game_map.height - 1
    rect    = Rect.new(0, 0, @grid_size, @grid_size)

    range_x.each { |x|
      next unless x.between?(0, map_w)
      range_y.each { |y|
        next unless y.between?(0, map_h)
        next if @passage_table[x, y] == 0
        next if @wall_events.find { |e| e.x == x && e.y == y }  # 壁

        # グリッド描画サイズ算出
        rect.set(0, 0, @grid_size, @grid_size)
        rect.x = (x - @draw_range_begin.x) * @grid_size
        rect.y = (y - @draw_range_begin.y) * @grid_size
        flag = @passage_table[x, y]
        if flag & 0x01 == 0  # 下通行不能
          rect.height -= 1
        end
        if flag & 0x02 == 0  # 左通行不能
          rect.x     += 1
          rect.width -= 1
        end
        if flag & 0x04 == 0  # 右通行不能
          rect.width -= 1
        end
        if flag & 0x08 == 0  # 上通行不能
          rect.y      += 1
          rect.height -= 1
        end
        bitmap.fill_rect(rect, KMS_MiniMap::FOREGROUND_COLOR)
      }
    }
  end
  #--------------------------------------------------------------------------
  # ○ 移動イベントの描画
  #--------------------------------------------------------------------------
  def draw_map_move_event(bitmap)
    rect = Rect.new(0, 0, @grid_size, @grid_size)
    @move_events.each { |e|
      rect.x = (e.x - @draw_range_begin.x) * @grid_size
      rect.y = (e.y - @draw_range_begin.y) * @grid_size
      bitmap.fill_rect(rect, KMS_MiniMap::MOVE_EVENT_COLOR)
    }
  end
  #--------------------------------------------------------------------------
  # ○ アニメーション更新
  #--------------------------------------------------------------------------
  def update_animation
    if @showing
      # フェードイン
      self.opacity += 16
      if opacity == 255
        @showing = false
      end
    elsif @hiding
      # フェードアウト
      self.opacity -= 16
      if opacity == 0
        @hiding = false
      end
    end
  end
  #--------------------------------------------------------------------------
  # ○ オブジェクト描画
  #--------------------------------------------------------------------------
  def draw_object
    # 下準備
    bitmap = @object_sprite.bitmap
    bitmap.clear
    rect = Rect.new(0, 0, @grid_size, @grid_size)

    # オブジェクト描画
    @object_list.each { |obj|
      next unless in_draw_range?(obj.x, obj.y)

      color = KMS_MiniMap::OBJECT_COLOR[obj.minimap_object_type - 1]
      next if color.nil?

      rect.x = (obj.real_x - @draw_range_begin.x) * @grid_size
      rect.y = (obj.real_y - @draw_range_begin.y) * @grid_size
      bitmap.fill_rect(rect, color)
    }

    # 乗り物描画
    $game_map.vehicles.each { |vehicle|
      next if vehicle.transparent

      rect.x = (vehicle.real_x - @draw_range_begin.x) * @grid_size
      rect.y = (vehicle.real_y - @draw_range_begin.y) * @grid_size
      bitmap.fill_rect(rect, KMS_MiniMap::VEHICLE_COLOR)
    }
  end
  #--------------------------------------------------------------------------
  # ○ 更新
  #--------------------------------------------------------------------------
  def update
    update_input

    return unless need_update?

    update_draw_range
    update_position
    update_animation
    draw_object

    @map_sprite.update
    @object_sprite.update
    @position_sprite.update
  end
  #--------------------------------------------------------------------------
  # ○ 更新判定
  #--------------------------------------------------------------------------
  def need_update?
    return (visible && opacity > 0) || @showing || @hiding
  end
end

#==============================================================================
# □ Sprite_MiniMapIcon
#------------------------------------------------------------------------------
#   ミニマップ用アイコンのクラスです。
#==============================================================================

class Sprite_MiniMapIcon < Sprite
  DURATION_MAX = 60
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #     viewport : ビューポート
  #--------------------------------------------------------------------------
  def initialize(viewport = nil)
    super(viewport)
    @duration = DURATION_MAX / 2
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    super
    @duration += 1
    if @duration == DURATION_MAX
      @duration = 0
    end
    update_effect
  end
  #--------------------------------------------------------------------------
  # ○ エフェクトの更新
  #--------------------------------------------------------------------------
  def update_effect
    self.color.set(255, 255, 255,
      (@duration - DURATION_MAX / 2).abs * KMS_MiniMap::BLINK_LEVEL
    )
  end
end

#==============================================================================
# ■ Spriteset_Map
#==============================================================================

class Spriteset_Map
  attr_reader :minimap
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #--------------------------------------------------------------------------
  alias initialize_KMS_MiniMap initialize
  def initialize
    initialize_KMS_MiniMap

    create_minimap
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップの作成
  #--------------------------------------------------------------------------
  def create_minimap
    @minimap = Game_MiniMap.new(@tilemap)
    @minimap.visible = $game_system.minimap_show && $game_map.minimap_show?
  end
  #--------------------------------------------------------------------------
  # ● 解放
  #--------------------------------------------------------------------------
  alias dispose_KMS_MiniMap dispose
  def dispose
    dispose_KMS_MiniMap

    dispose_minimap
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップの解放
  #--------------------------------------------------------------------------
  def dispose_minimap
    @minimap.dispose
    @minimap = nil
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  alias update_KMS_MiniMap update
  def update
    update_KMS_MiniMap

    update_minimap
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップ更新
  #--------------------------------------------------------------------------
  def minimap_show?
    return $game_map.minimap_show? && $game_system.minimap_show
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップ更新
  #--------------------------------------------------------------------------
  def update_minimap
    return if @minimap.nil?

    # 表示切替
    if minimap_show?
      @minimap.visible = true
    else
      @minimap.visible = false
      return
    end

    # フェード判定
    case $game_map.minimap_fade
    when Game_Map::MINIMAP_FADE_IN
      @minimap.fadein
      $game_map.minimap_fade = Game_Map::MINIMAP_FADE_NONE
    when Game_Map::MINIMAP_FADE_OUT
      @minimap.fadeout
      $game_map.minimap_fade = Game_Map::MINIMAP_FADE_NONE
    end

    @minimap.update
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップ全体をリフレッシュ
  #--------------------------------------------------------------------------
  def refresh_minimap
    return if @minimap.nil?

    @minimap.clear_passage_table_cache
    @minimap.refresh
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップのオブジェクトを更新
  #--------------------------------------------------------------------------
  def update_minimap_object
    @minimap.update_object_list unless @minimap.nil?
  end
end

#==============================================================================
# ■ Scene_Map
#==============================================================================

class Scene_Map
  #--------------------------------------------------------------------------
  # ● 場所移動後の処理
  #--------------------------------------------------------------------------
  alias post_transfer_KMS_MiniMap post_transfer
  def post_transfer
    refresh_minimap

    post_transfer_KMS_MiniMap
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップ全体をリフレッシュ
  #--------------------------------------------------------------------------
  def refresh_minimap
    @spriteset.refresh_minimap unless @spriteset.nil?
  end
  #--------------------------------------------------------------------------
  # ○ ミニマップのオブジェクトを更新
  #--------------------------------------------------------------------------
  def update_minimap_object
    @spriteset.update_minimap_object unless @spriteset.nil?
  end
end

#===============================================================================
# TheoAllen - Fog of War
# Requested by : Zero0018
# Last edited : 15.01.2015
#-------------------------------------------------------------------------------
# How to use :
# Put the script below materials but above main
# No external resource is required
#
#------------------------------------------------------------------------------
# ** MAP NOTETAG :
#------------------------------------------------------------------------------
# To show fog in map, simply put <fog> in map note
# To hide fog in map, simply put <no fog> in map note
#
# Set the default of showing fog in configuration
#
#------------------------------------------------------------------------------
# ** SCRIPT CALL :
#------------------------------------------------------------------------------
#
# $game_map.reveal_tiles(x, y)
# $game_map.reveal_tiles(x, y, distance)
# Will reveal tiles in x,y within the distance. If distance is ommited, it will
# be same as the VisiRange in script setting
#
# $game_map.events[event_id].reveal_tiles
# $game_map.events[event_id].reveal_tiles(distance)
# Will reveal tiles from the event location within the distance. If distance is
# ommited, it will be same as the VisiRange in script setting
#
#-------------------------------------------------------------------------------
# Configuration
#===============================================================================
module Theo
 
  VisiRange   = 4
# Visibility range of the character. Larger value, longer distance

  FogOpacity  = 255
# Fog opacity. Set 255 for full opacity.

  DefaultFog  = false
# If set to true, every map will has fog. Unless you put <no fog>
# If set to false, every map will has no fog. Unless you put <fog>

end
#===============================================================================
# End of config
#===============================================================================

#===============================================================================
# ** Bitmap
#===============================================================================

class Bitmap
 
  # Fill entire bitmap with color
  def entire_fill(color = Color.new(0,0,0,150))
    fill_rect(self.rect,color)
  end
 
end

#===============================================================================
# ** Fog of War
#===============================================================================

class Fog_of_War < Plane
  @@bitmap_cache = {}
  #----------------------------------------------------------------------------
  # * Initialize
  #----------------------------------------------------------------------------
  def initialize(vport)
    super(vport)
    @id = -1
  end
 
  #----------------------------------------------------------------------------
  # * Update
  #----------------------------------------------------------------------------
  def update
    if $game_map
      if @id != $game_map.map_id
        @id = $game_map.map_id
        @width = $game_map.width
        @height = $game_map.height
        update_bitmap
      end
      self.ox = $game_map.display_x * 32
      self.oy = $game_map.display_y * 32
      self.visible = !$game_map.no_fog?
    end
  end
 
  #----------------------------------------------------------------------------
  # * Update bitmap
  #----------------------------------------------------------------------------
  def update_bitmap
    bmp = @@bitmap_cache[@id]
    unless bmp && !bmp.disposed?
      bmp = Bitmap.new(@width * 32, @height * 32)
      @@bitmap_cache[@id] = bmp
    end
    self.bitmap = bmp
    return if $game_map.no_fog?
    bitmap.entire_fill(Color.new(0,0,0,Theo::FogOpacity))
    reveal_tiles($game_system.revealed_tiles)
    reveal_tiles($game_player.reveal_tiles)
  end
 
  #----------------------------------------------------------------------------
  # * Reveal Tiles
  #----------------------------------------------------------------------------
  def reveal_tiles(tiles)
    tiles.each do |pos|
      x = pos.x * 32
      y = pos.y * 32
      bitmap.clear_rect(x,y,32,32)
    end unless disposed?
  end
 
end

#===============================================================================
# ** Game_System
#===============================================================================

class Game_System
  #----------------------------------------------------------------------------
  # * Revealed tiles
  #----------------------------------------------------------------------------
  def revealed_tiles
    @revealed_map ||= {}
    @revealed_map[$game_map.map_id] ||= []
    @revealed_map[$game_map.map_id]
  end
 
  #----------------------------------------------------------------------------
  # * Revealed tiles =
  #----------------------------------------------------------------------------
  def revealed_tiles=(t)
    @revealed_map ||= {}
    @revealed_map[$game_map.map_id] = t
  end
 
end

#===============================================================================
# ** Revealed Node
#===============================================================================

class Revealed_Node
  #----------------------------------------------------------------------------
  # * Public attributes
  #----------------------------------------------------------------------------
  attr_accessor :parent   
  attr_accessor :visited
  attr_accessor :x
  attr_accessor :y
  attr_reader :expanded
  attr_reader :nodes
 
  #----------------------------------------------------------------------------
  # * Initialize
  #----------------------------------------------------------------------------
  def initialize(x,y)
    @x ,@y = x, y
    @nodes = {}
    @visited = false
    @expanded = false
  end
 
  #----------------------------------------------------------------------------
  # * Expand node
  #----------------------------------------------------------------------------
  def expand_node(mapnodes, char)
    dir = [2,4,6,8]
    dir.each do |d|
      xpos = $game_map.round_x_with_direction(@x, d)
      ypos = $game_map.round_y_with_direction(@y, d)
      key = [xpos, ypos]
      next_node = mapnodes[key]
      if next_node.nil?
        next_node = Revealed_Node.new(xpos, ypos)
        mapnodes[key] = next_node
      elsif next_node.visited
        next
      end
      next_node.parent = self
      self.nodes[d] = next_node
    end
    @expanded = true
  end
 
  #----------------------------------------------------------------------------
  # * Get Parent Direction
  #----------------------------------------------------------------------------
  def get_parent_dir
    parent.nodes.index(self)
  end

end

#===============================================================================
# ** Game_Map
#===============================================================================

class Game_Map
  #----------------------------------------------------------------------------
  # * No fog?
  #----------------------------------------------------------------------------
  def no_fog?
    return false unless @map
    return true if @map.note[/<no[\s_]+fog>/i]
    return false if @map.note[/<fog>/i]
    return !Theo::DefaultFog
  end
  #----------------------------------------------------------------------------
  # * Reveal tiles
  #----------------------------------------------------------------------------
  def reveal_tiles(x, y, distance = Theo::VisiRange, reveal = true)
    return if no_fog?
    # Initialize
    @revealed_nodes = {}
    @max_distance = distance - 1
    @init_x = x
    @init_y = y
    
    # Make first node to check
    first_node = Revealed_Node.new(x, y)
    first_node.expand_node(@revealed_nodes, self)
    first_node.visited = true
    @revealed_nodes[[x, y]] = first_node
    @reveal_queue = []
    @reveal_queue.push(first_node)
    
    # spread search using BFS
    until @reveal_queue.empty?
      spread_search(@reveal_queue.shift)
    end
    
    node_to_reveal = @revealed_nodes.values - $game_system.revealed_tiles
    sprset = SceneManager.scene.spriteset
    sprset.fogofwar.reveal_tiles(node_to_reveal) if sprset
    $game_system.revealed_tiles += @revealed_nodes.values
  end
 
  #----------------------------------------------------------------------------
  # * Spread search
  #----------------------------------------------------------------------------
  def spread_search(node)
    dir = [2,4,6,8]
    dir.shuffle.each do |d|
      next_node = node.nodes[d]
      next unless next_node
      next if next_node.visited
      next if get_distance(next_node) > @max_distance
      next_node.expand_node(@revealed_nodes, self) unless next_node.expanded
      next_node.visited = true
      @reveal_queue.push(next_node, node)
    end
  end
 
  #----------------------------------------------------------------------------
  # * Get distance
  #----------------------------------------------------------------------------
  def get_distance(node)
    range_x = node.x - @init_x
    range_y = node.y - @init_y
    result =  Math.sqrt((range_x**2) + (range_y**2))
    return result
  end
 
end
#===============================================================================
# ** Game_Character
#===============================================================================
class Game_Character
  #----------------------------------------------------------------------------
  # * Reveal tiles
  #----------------------------------------------------------------------------
  def reveal_tiles(distance = Theo::VisiRange)
    $game_map.reveal_tiles(x, y, distance)
  end
 
end

#===============================================================================
# ** Game_Player
#===============================================================================
class Game_Player
  #----------------------------------------------------------------------------
  # * Increase step
  #----------------------------------------------------------------------------
  alias theo_fogofwar_increase_steps increase_steps
  def increase_steps
    theo_fogofwar_increase_steps
    reveal_tiles
  end
 
end

#===============================================================================
# ** Spriteset_Map
#===============================================================================

class Spriteset_Map
  #----------------------------------------------------------------------------
  # * Attribute Reader
  #----------------------------------------------------------------------------
  attr_reader :fogofwar
 
  #----------------------------------------------------------------------------
  # * Create viewports (alias)
  #----------------------------------------------------------------------------
  alias theo_fogofwar_create_viewports create_viewports
  def create_viewports
    theo_fogofwar_create_viewports
    create_fogofwar
  end
 
  #----------------------------------------------------------------------------
  # * Create fog of war
  #----------------------------------------------------------------------------
  def create_fogofwar
    @fogofwar = Fog_of_War.new(@viewport1)
    @fogofwar.z = 500#210
  end
 
  #----------------------------------------------------------------------------
  # * Update (alias)
  #----------------------------------------------------------------------------
  alias theo_fogofwar_update update
  def update
    theo_fogofwar_update
    @fogofwar.update
  end
 
  #----------------------------------------------------------------------------
  # * Dispose (alias)
  #----------------------------------------------------------------------------
  alias theo_fogofwar_dispose dispose
  def dispose
    theo_fogofwar_dispose
    @fogofwar.dispose
  end
 
end

#===============================================================================
# ** Scene_Base
#===============================================================================

class Scene_Base
  attr_reader :spriteset
end

#==============================================================================
# □ Etude87's KMS MiniMap Add-on ver.1.3.7
#==============================================================================
# * 한국어
# 작성자 : 습작
# 설　명 : KMS MiniMap에 이동경로 그리기 및 포그 기능 등을 추가해주는 스크립트 입니다.
#==============================================================================
# * ENG
# Author : etude87
# Explanation : It is a script that adds movement path drawing and fog function to KMS MiniMap.
#==============================================================================
#
# 현재 문제점 : 지붕타일 정상 작동 안함, FOV 화면 스크롤과 이격, 타일 id 기반 지붕타일 예외 추가 처리 안됨, inRange 필요 여부
#
#==============================================================================
module Etude87_KMS_MiniMap
    #--------------------------------------------------------------------------
    # 현재 위치 그리기 설정 모음
    # Collection of current location drawing settings
    #--------------------------------------------------------------------------
    # 세모꼴 위치 표시 사용 여부
    # Whether to use the triangle mark
    USE_TRIANGLE_POINT = true
    # 세모꼴 위치 표시 정렬 방식(0:상단, 1:중단, 2:하단)
    # Triangle mark position display alignment method(0:top, 1:middle, 2:bottom)
    ALIGN_TRIANGLE_POINT = 1
    #--------------------------------------------------------------------------
    # 미니맵 이동 경로 그리기 설정 모음
    # Mini Map Drawing Path Drawing Set Collection
    #--------------------------------------------------------------------------
    # 이동 경로 그리기 사용 여부
    # Whether to use draw path
    USE_MOVE_ROUTE = true
    # 이동 경로 색상
    # Path color
    MOVE_ROUTE_COLOR = Color.new(255,   0,   0, 192)
    # 이동 경로 길이( 1보다 작은 경우 무제한 )
    # Path length (unlimited if less than 1)
    MOVE_ROUTE_LENGTH = 50
    # 이동 경로 선 굵기
    # Thickness of the moving path
    LINE_THICKNESS = 1
    # 점점 흐려지기 사용 여부
    # Increasingly blurred
    USE_TRANSPARENCY = true
    #--------------------------------------------------------------------------
    # 미니맵 포그 기능 설정 모음
    # Mini Map fog feature set
    #--------------------------------------------------------------------------
    # 미니맵 포그 기능 사용 여부
    # Whether mini-map fog function is used
    USE_FOG = true
    # 시야범위 최 외각 처리여부
    # Whether the outline of the field is processed
    USE_OUTLINE = true
    # 시야범위 최 외각 굵기
    # Outline thickness
    OUTLINE_THICKNESS = 5
    # 맵별 예외처리
    # Handle exceptions by map
    EXCEPTION = {     
        # ID 1번맵 마름모 시야범위
        # ID 1 map rhombus view
        #1 => [:lozenge,    5],
         # ID 2번맵 정사각형 시야범
         # ID 2 map square view
        2 => [:square, 4],
        # ID 3번맵 원형 시야범위
        # ID 3 map round view
        #3 => [:circle,    5],
        # ID 4번맵 마름모 시야범위
        # ID 4 map rhombus view
        #4 => [:lozenge,    5],
        # ID 5번맵 포그 미사용
        # ID 5 map fog unused
        #5 => :none,
    }#<= 지우지 말것 / Do not erase
    #--------------------------------------------------------------------------
    # 미니맵 시야각 기능 설정 모음
    # Mini Map field of view feature set
    #--------------------------------------------------------------------------
    # 미니맵 시야각 기능 사용 여부
    # Whether mini-map field of view function is used
    USE_FOV = true
    # 통행설정 기반 시야각 판별 사용 여부
    # Use of traffic setting based viewing angle discrimination
    Auto_FOV = true
    # 지붕 및 벽 시야각 처리 여부
    # Handle roof and wall viewing angles
    Roof_Wall = true
    # 시야각 처리 예외 지형 태그
    # Viewing angle handling exception terrain tag
    Exception_Terrain_Tag = 1
    # 시야각 처리 추가 지형 태그
    # View angle handling added terrain tag
    Additional_Terrain_Tag = 2
    # 시야각 처리 대상 이벤트 이름 키워드
    # Viewing angle processing target event name keyword
    FOV_Ev_Name_Keyword = "[FOV]"
    #--------------------------------------------------------------------------
end
#==============================================================================
#==============================================================================
class Game_System
    attr_reader   :route
    attr_reader   :drawable
    #--------------------------------------------------------------------------
    alias etude87_initialize initialize
    def initialize
        @route = []
        @drawable = {}
        etude87_initialize
    end
    #--------------------------------------------------------------------------
    def add_route(pos)
        @route.shift if (Etude87_KMS_MiniMap::MOVE_ROUTE_LENGTH <= @route.size && Etude87_KMS_MiniMap::MOVE_ROUTE_LENGTH >= 1)
        @route.push(pos)
        px = $game_player.x
        py = $game_player.y
        m = Etude87_KMS_MiniMap::EXCEPTION[$game_map.map_id]
        o = Etude87_KMS_MiniMap::USE_OUTLINE
        t = Etude87_KMS_MiniMap::OUTLINE_THICKNESS
        tx = $game_map.screen_tile_x.to_i
        ty = $game_map.screen_tile_y.to_i
        dx = $game_map.display_x.to_i
        dy = $game_map.display_y.to_i
        mw = $game_map.width.to_i
        mh = $game_map.height.to_i
        if Etude87_KMS_MiniMap::EXCEPTION[$game_map.map_id] && Etude87_KMS_MiniMap::EXCEPTION[$game_map.map_id] != :none
            min_x = px - m[1]
            max_x = px + m[1]
            min_y = py - m[1]
            max_y = py + m[1]
        else
            min_x = [[px - (tx - 1)/2, 0].max, mw - tx].min
            max_x = min_x + tx - 1
            min_y = [[py - (ty - 1)/2, 0].max, mh - ty].min
            max_y = min_y + ty - 1
            if o
                min_x -= t if min_x == 0
                max_x += t if max_x == mw - 1
                min_y -= t if min_y == 0
                max_y += t if max_y == mh - 1
            end
        end
        @drawable[pos[0]] ||= {}
        for i in dx..(dx + tx)
            for j in dy..(dy + ty)
                @drawable[pos[0]][i] ||= {}
                if Etude87_KMS_MiniMap::USE_FOV
                    unless checkFOV(px, py, i, j, false)
                        if @drawable[pos[0]][i][j]
                            @drawable[pos[0]][i][j] = 1
                        end
                        next
                    end
                end
            end
        end
        for x in min_x..max_x
            for y in min_y..max_y
                @drawable[pos[0]][x] ||= {}
                if Etude87_KMS_MiniMap::USE_FOV
                    unless checkFOV(px, py, x, y, true)
                        if @drawable[pos[0]][x][y]
                            @drawable[pos[0]][x][y] = 1
                        end
                        next
                    end
                end
                if m
                    case m[0]
                    when :circle
                        next if m[1] < Math.sqrt((px - x)**2 + (py - y)**2).to_i
                    when :lozenge
                        next if (px - x).abs + (py - y).abs > m[1]
                    end
                end
                r = offset(x, min_x, max_x, y, min_y, max_y, px, py)
                if @drawable[pos[0]][x][y]
                    if @drawable[pos[0]][x][y] < r
                        @drawable[pos[0]][x][y] = r
                    end
                else
                    @drawable[pos[0]][x][y] = r
                end
            end
        end
    end   
    #--------------------------------------------------------------------------
    def checkFOV(x1, y1, x2, y2, inRange)
        return true if x1 == x2 && y1 == y2
        x = x1
        y = y1
        counter = 0
        result = true
        dx = x2 - x1
        dy = y2 - y1
        if dx.abs > dy.abs
            d = dx > 0 ? 6 : 4
        elsif dy != 0
            d = dy > 0 ? 2 : 8
        end
        if dx < 0
            addX = -1
            dx = -dx
        else
            addX = 1
        end
        if dy < 0
            addY = -1
            dy = -dy
        else
            addY = 1
        end
        if dx >= dy
            for i in 0...dx
                x += addX
                counter += dy
                if counter >= dx
                    y += addY
                    counter -= dx
                end
                unless $game_map.viewable?(x, y, d)
                    result = false unless (x == x2 && y == y2)
                    break
                end
            end
        else
            for i in 0...dy
                y += addY
                counter += dx
                if counter >= dy
                    x += addX
                    counter -= dy
                end
                unless $game_map.viewable?(x, y, d)
                    result = false unless (x == x2 && y == y2)
                    break
                end
            end
        end
        return result
    end
    #--------------------------------------------------------------------------
    def offset(x, min_x, max_x, y, min_y, max_y, px, py)
        t = Etude87_KMS_MiniMap::OUTLINE_THICKNESS
        return t unless Etude87_KMS_MiniMap::USE_OUTLINE
        if Etude87_KMS_MiniMap::EXCEPTION[$game_map.map_id]
            m = Etude87_KMS_MiniMap::EXCEPTION[$game_map.map_id]
            case m[0]
            when :square
                a = (x - min_x).abs if (x - min_x).abs < t
                b = (x - max_x).abs if (x - max_x).abs < t
                c = (y - min_y).abs if (y - min_y).abs < t
                d = (y - max_y).abs if (y - max_y).abs < t
            when :circle
                i = m[1] - Math.sqrt((px - x)**2 + (py - y)**2).to_i
                a = i if i < t
            when :lozenge
                a = m[1] - ((px - x).abs + (py - y).abs) if m[1] - ((px - x).abs + (py - y).abs) < t
            end
        else
            a = (x - min_x).abs if (x - min_x).abs < t
            b = (x - max_x).abs if (x - max_x).abs < t
            c = (y - min_y).abs if (y - min_y).abs < t
            d = (y - max_y).abs if (y - max_y).abs < t
        end
        return [a,b,c,d,t].compact.min
    end
    #--------------------------------------------------------------------------
    def clear_route
        @route = []
    end
    #--------------------------------------------------------------------------
end
#==============================================================================
#==============================================================================
class Game_Event < Game_Character
    #--------------------------------------------------------------------------
    attr_reader   :event
    #--------------------------------------------------------------------------
end
#==============================================================================
#==============================================================================
class Game_Map
    #--------------------------------------------------------------------------
    def viewable?(x, y, d)
        check_view(x, y, (1 << (d / 2 - 1)) & 0x0f)
    end
    #--------------------------------------------------------------------------
    def check_view(x, y, bit)
        all_tiles(x, y).each do |tile_id|
            unless events_xy(x, y).empty?
                ev = events_xy(x, y)[0]
                return false if ev.event.name.include?(Etude87_KMS_MiniMap::FOV_Ev_Name_Keyword) && ev.normal_priority?
            end
            return false if terrain_tag(x, y) == Etude87_KMS_MiniMap::Additional_Terrain_Tag
            flag = tileset.flags[tile_id]
            if flag & 0x10 != 0
                next if flag & bit == 0
            else
                return true if flag & bit == 0
            end
            return true  if terrain_tag(x, y) == Etude87_KMS_MiniMap::Exception_Terrain_Tag
            return false if tile_id >= 4352 && tile_id <= 8191 && Etude87_KMS_MiniMap::Roof_Wall
            return false if flag & bit == bit && Etude87_KMS_MiniMap::Auto_FOV
        end
        return false
    end
    #--------------------------------------------------------------------------
  def reveal_tiles(x, y, distance = Theo::VisiRange, reveal = true)
    return if no_fog?
    sprset = SceneManager.scene.spriteset
    sprset.fogofwar.reveal_fogs if sprset
  end
  #--------------------------------------------------------------------------
end
#==============================================================================
#==============================================================================
class Game_Player < Game_Character
    #--------------------------------------------------------------------------
    alias etude87_moveto moveto
    def moveto(x, y)
        etude87_moveto(x, y)
        @last_pos = [$game_map.map_id, @x, @y, 5]
        $game_system.add_route(@last_pos)
    end
    #--------------------------------------------------------------------------
    alias etude87_increase_steps increase_steps
    def increase_steps
        $game_system.add_route(@last_pos) if @last_pos
        @last_pos = [$game_map.map_id, @x, @y, @direction]
        etude87_increase_steps
    end
    #--------------------------------------------------------------------------
    alias etude87_reserve_transfer reserve_transfer
    def reserve_transfer(map_id, x, y, d = 2)
        etude87_reserve_transfer(map_id, x, y, d)
        $game_system.clear_route
    end
    #--------------------------------------------------------------------------
end
#==============================================================================
#==============================================================================
class Game_MiniMap
    #--------------------------------------------------------------------------
    alias etude87_create_sprites create_sprites
    def create_sprites
        unless Etude87_KMS_MiniMap::USE_TRIANGLE_POINT
            etude87_create_sprites
        else
            @viewport   = Viewport.new(@map_rect)
            @viewport.z = KMS_MiniMap::MAP_Z
            @bmp_size = Size.new(
                (@grid_num.x + 2) * @grid_size,
                (@grid_num.y + 2) * @grid_size
            )
            @buf_bitmap = Bitmap.new(@bmp_size.width, @bmp_size.height)
            @map_sprite   = Sprite.new(@viewport)
            @map_sprite.x = -@grid_size
            @map_sprite.y = -@grid_size
            @map_sprite.z = 0
            @map_sprite.bitmap = Bitmap.new(@bmp_size.width, @bmp_size.height)
            @object_sprite   = Sprite_MiniMapIcon.new(@viewport)
            @object_sprite.x = -@grid_size
            @object_sprite.y = -@grid_size
            @object_sprite.z = 1
            @object_sprite.bitmap = Bitmap.new(@bmp_size.width, @bmp_size.height)
            @position_sprite   = Sprite_MiniMapIcon.new
            @position_sprite.x = @map_rect.x + @grid_num.x / 2 * @grid_size
            @position_sprite.y = @map_rect.y + @grid_num.y / 2 * @grid_size
            @position_sprite.z = @viewport.z + 2
            bitmap = Bitmap.new(@grid_size, @grid_size)
            case Etude87_KMS_MiniMap::ALIGN_TRIANGLE_POINT
            when 0
                align_tp = 0
            when 1
                align_tp = @grid_size/4
            when 2
                align_tp = @grid_size/2
            end
            @last_dir = $game_player.direction
            for i in 0...(@grid_size/2 + @grid_size%2)
                case @last_dir
                when 2
                    bitmap.fill_rect(@grid_size/2-i, @grid_size-i-1-align_tp, 2*i+1, 1, KMS_MiniMap::POSITION_COLOR)
                when 4
                    bitmap.fill_rect(i+align_tp, @grid_size/2-i, 1, 2*i+1, KMS_MiniMap::POSITION_COLOR)
                when 6
                    bitmap.fill_rect(@grid_size-i-1-align_tp, @grid_size/2-i, 1, 2*i+1, KMS_MiniMap::POSITION_COLOR)
                when 8
                    bitmap.fill_rect(@grid_size/2-i, i+align_tp, 2*i+1, 1, KMS_MiniMap::POSITION_COLOR)
                end
            end
            @position_sprite.bitmap = bitmap
        end
    end
    #--------------------------------------------------------------------------
    alias etude87_update_position update_position
    def update_position
        etude87_update_position
        return unless Etude87_KMS_MiniMap::USE_TRIANGLE_POINT
        return unless @last_dir != $game_player.direction
        @position_sprite.bitmap.clear
        bitmap = Bitmap.new(@grid_size, @grid_size)
        case Etude87_KMS_MiniMap::ALIGN_TRIANGLE_POINT
        when 0
            align_tp = 0
        when 1
            align_tp = @grid_size/4
        when 2
            align_tp = @grid_size/2
        end
        @last_dir = $game_player.direction
        for i in 0...(@grid_size/2 + @grid_size%2)
            case @last_dir
            when 2
                bitmap.fill_rect(@grid_size/2-i, @grid_size-i-1-align_tp, 2*i+1, 1, KMS_MiniMap::POSITION_COLOR)
            when 4
                bitmap.fill_rect(i+align_tp, @grid_size/2-i, 1, 2*i+1, KMS_MiniMap::POSITION_COLOR)
            when 6
                bitmap.fill_rect(@grid_size-i-1-align_tp, @grid_size/2-i, 1, 2*i+1, KMS_MiniMap::POSITION_COLOR)
            when 8
                bitmap.fill_rect(@grid_size/2-i, i+align_tp, 2*i+1, 1, KMS_MiniMap::POSITION_COLOR)
            end
        end
        @position_sprite.bitmap = bitmap
    end
    #--------------------------------------------------------------------------
    alias etude87_draw_map_foreground draw_map_foreground
    def draw_map_foreground(bitmap)
        if Etude87_KMS_MiniMap::USE_FOG && Etude87_KMS_MiniMap::EXCEPTION[$game_map.map_id] != :none
            range_x = (@draw_range_begin.x)..(@draw_range_end.x)
            range_y = (@draw_range_begin.y)..(@draw_range_end.y)
            map_w   = $game_map.width  - 1
            map_h   = $game_map.height - 1
            rect    = Rect.new(0, 0, @grid_size, @grid_size)
            range_x.each { |x|
                next unless x.between?(0, map_w)
                next unless $game_system.drawable[$game_map.map_id][x]
                range_y.each { |y|
                    next unless y.between?(0, map_h)
                    next unless $game_system.drawable[$game_map.map_id][x][y]
                    next if @passage_table[x, y] == 0
                    next if @wall_events.find { |e| e.x == x && e.y == y }
                    
                    rect.set(0, 0, @grid_size, @grid_size)
                    rect.x = (x - @draw_range_begin.x) * @grid_size
                    rect.y = (y - @draw_range_begin.y) * @grid_size
                    flag = @passage_table[x, y]
                    if flag & 0x01 == 0
                        rect.height -= 1
                    end
                    if flag & 0x02 == 0
                        rect.x     += 1
                        rect.width -= 1
                    end
                    if flag & 0x04 == 0
                        rect.width -= 1
                    end
                    if flag & 0x08 == 0
                        rect.y      += 1
                        rect.height -= 1
                    end
                    color = outline_color($game_system.drawable[$game_map.map_id][x][y])
                    bitmap.fill_rect(rect, color)
                }
            }
        else
            etude87_draw_map_foreground(bitmap)
        end
        if Etude87_KMS_MiniMap::USE_MOVE_ROUTE
            if $game_system.route.size > 0
                for i in 0...$game_system.route.size
                    draw_route(bitmap, i)
                end
            end
        end
    end
    #--------------------------------------------------------------------------
    alias etude87_draw_map_move_event draw_map_move_event
    def draw_map_move_event(bitmap)
        if Etude87_KMS_MiniMap::USE_FOG
            rect = Rect.new(0, 0, @grid_size, @grid_size)
            @move_events.each { |e|
                rect.x = (e.x - @draw_range_begin.x) * @grid_size
                rect.y = (e.y - @draw_range_begin.y) * @grid_size
                bitmap.fill_rect(rect, KMS_MiniMap::MOVE_EVENT_COLOR) if map_visible?(e.x, e.y)
            }
        else
            etude87_draw_map_move_event(bitmap)
        end
    end
    #--------------------------------------------------------------------------
    alias etude87_draw_object draw_object
    def draw_object
        if Etude87_KMS_MiniMap::USE_FOG
            bitmap = @object_sprite.bitmap
            bitmap.clear
            rect = Rect.new(0, 0, @grid_size, @grid_size)
            @object_list.each { |obj|
                next unless in_draw_range?(obj.x, obj.y)
                color = KMS_MiniMap::OBJECT_COLOR[obj.minimap_object_type - 1]
                next if color.nil?
                rect.x = (obj.real_x - @draw_range_begin.x) * @grid_size
                rect.y = (obj.real_y - @draw_range_begin.y) * @grid_size
                bitmap.fill_rect(rect, color) if map_visible?(obj.real_x, obj.real_y)
            }
            $game_map.vehicles.each { |vehicle|
                next if vehicle.transparent
                rect.x = (vehicle.real_x - @draw_range_begin.x) * @grid_size
                rect.y = (vehicle.real_y - @draw_range_begin.y) * @grid_size
                bitmap.fill_rect(rect, KMS_MiniMap::VEHICLE_COLOR) if map_visible?(vehicle.real_x, vehicle.real_y)
            }
        else
            etude87_draw_object
        end
    end
    #--------------------------------------------------------------------------
    def outline_color(i)
        t = Etude87_KMS_MiniMap::OUTLINE_THICKNESS
        c1 = KMS_MiniMap::BACKGROUND_COLOR
        c2 = KMS_MiniMap::FOREGROUND_COLOR   
        red   = c2.red   + (c1.red   - c2.red)  /(t + 1) * (t - i)
        green = c2.green + (c1.green - c2.green)/(t + 1) * (t - i)
        blue  = c2.blue  + (c1.blue  - c2.blue) /(t + 1) * (t - i)
        alpha = c2.alpha + (c1.alpha - c2.alpha)/(t + 1) * (t - i)
        return Color.new(red, green, blue, alpha)
    end
    #--------------------------------------------------------------------------
    def map_visible?(x, y)
        return false unless $game_system.drawable[$game_map.map_id]
        return false unless $game_system.drawable[$game_map.map_id][x]
        return false unless $game_system.drawable[$game_map.map_id][x][y]
        return true
    end
    #--------------------------------------------------------------------------
    def draw_route(bitmap, i)
        a = i+1 < $game_system.route.size ? $game_system.route[i+1][3] : $game_player.direction
        r = $game_system.route[i]
        x = (r[1] - @draw_range_begin.x) * @grid_size
        y = (r[2] - @draw_range_begin.y) * @grid_size
        draw_line(bitmap, x, y, a, i)
        draw_line(bitmap, x, y, 10-r[3], i)
    end
    #--------------------------------------------------------------------------
    def draw_line(bitmap, x, y, dir, i)
        t = Etude87_KMS_MiniMap::LINE_THICKNESS
        l = ((@grid_size - t) - (@grid_size - t)%2)/2 + t
        case dir
        when 2
            rect = Rect.new(0, 0, t, l)
            rect.x = x + l - t
            rect.y = y + l - t
        when 4
            rect = Rect.new(0, 0, l, t)
            rect.x = x
            rect.y = y + l - t
        when 6
            rect = Rect.new(0, 0, l, t)
            rect.x = x + l - t
            rect.y = y + l - t
        when 8
            rect = Rect.new(0, 0, t, l)
            rect.x = x + l - t
            rect.y = y
        end
        bitmap.fill_rect(rect, line_color(KMS_MiniMap::FOREGROUND_COLOR, Etude87_KMS_MiniMap::MOVE_ROUTE_COLOR, i)) if rect
    end
    #--------------------------------------------------------------------------
    def line_color(c1, c2, i)
        return c2 unless Etude87_KMS_MiniMap::USE_TRANSPARENCY
        red = c2.red + (c1.red - c2.red)/$game_system.route.size * ($game_system.route.size - i)
        green = c2.green + (c1.green - c2.green)/$game_system.route.size * ($game_system.route.size - i)
        blue = c2.blue + (c1.blue - c2.blue)/$game_system.route.size * ($game_system.route.size - i)
        alpha = c2.alpha + (c1.alpha - c2.alpha)/$game_system.route.size * ($game_system.route.size - i)
        return Color.new(red, green, blue, alpha)
    end
    #--------------------------------------------------------------------------
end
#==============================================================================
#==============================================================================
class Fog_of_War < Plane
  #----------------------------------------------------------------------------
  def update_bitmap
    bmp = @@bitmap_cache[@id]
    unless bmp && !bmp.disposed?
      bmp = Bitmap.new(@width * 32, @height * 32)
      @@bitmap_cache[@id] = bmp
    end
    self.bitmap = bmp
    return if $game_map.no_fog?
    bitmap.entire_fill(Color.new(0,0,0,Theo::FogOpacity))
    reveal_fogs
  end
  #----------------------------------------------------------------------------
  def reveal_fogs
    for x in 0..@width
      for y in 0..@height
        next unless ($game_system.drawable[$game_map.map_id][x] && $game_system.drawable[$game_map.map_id][x][y])
        width = 32
        height = 32
        fog_x = x * width
        fog_y = y * height
        bitmap.clear_rect(fog_x,fog_y,width,height)
        if $game_system.drawable[$game_map.map_id][x] && $game_system.drawable[$game_map.map_id][x][y]
          t = Etude87_KMS_MiniMap::OUTLINE_THICKNESS
          i = $game_system.drawable[$game_map.map_id][x][y]
          alpha = 255 / (t + 1) * (t - i)
          bitmap.fill_rect(fog_x,fog_y,width,height,Color.new(0,0,0,alpha)) if alpha > 0
        end
      end
    end unless disposed?
  end
  #----------------------------------------------------------------------------
end