Sprite_Vision 地图视野

kvkv97

[pre lang="Ruby"]
#======================================   
# Sprite_Vision 地图视野   
# 作者: viktor   
# 原创脚本。仅供讨论使用，不可以用于商用。转载请注明出处/暂时不对脚本进行更多的解释了。   
# 设置视野方法：使用地图标记，原则是地图标记越大，高度越高。   
#   
# 最低的地面：0   
# 墙：比下方的地面高1   
# 竖直墙的顶部：比下方的墙高1   
# 高地：与在高地下侧的竖直墙顶部高度相同。这样在高地上可以看到下面的东西   
# 背后可通行的障碍物（如树木）：可通行的部分与周围地面相同，底部+1   
#   
# 例如：   
# 样例中的地面（浅绿草地）：0   
# 石头墙：1   
# 石头墙顶部：2   
# 高地（绿草地）：2   
# 高地上的树：树根3 树冠2   
# 山顶的草：3   
#======================================   
#$Call_fillshadow = Win32API.new("bmp", "fill_shadow", 'lllli', 'i')   
$width = 640 if $width == nil  
$height = 480 if $height == nil  
  
class Sprite_Vision < Sprite  
# 配置   
# 脚本开关   
SWITCH = 30  
# 渐变速率   
STEP = 0.1  
# 平滑开关   
SMOOTH = true  
# 可变配置   
def init_param  
    # directional lighting   
    # [前 侧 后]方向的最大亮度   
    @lighting=[255, 160, 64]  
    @directional = [[0, 1, 1, 2],  
                    [1, 0, 2, 1],  
                    [1, 2, 0, 1],  
                    [2, 1, 1, 0]]  
    # 由近到远的亮度变化率。1表示不改变（可以看到前方无限远）   
    @rate = 1.0  
    # 阈值:小于此亮度的格子不可见   
    @threshold = 0  
    # 视野阴影的z值。如果遮挡了窗口需要调整这个。   
    self.z=10  
end  
# 直接修改init_param中的参数的方法。每秒至多调用一次因为有refresh   
def set_param(param, value)  
  self.instance_variable_set(param, value)  
  refresh  
end  
# 经验公式。设置视野范围 0..1 为近..远 每秒至多调用一次因为有refresh   
def set_range(param)  
  @threshold = (64 * (1.0 - param)).to_i  
  @rate = 0.4 + 0.6 * param  
  refresh  
end  
  
    def initialize(viewport, tilemap)  
        super(viewport)  
        @tilemap = tilemap  
        init_param  
        init_cache  
  
        self.bitmap = Bitmap.new(@tilemap.map_data.xsize * 32,  
                                 @tilemap.map_data.ysize * 32)  
        self.bitmap.fill_rect(self.bitmap.rect, @gray[255])  
        # 内部亮度矩阵，存放各个角色看到的亮度的最大值   
        @brightness = Table.new(@tilemap.map_data.xsize, @tilemap.map_data.ysize)  
        # 显示亮度矩阵   
        @disp = Table.new(@tilemap.map_data.xsize, @tilemap.map_data.ysize)  
        # 玩家位置   
        @cx = -1; @cy = -1  
        # 跟随的玩家数量初始化为1   
        init_br(1)  
        # 设置绘制方法   
        @update_func = SMOOTH ? self.method(:smooth_update) :   
                                self.method(:rough_update)  
        # 刷新列表初始化   
        @xlist=[0]*1000  
        @ylist=[0]*1000  
        @blist=[0]*1000  # 亮度   
        @tlist=[1]*1000  # 是否要刷新。正数为需要   
        @list_size = 0  
  
        refresh  
    end  
  
    def dispose  
        self.bitmap.dispose if self.bitmap != nil  
        super  
    end  
  
    def init_cache  
        srand; @Gray = []  
        # 颜色对象           
        (0..255).each{|x|@gray.push(Color.new(46, 29, 27, x))}  
        # 测试用颜色对象   
        # (0..255).each{|a| @gray.push(Color.new(rand(255), rand(255), rand(255), 64))}   
  
        # 地图标记   
        @tags = Table.new(@tilemap.map_data.xsize, @tilemap.map_data.ysize)  
        for x in 0...@tags.xsize  
            for y in 0...@tags.ysize  
                @tags[x, y]=$game_map.terrain_tag(x, y)  
            end  
        end  
    end  
  
    def init_br(n)  
        # multiple lighting   
        # 初始化每个角色的亮度矩阵   
        @br=Table.new(@tilemap.map_data.xsize, @tilemap.map_data.ysize, n)  
        @nc = n  
        @current = 0  
    end  
  
    # 取某方向的最大亮度   
    def base_brightness(direction)  
        return @lighting[@directional[$game_player.direction/2-1][direction/2-1]]  
    end  
    # 计算刷新矩形   
    def count_refresh_rect  
        @min_x = $game_map.display_x / 128  
        @min_y = $game_map.display_y / 128  
        @max_x = @min_x + $width / 32  
        @max_y = @min_y + $height / 32  
        # 调整   
        case $game_player.direction  
        when 2  
            @max_y += 3  
        when 4  
            @min_x -= 3  
        when 6  
            @max_x += 3  
        when 8  
            @min_y -= 3  
        end  
        # 剪裁，规范化   
        @min_x = [@min_x, 0].max.to_i  
        @min_y = [@min_y, 0].max.to_i  
        @max_x = [@max_x, @tilemap.map_data.xsize].min.to_i  
        @max_y = [@max_y, @tilemap.map_data.ysize].min.to_i  
    end  
  
    def set_brightness(x, y)  
        # 设置内部亮度值   
        m=0  
        (0...@nc).each{|z|  
            m=[m, @br[x, y, z]].max  
        }  
        @brightness[x, y]=m  
        # 更新刷新列表   
        if m != @disp[x, y]  
            @xlist[@list_size] = x  
            @ylist[@list_size] = y  
            @list_size += 1  
        end  
    end  
  
    def refresh  
        @cx = $game_player.x  
        @cy = $game_player.y  
        @list_size = 0  
  
        count_refresh_rect  
        @br[@cx, @cy, @current] = 255  
        set_brightness(@cx, @cy)  
        @ctag = @tags[@cx, @cy]  
        # 四方向预处理   
        b=base_brightness(2)  
        (@cy+1...@max_y).to_a.each{|y|  
            @br[@cx, y, @current] = b  
            set_brightness(@cx, y)  
            b *= @rate  
            break if @tags[@cx, y] > @ctag  
        }  
  
        b=base_brightness(4)  
        (@min_x...@cx).to_a.reverse_each{|x|  
            @br[x, @cy, @current] = b  
            set_brightness(x, @cy)  
            b *= @rate  
            break if @tags[x, @cy] > @ctag  
        }  
  
        b=base_brightness(6)  
        (@cx+1...@max_x).to_a.each{|x|  
            @br[x, @cy, @current] = b  
            set_brightness(x, @cy)  
            b *= @rate  
            break if @tags[x, @cy] > @ctag  
        }  
  
        b=base_brightness(8)  
        ref_tag = @ctag + 1  
        (@min_y...@cy).to_a.reverse_each{|y|  
            @br[@cx, y, @current] = b  
            set_brightness(@cx, y)  
            b *= @rate  
            this_tag = @tags[@cx, y]  
            break if this_tag > ref_tag  
            # ref_tag = [this_tag, ref_tag].max   
        }  
  
        # 填充其他格子   
        # up-right   
        iterate_tiles(@cx+1...@max_x,  
                      (@min_y...@cy).to_a.reverse,  
                      1, -1) # rescue p @min_y, @cy   
        # up-left   
        iterate_tiles((@min_x...@cx).to_a.reverse,  
                      (@min_y...@cy).to_a.reverse,  
                      -1, -1)  
        # down-left   
        iterate_tiles((@min_x...@cx).to_a.reverse,  
                      @cy+1...@max_y,  
                      -1, 1)  
        # down-right   
        iterate_tiles(@cx+1...@max_x,   
                      @cy+1...@max_y,  
                      1, 1)  
         
        # 滚动   
        @current = (@current + 1) % @nc  
    end  
  
    def iterate_tiles(xarray, yarray, dx, dy)  
      ref_tag = @ctag  
      for y in yarray  
        for x in xarray  
          tag1 = @tags[x - dx, y]  
          tag2 = @tags[x, y - dy]  
            
          # 墙判定   
          br1 = tag1 > @ctag ? 0 : @br[x-dx, y, @current]  
          br2 = tag2 > ref_tag ? 0 : @br[x, y-dy, @current]  
   
          ref_tag = tag2 if dy==-1 and ref_tag < tag2  
            
          # 计算亮度   
          tmp = (br1 + br2) / 2  
          @br[x, y, @current] = (tmp>@threshold?tmp:0)  
          set_brightness(x, y)  
        end  
      end  
    end  
      
    def update_bitmap(step=STEP)  
        new_size=0  
        for i in 0...@list_size  
            x = @xlist; y = @ylist  
            diff = @brightness[x, y] - @disp[x, y]  
            if diff!=0  
              @disp[x, y] += [diff.abs*step, 1].max.to_i * (diff<=>0)  
              @xlist[new_size]=x; @ylist[new_size]=y;  
              @blist[new_size]=@disp[x, y]  
              self.bitmap.fill_rect(x*32, y*32, 32, 32, @gray[255-@blist[new_size]])  
              #self.bitmap.draw_text(x*32, y*32, 32, 32, @tags[x, y].to_s, 1)   
              new_size += 1  
            end  
        end  
         
        @list_size = new_size  
        # puts new_size   
        # 调用dll   
        #$Call_fillshadow.call(self.bitmap.object_id,   
        #            @xlist.object_id, @ylist.object_id, @blist.object_id,   
        #            @list_size)   
    end  
  
    def smooth_update  
        # 移动时刷新视野数据   
        refresh if $game_player.x != @cx or $game_player.y != @cy  
        # 每一帧平滑刷新视野图形   
        update_bitmap  
    end  
    def rough_update  
        # 移动时刷新视野数据   
        if $game_player.x != @cx or $game_player.y != @cy  
          refresh   
          update_bitmap  
        end  
    end      
    def update  
      @update_func.call  
      super  
    end  
end  
  
# 接入部分   
class Spriteset_Map  
  attr_accessor :vision_sprite  
   
  def update_vision  
    if @vision_sprite==nil  
      @vision_sprite=Sprite_Vision.new(@viewport1, @tilemap)  
      @vision_sprite.init_br($game_party.actors.size)  
      @vision_sprite.opacity=0  
    end  
    if $game_switches[Sprite_Vision::SWITCH]  
      @vision_sprite.visible=true  
      @vision_sprite.opacity+=10 if @vision_sprite.opacity < 255  
      @vision_sprite.ox=$game_map.display_x / 4  
      @vision_sprite.oy=$game_map.display_y / 4  
      @vision_sprite.update  
    else  
      if @vision_sprite!=nil  
        @vision_sprite.opacity-=10  
        @vision_sprite.visible=false if @vision_sprite.opacity<30  
      end  
    end  
  end  
   
  alias viktor_vision_update update  
  def update  
    update_vision  
    viktor_vision_update  
  end  
   
  alias viktor_vision_dispose dispose  
  def dispose  
    @vision_sprite.dispose if @vision_sprite!=nil  
    viktor_vision_dispose  
  end  
end  
  
class Scene_Map  
  attr_accessor :spriteset  
end   
[/pre]

linwsh123

顶  虽然还看不懂，但是必须支持

锡鹏

没什么用啊，

牛肉面

啊，这个脚本要怎么使用呢？