Khas Awesome Light Effects 脚本的使用教程

Blois233

我是很早以前不知道在哪找的。。
站里大多是一些使用脚本时出现的问题，没有具体教程
因为RGSS3只学了皮毛所以半看半蒙试了一下发现并不行
所以想求个具体教程
下面附上脚本


#-------------------------------------------------------------------------------
# * [ACE] Khas Awesome Light Effects
#-------------------------------------------------------------------------------
# * By Khas Arcthunder - arcthunder.site40.net
# * Version: 1.0 EN
# * Released on: 17/01/2012
#
#-------------------------------------------------------------------------------
# * Terms of Use
#-------------------------------------------------------------------------------
# When using any Khas script, you agree with the following terms:
# 1. You must give credit to Khas;
# 2. All Khas scripts are licensed under a Creative Commons license;
# 3. All Khas scripts are for non-commercial projects. If you need some script
#    for your commercial project (I accept requests for this type of project),
#    send an email to [email protected] with your request;
# 4. All Khas scripts are for personal use, you can use or edit for your own
#    project, but you are not allowed to post any modified version;
# 5. You can’t give credit to yourself for posting any Khas script;
# 6. If you want to share a Khas script, don’t post the direct download link,
#    please redirect the user to arcthunder.site40.net
#
#-------------------------------------------------------------------------------
# * Features
#-------------------------------------------------------------------------------
# - Realistic Light
# - Light does not pass over walls, blocks and roofs
# - Static Light Sources
# - Dynamic Light Sources (like a player's lantern)
# - Multiple effects
# - Easy to use (comments)
#
#-------------------------------------------------------------------------------
# * WARNING - Performance
#-------------------------------------------------------------------------------
# This script may be too heavy to old processors! The Awesome Light Effects was
# tested on a Core 2 Duo E4500 and on a Core i5, without any lag. However,
# there's other factors that may influence the script performance:
#
# 1. Map size
# This script searches surfaces on the map, in order to cut the light pictures.
# In a huge map, the number of surfaces may increase a lot, affecting the
# DYNAMIC LIGHT SOURCE only. Map size does not influence the static sources.
#
# 2. Number of effects
# This script draws the effects on the screen, but before drawing, it checks
# if the effect is out of screen (in this case, the script will skip the
# light drawing). Too much effects may cause lag, but this is just a prevision.
#
# 3. Effect's picture size
# The picture size of the DYNAMIC LIGHT SOURCE influences directly on your
# game's performace. The bigger is the picture, the slower it will be to
# draw it dynamically. The recommended maximum size is 200x200 pixels
#
#-------------------------------------------------------------------------------
# * WARNING - Light pictures
#-------------------------------------------------------------------------------
# In order to run this script correctly, the light pictures MUST obey the
# following conditions:
# 1. The picture's size MUST be multiple of 2. Example: 150x150
# 2. The picture's width MUST be equal to it's height. Example: 156x156
# 3. The picture's colors MUST be inverted! This is necessary because
#    the script inverts the colors to draw the effect. The black color
#    will be transparent!
#
#-------------------------------------------------------------------------------
# * Instructions - 1. Setup your effects!
#-------------------------------------------------------------------------------
# In order to setup your static effects, go to the setup part and define your
# effects inside the Effects hash. Do as the following mode:
#
# X => [picture,opacity,variation,cut],   <= Remember to put a comma here!
#
# Where:
# picture => Picture's name, inside the Graphics/Lights folder;
# opacity => Effect's opacity;
# variation => Effect's opacity variation;
# cut => Put true to cut the effect or false to don't;
# X => The effect's ID, it will be used on events.
#
# Check the default effects to understand how they work.
#
#-------------------------------------------------------------------------------
# * Instructions - 2. Use your effects!
#-------------------------------------------------------------------------------
# In order to use a effect, put the following comment on a event:
#
# [light x]
#
# Where x must be the Effect's ID.
#
#-------------------------------------------------------------------------------
# * Instructions - 3. Use an awesome lantern!
#-------------------------------------------------------------------------------
# The dynamic light source (lantern) is initialized invisible by default.
# You may call the following commands:
#
# l = $game_map.lantern
# Gets the lantern into a variable

# l.set_graphic(i)
# Sets the lantern's graphic to i, where i must be the picture's file name on
# Graphics/Lights folder.
#
# l.set_multiple_graphics(h)
# Sets the lantern's graphics to h, where h must be a hash with the following
# structure:
#
# h = {2=>"ld",4=>"ll",6=>"lr",8=>"lu"}
#
# Where:
# "ld" is the name of the picture when the lantern's owner is looking down;
# "ll" is the name of the picture when the lantern's owner is looking left;
# "lr" is the name of the picture when the lantern's owner is looking right;
# "lu" is the name of the picture when the lantern's owner is looking up.
#
# l.change_owner(char)
# Sets the lantern's owner to char. Char must be ONE of the following commands:
# $game_player           <= The player itself;
# self_event             <= The event where the command was called;
# $game_map.events[x]    <= The event ID x.
#
# l.set_opacity(o,p)
# Sets the lantern's opacity, where:
# o is the opacity itself;
# p is the opacity variation.
#
# l.show
# After setting the lantern with the commands above, you may set it to visible
# using this command.
#
# l.hide
# Use this command to set the lantern as invisible.
#
#-------------------------------------------------------------------------------
# * Instructions - 4. Use the effect's surface!
#-------------------------------------------------------------------------------
# The Awesome Light Effects draws the effects on a surface. In order to make
# the effects visible, the effect's surface MUST be visible. The Effect's
# Surface is initialized with it's opacity set to zero. You can call the
# following commands:
#
# s = $game_map.effect_surface
# Gets the Effect's Surface into a variable
#
# s.set_color(r,g,b)
# Changes the Effect's Surface color instantly, where:
# r => red level;
# g => green level;
# b => blue level;
#
# s.set_alpha(a)
# Changes the Effect's Surface opacity instantly to a.
#
# s.change_color(time,r,g,b)
# Changes the Effect's Surface color ONLY in a certain time, where:
# time => The change's time (frames);
# r => red level;
# g => green level;
# b => blue level;
#
# s.change_color(time,r,g,b,a)
# Changes the Effect's Surface color and it's opacity in a certain time, where:
# time => The change's time (frames);
# r => red level;
# g => green level;
# b => blue level;
# a => opacity
#
# s.change_alpha(time,a)
# Changes the Effect's Surface opacity in a certain time, where:
# time => The change's time (frames);
# a => opacity
#
#-------------------------------------------------------------------------------
# * Instructions - 5. Use the effect's surface with Tone command!
#-------------------------------------------------------------------------------
# You can access the Effect's Surface with the "Screen Tone" command. In order
# to turn this feature on, set the "Surface_UE" constant to true.
#
# If you decided to use this feature, please note some details:
# 1. The colors values must be between 0 and 255;
# 2. The time is in frames;
# 3. The "gray" value will be sent as the opacity value
#
#-------------------------------------------------------------------------------
# * Instructions - 6. Setup your Tileset Tags!
#-------------------------------------------------------------------------------
# In order to cut the effect's picture correctly, there's 3 types of behavior
# for a tile: wall, block and roof. Walls will make shadows as real walls,
# blocks as blocks and roofs as roofs. So, the tileset tags MUST be configured.
# Check the demo to understand how this system works. If the tilesets aren't
# configured correctly, the script won't cut the effects correctly.
#
#-------------------------------------------------------------------------------
# * Setup Part
#-------------------------------------------------------------------------------
module Light_Core
  Effects = { #  <= DON'T change this!
#-------------------------------------------------------------------------------
# PUT YOUR EFFECTS HERE!
#-------------------------------------------------------------------------------
  0 => ["light",255,0,true],
  1 => ["torch",200,20,true],
  2 => ["torch_m",180,30,true],
  3 => ["light_s",255,0,true],

#-------------------------------------------------------------------------------
# End of effecs configuration
#-------------------------------------------------------------------------------
  } #  <= DON'T change this!

  # Z coordinate of the Effect's Surface
  Surface_Z = 180
  # Enable Effect's Surface control by "Screen Tone" command?
  Surface_UE = true

  # Roof behavior tag
  Roof_Tag = 5
  # Wall behavior tag
  Wall_Tag = 6
  # Block behavior tag
  Block_Tag = 7

  # Don't change this!
  ACC = Math.tan(Math::PI/26)
end
#-------------------------------------------------------------------------------
# Script
#-------------------------------------------------------------------------------
module Cache
  def self.light(filename)
    load_bitmap("Graphics/Lights/", filename)
  end
end
module Light_Bitcore
  include Light_Core
  def self.initialize
    @@buffer = {}
    Effects.values.each { |effect| Light_Bitcore.push(effect[0])}
  end
  def self::[](key)
    return @@buffer[key]
  end
  def self.push(key)
    return if @@buffer.keys.include?(key)
    @@buffer[key] = Cache.light(key)
  end
end
Light_Bitcore.initialize
class Light_SSource
  attr_reader :real_x
  attr_reader :real_y
  attr_reader :range
  attr_accessor :bitmap
  attr_reader :w
  attr_reader :h
  attr_reader :hs
  def initialize(char,bitmap,opacity,plus,hs)
    sync(char)
    @KEY = bitmap
    @bitmap = Light_Bitcore[@key].clone
    @range = @bitmap.width/2
    @w = @bitmap.width
    @h = @bitmap.height
    @mr = @range - 16
    @opacity = opacity
    @plus = plus
    @hs = hs
    render if @hs
  end
  def render
    tx = x
    ty = y
    tsx = x + @range
    tsy = y + @range
    dr = @range*2
    for s in $game_map.surfaces
      next if !s.visible?(tsx,tsy) || !s.within?(tx,tx+dr,ty,ty+dr)
      s.render_shadow(tx,ty,tsx,tsy,@range,@bitmap)
    end
  end
  def restore
    return unless @bitmap.nil?
    @bitmap = Light_Bitcore[@key].clone
    render if @hs
  end
  def opacity
    @plus == 0 ? @opacity : (@opacity + rand(@plus))
  end
  def sx
    return $game_map.adjust_x(@real_x)*32-@mr
  end
  def sy
    return $game_map.adjust_y(@real_y)*32-@mr
  end
  def sync(char)
    @real_x = char.real_x
    @real_y = char.real_y
  end
  def x
    return (@real_x*32 - @mr).to_f
  end
  def y
    return (@real_y*32 - @mr).to_f
  end
  def dispose
    return if @bitmap.nil?
    @bitmap.dispose
    @bitmap = nil
  end
end
class Light_DSource < Light_SSource
  attr_reader :bitmap
  attr_reader :visible
  def initialize
    @key = nil
    @bitmap = nil
    @opacity = 255
    @plus = 0
    @CHAR = $game_player
    @visible = false
  end
  def set_opacity(o,p)
    @opacity = o
    @plus = p
  end
  def set_graphic(sb)
    dispose
    @key = {2=>sb,4=>sb,6=>sb,8=>sb}
    Light_Bitcore.push(sb)
    @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
    @range = @bitmap[2].width/2
    @w = @bitmap[2].width
    @h = @bitmap[2].height
    @mr = @range - 16
  end
  def set_multiple_graphics(ba)
    dispose
    @key = ba
    @key.values.each {|key| Light_Bitcore.push(key)}
    @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
    @range = @bitmap[2].width/2
    @w = @bitmap[2].width
    @h = @bitmap[2].height
    @mr = @range - 16
  end
  def get_graphic
    return @bitmap[@char.direction].clone
  end
  def show
    return if @bitmap.nil?
    @visible = true
  end
  def hide
    @visible = false
  end
  def restore
    return if @key.nil?
    @key.values.each {|key| Light_Bitcore.push(key)}
    @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
  end
  def dispose
    return if @bitmap.nil?
    @bitmap.values.each { |b| b.dispose }
    @bitmap = nil
  end
  def change_owner(char)
    @char = char
  end
  def render
  end
  def sx
    return $game_map.adjust_x(@char.real_x)*32-@mr
  end
  def sy
    return $game_map.adjust_y(@char.real_y)*32-@mr
  end
  def x
    return (@char.real_x*32 - @mr).to_f
  end
  def y
    return (@char.real_y*32 - @mr).to_f
  end
end
class Light_Surface
  def initialize
    @ta = @a = 0
    @tr = @r = 255
    @tg = @g = 255
    @tb = @b = 255
    @va = @vr = @vg = @vb = 0.0
    @timer = 0
  end
  def refresh
    return if @timer == 0
    @a += @va
    @r += @vr
    @g += @vg
    @b += @vb
    $game_map.light_surface.opacity = @a
    @timer -= 1
  end
  def change_color(time,r,g,b,a=nil)
    r = 0 if r < 0; r = 255 if r > 255
    g = 0 if g < 0; g = 255 if g > 255
    b = 0 if b < 0; b = 255 if b > 255
    unless a.nil?
      a = 0 if a < 0; a = 255 if a > 255
    end
    @timer = time
    @tr = 255-r
    @tg = 255-g
    @tb = 255-b
    @va = (a.nil? ? 0 : (a-@a).to_f/@timer)
    @vr = (@tr - @r).to_f/@timer
    @vg = (@tg - @g).to_f/@timer
    @vb = (@tb - @b).to_f/@timer
  end
  def change_alpha(time,a)
    a = 0 if a < 0; a = 255 if a > 255
    @timer = time
    @ta = a
    @vr = @vg = @vb = 0.0
    @va = (a-@a).to_f/@timer
  end
  def set_color(r,g,b)
    r = 0 if r < 0; r = 255 if r > 255
    g = 0 if g < 0; g = 255 if g > 255
    b = 0 if b < 0; b = 255 if b > 255
    @tr = @r = 255-r
    @tg = @g = 255-g
    @tb = @b = 255-b
    @va = @vr = @vg = @vb = 0.0
    @timer = 0
  end
  def set_alpha(a)
    a = 0 if a < 0; a = 255 if a > 255
    @ta = @a = a
    $game_map.light_surface.opacity = @a
    @va = @vr = @vg = @vb = 0.0
    @timer = 0
  end
  def alpha
    return @a
  end
  def color
    return Color.new(@r,@g,@b)
  end
end
class Game_Map
  include Light_Core
  attr_accessor :light_surface
  attr_accessor :light_sources
  attr_accessor :surfaces
  attr_accessor :effect_surface
  attr_accessor :lantern
  alias kbl_setup_events setup_events
  alias kbl_initialize initialize
  alias kbl_update update
  def initialize
    kbl_initialize
    @effect_surface = Light_Surface.new
    @lantern = Light_DSource.new
  end
  def update(arg)
    @effect_surface.refresh if arg
    kbl_update(arg)
  end
  def first_tag(x,y)
    tag = tileset.flags[tile_id(x,y,0)] >> 12
    return tag > 0 ? tag : 0
  end
  def setup_events
    @light_sources.nil? ? @light_sources = [] : @light_sources.clear
    setup_surfaces
    merge_surfaces
    kbl_setup_events
  end
  def setup_surfaces
    @surfaces = []
    for x in 0..(width-1)
      for y in 0..(height-1)
        tag = first_tag(x,y)
        if tag == Wall_Tag
          i = tile_id(x,y,0)
          if i & 0x02 == 0x02
            @surfaces << Block_SD.new(x*32,y*32,x*32+32,y*32)
          end
          if i & 0x04 == 0x04
            @surfaces << Block_WR.new(x*32+31,y*32,x*32+31,y*32+32)
            @surfaces << Block_IL.new(x*32+32,y*32,x*32+32,y*32+32)
          end
          if i & 0x01 == 0x01
            @surfaces << Block_IR.new(x*32-1,y*32,x*32-1,y*32+32)
            @surfaces << Block_WL.new(x*32,y*32,x*32,y*32+32)
          end
        elsif tag == Roof_Tag
          i = tile_id(x,y,0)
          @surfaces << Block_SU.new(x*32,y*32,x*32+32,y*32) if i & 0x02 == 0x02
          @surfaces << Block_SR.new(x*32+31,y*32,x*32+31,y*32+32) if i & 0x04 == 0x04
          @surfaces << Block_SL.new(x*32,y*32,x*32,y*32+32) if i & 0x01 == 0x01
        elsif tag == Block_Tag
          f = tileset.flags[tile_id(x,y,0)]
          @surfaces << Block_SL.new(x*32,y*32,x*32,y*32+32) if f & 0x02 == 0x02
          @surfaces << Block_SR.new(x*32+31,y*32,x*32+31,y*32+32) if f & 0x04 == 0x04
          @surfaces << Block_SU.new(x*32,y*32,x*32+32,y*32) if f & 0x08 == 0x08
        end
      end
    end
  end
  def merge_surfaces
    new_surfaces = []
    hs = []; vs = []
    ws = []; is = []
    for surface in @surfaces
      if surface.type & 0x05 == 0
        hs << surface
      else
        if surface.type & 0x010 == 0
          vs << surface
        else
          if surface.type & 0x08 == 0
            ws << surface
          else
            is << surface
          end
        end
      end
    end
    for surface in hs
      surface.ready ? next : surface.ready = true
      for s in hs
        next if s.ready || s.y1 != surface.y1 || surface.type != s.type
        if s.x2 == surface.x1
          surface.x1 = s.x1
          s.trash = true
          s.ready = true
          surface.ready = false
        elsif s.x1 == surface.x2
          surface.x2 = s.x2
          s.trash = true
          s.ready = true
          surface.ready = false
        end
      end
    end
    hs.each { |s| @surfaces.delete(s) if s.trash}
    for surface in vs
      surface.ready ? next : surface.ready
      for s in vs
        next if s.ready || s.x1 != surface.x1
        if s.y2 == surface.y1
          surface.y1 = s.y1
          s.trash = true
          s.ready = true
          surface.ready = false
        elsif s.y1 == surface.y2
          surface.y2 = s.y2
          s.trash = true
          s.ready = true
          surface.ready = false
        end
      end
    end
    vs.each { |s| @surfaces.delete(s) if s.trash}
    for surface in ws
      surface.ready ? next : surface.ready
      for s in ws
        next if s.ready || s.x1 != surface.x1
        if s.y2 == surface.y1
          surface.y1 = s.y1
          s.trash = true
          s.ready = true
          surface.ready = false
        elsif s.y1 == surface.y2
          surface.y2 = s.y2
          s.trash = true
          s.ready = true
          surface.ready = false
        end
      end
    end
    ws.each { |s| @surfaces.delete(s) if s.trash}
    for surface in is
      surface.ready ? next : surface.ready
      for s in is
        next if s.ready || s.x1 != surface.x1
        if s.y2 == surface.y1
          surface.y1 = s.y1
          s.trash = true
          s.ready = true
          surface.ready = false
        elsif s.y1 == surface.y2
          surface.y2 = s.y2
          s.trash = true
          s.ready = true
          surface.ready = false
        end
      end
    end
    is.each { |s| @surfaces.delete(s) if s.trash}
  end
end
class Game_Event < Game_Character
  alias kbl_initialize initialize
  alias kbl_setup_page setup_page
  def initialize(m,e)
    @light = nil
    kbl_initialize(m,e)
  end
  def setup_page(np)
    kbl_setup_page(np)
    setup_light(np.nil?)
  end
  def setup_light(dispose)
    unless @light.nil?
      $game_map.light_sources.delete(self)
      @light.dispose
      @light = nil
    end
    unless dispose && @list.nil?
      for command in @list
        if command.code == 108 && command.parameters[0].include?("[light")
          command.parameters[0].scan(/\[light ([0.0-9.9]+)\]/)
          effect = Light_Core::Effects[$1.to_i]
          @light = Light_SSource.new(self,effect[0],effect[1],effect[2],effect[3])
          $game_map.light_sources << self
          return
        end
      end
    end
  end
  def draw_light
    sx = @light.sx
    sy = @light.sy
    w = @light.w
    h = @light.h
    return if sx > 544 && sy > 416 && sx + w < 0 && sy + h < 0
    $game_map.light_surface.bitmap.blt(sx,sy,@light.bitmap,Rect.new(0,0,w,h),@light.opacity)
  end
  def dispose_light
    @light.dispose
  end
  def restore_light
    @light.restore
  end
end
if Light_Core::Surface_UE
  class Game_Interpreter
    def command_223
      $game_map.effect_surface.change_color(@params[1],@params[0].red,@params[0].green,@params[0].blue,@params[0].gray)
      wait(@params[1]) if @params[2]
    end
  end
end
class Game_Interpreter
  def self_event
    return $game_map.events[@event_id]
  end
end
class Block_Surface
  include Light_Core
  attr_accessor :x1
  attr_accessor :y1
  attr_accessor :x2
  attr_accessor :y2
  attr_accessor :ready
  attr_accessor :trash
  def initialize(x1,y1,x2,y2)
    @x1 = x1
    @y1 = y1
    @x2 = x2
    @y2 = y2
    @ready = false
    @trash = false
  end
  def within?(min_x,max_x,min_y,max_y)
    return @x2 > min_x && @x1 < max_x && @y2 > min_y && @y1 < max_y
  end
end
class Block_SL < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x01
  end
  def visible?(sx,sy)
    return sx < @x1
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    @m1 = (@y1-sy)/(@x1-sx)
    @n1 = sy - @m1*sx
    @m2 = (@y2-sy)/(@x2-sx)
    @n2 = sy - @m2*sx
    for x in @x1..(sx+range)
      init = shadow_iy(x)
      bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+3)
    end
  end
  def shadow_iy(x)
    return @m1*x+@n1
  end
  def shadow_fy(x)
    return @m2*x+@n2
  end
end
class Block_SR < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x04
  end
  def visible?(sx,sy)
    return sx > @x1
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    @m1 = (@y1-sy)/(@x1-sx)
    @n1 = sy - @m1*sx
    @m2 = (@y2-sy)/(@x2-sx)
    @n2 = sy - @m2*sx
    for x in (sx-range).to_i..@x1
      init = shadow_iy(x)
      bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+3)
    end
  end
  def shadow_iy(x)
    return @m1*x+@n1
  end
  def shadow_fy(x)
    return @m2*x+@n2
  end
end
class Block_IL < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x019
  end
  def visible?(sx,sy)
    return sx < @x1 && sy > @y1
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    @m1 = (@y1-sy)/(@x1-sx)
    @n1 = @y1 - @m1*@x1
    @m2 = (@y2-sy)/(@x2-sx)
    @m2 = 0 if @m2 > 0
    @n2 = @y2 - @m2*@x2
    for x in @x1..(sx+range)
      init = shadow_iy(x).floor
      bitmap.clear_rect(x-phx,init-3-phy,1,shadow_fy(x)-init+3)
    end
  end
  def shadow_iy(x)
    return @m1*x+@n1
  end
  def shadow_fy(x)
    return @m2*x+@n2
  end
end
class Block_IR < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x01c
  end
  def visible?(sx,sy)
    return sx > @x1 && sy > @y1
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    @m1 = (@y1-sy)/(@x1-sx)
    @n1 = @y1 - @m1*@x1
    @m2 = (@y2-sy)/(@x2-sx)
    @m2 = 0 if @m2 < 0
    @n2 = @y2 - @m2*@x2
    for x in (sx-range).to_i..@x1
      init = shadow_iy(x).floor
      bitmap.clear_rect(x-phx,init-3-phy,1,shadow_fy(x)-init+3)
    end
  end
  def shadow_iy(x)
    return @m1*x+@n1
  end
  def shadow_fy(x)
    return @m2*x+@n2
  end
end
class Block_WL < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x011
  end
  def visible?(sx,sy)
    return sx < @x1 && sy < @y2
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    @m1 = (@y1-sy)/(@x1-sx)
    @n1 = sy - @m1*sx
    @m2 = (@y2-sy)/(@x2-sx)
    @n2 = sy - @m2*sx
    for x in @x1..(sx+range)
      init = shadow_iy(x)
      bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+2)
    end
  end
  def shadow_iy(x)
    return @m1*x+@n1
  end
  def shadow_fy(x)
    return @m2*x+@n2
  end
end
class Block_WR < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x014
  end
  def visible?(sx,sy)
    return sx > @x1 && sy < @y2
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    @m1 = (@y1-sy)/(@x1-sx)
    @n1 = sy - @m1*sx
    @m2 = (@y2-sy)/(@x2-sx)
    @n2 = sy - @m2*sx
    for x in (sx-range).to_i..@x1
      init = shadow_iy(x)
      bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+2)
    end
  end
  def shadow_iy(x)
    return @m1*x+@n1
  end
  def shadow_fy(x)
    return @m2*x+@n2
  end
end
class Block_SU < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x02
  end
  def visible?(sx,sy)
    return sy < @y1
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    if @x1 == sx
      @m1 = nil
    else
      @m1 = (@y1-sy)/(@x1-sx)
      @m1 += ACC if @m1 < -ACC
      @n1 = @y1 - @m1*@x1
    end
    if @x2 == sx
      @m2 = nil
    else
      @m2 = (@y2-sy)/(@x2-sx)
      @n2 = sy - @m2*sx
    end
    for y in @y1..(sy+range)
      init = shadow_ix(y)
      bitmap.clear_rect(init-phx,y-phy,shadow_fx(y)-init+1,1)
    end
  end
  def shadow_ix(y)
    return @m1.nil? ? @x1 : (y-@n1)/@m1
  end
  def shadow_fx(y)
    return @m2.nil? ? @x2 : (y-@n2)/@m2
  end
end
class Block_SD < Block_Surface
  attr_reader :type
  def initialize(x1,y1,x2,y2)
    super(x1,y1,x2,y2)
    @type = 0x08
  end
  def visible?(sx,sy)
    return sy > @y1
  end
  def render_shadow(phx,phy,sx,sy,range,bitmap)
    if @x1 == sx
      @m1 = nil
    else
      @m1 = (@y1-sy)/(@x1-sx)
      @m1 -= ACC if @m1 > ACC
      @n1 = sy - @m1*sx
    end
    if x2 == sx
      @m2 = nil
    else
      @m2 = (@y2-sy)/(@x2-sx)
      @n2 = sy - @m2*sx
    end
    for y in (sy-range).to_i..@y1
      init = shadow_ix(y)
      bitmap.clear_rect(init-phx,y-phy,shadow_fx(y)-init+1,1)
    end
  end
  def shadow_ix(y)
    return @m1.nil? ? @x1 : (y-@n1)/@m1
  end
  def shadow_fx(y)
    return @m2.nil? ? @x2 : (y-@n2)/@m2
  end
end
class Spriteset_Map
  include Light_Core
  alias kbl_initialize initialize
  alias kbl_update update
  alias kbl_dispose dispose
  def initialize
    setup_lights
    kbl_initialize
  end
  def update
    kbl_update
    update_lights
  end
  def dispose
    kbl_dispose
    dispose_lights
  end
  def dispose_lights
    $game_map.lantern.dispose
    $game_map.light_sources.each { |source| source.dispose_light }
    $game_map.light_surface.bitmap.dispose
    $game_map.light_surface.dispose
    $game_map.light_surface = nil
  end
  def update_lights
    $game_map.light_surface.bitmap.clear
    $game_map.light_surface.bitmap.fill_rect(0,0,544,416,$game_map.effect_surface.color)
    $game_map.light_sources.each { |source| source.draw_light }
    return unless $game_map.lantern.visible
    @btr = $game_map.lantern.get_graphic
    x = $game_map.lantern.x
    y = $game_map.lantern.y
    r = $game_map.lantern.range
    sx = x + r
    sy = y + r
    dr = r*2
    $game_map.surfaces.each { |s| s.render_shadow(x,y,sx,sy,r,@btr) if s.visible?(sx,sy) && s.within?(x,x+dr,y,y+dr) }
    $game_map.light_surface.bitmap.blt($game_map.lantern.sx,$game_map.lantern.sy,@btr,Rect.new(0,0,dr,dr),$game_map.lantern.opacity)
  end
  def setup_lights
    @btr = nil
    $game_map.lantern.restore
    $game_map.light_sources.each { |source| source.restore_light }
    $game_map.light_surface = Sprite.new
    $game_map.light_surface.bitmap = Bitmap.new(544,416)
    $game_map.light_surface.bitmap.fill_rect(0,0,544,416,$game_map.effect_surface.color)
    $game_map.light_surface.blend_type = 2
    $game_map.light_surface.opacity = $game_map.effect_surface.alpha
    $game_map.light_surface.z = Surface_Z
  end
end

淡淡一杯冷咖啡

为什么我注释了[light 1】用不出来呀，大佬求解

hyx4022408

范例教程网址在哪啊？

Blois233

七重 发表于 2018-8-23 22:32
这样啊。。

话说我觉得灯光脚本里面半生那个也挺好用的，要说的话，说不定论坛里面比较多人用的是这个。 ...

试过半生的。。事实上以前都在用半生的
但是好像做不出影子的效果？（雾）
而且动态光源也还khas的稍微好一点

七重

Blois233 发表于 2018-8-23 21:25
谢谢，这我知道。但是当时机翻出来很混乱，也出现了一堆莫名奇妙的冲突，所以想要个有图文的教程。
我会 ...

这样啊。。

话说我觉得灯光脚本里面半生那个也挺好用的，要说的话，说不定论坛里面比较多人用的是这个。
khas里面有个方便的手电筒功能，如果是半生的话手电筒要自己写脚本。
半生的光效是正片叠底的。（虽然我也没有分出来和khas那个有什么大的区别。）
↓
https://rpg.blue/forum.php?mod=v ... 0782&highlight=烛光脚本

Blois233

七重 发表于 2018-8-23 12:59
前面那段英文就是教程。
khas主页有个配套的范例工程。

谢谢，这我知道。但是当时机翻出来很混乱，也出现了一堆莫名奇妙的冲突，所以想要个有图文的教程。
我会去khas的主页看下范例工程的

七重

前面那段英文就是教程。
khas主页有个配套的范例工程。

Nil2018

1. =begin
   
2. #-------------------------------------------------------------------------------
   
3. # * [ACE] Khas Awesome Light Effects
   
4. #-------------------------------------------------------------------------------
   
5. # * 作者 Khas Arcthunder - arcthunder.site40.net
   
6. # * 版本: 1.0 EN
   
7. # * Released on: 17/01/2012
   
8. #
   
9. #-------------------------------------------------------------------------------
   
10. # * Terms of Use
    
11. #-------------------------------------------------------------------------------
    
12. # When using any Khas script, you agree with the following terms:
    
13. # 1. You must give credit to Khas;
    
14. # 2. All Khas scripts are licensed under a Creative Commons license;
    
15. # 3. All Khas scripts are for non-commercial projects. If you need some script
    
16. #    for your commercial project (I accept requests for this type of project),
    
17. #    send an email to [email protected] with your request;
    
18. # 4. All Khas scripts are for personal use, you can use or edit for your own
    
19. #    project, but you are not allowed to post any modified version;
    
20. # 5. You can’t give credit to yourself for posting any Khas script;
    
21. # 6. If you want to share a Khas script, don’t post the direct download link,
    
22. #    please redirect the user to arcthunder.site40.net
    
23. #
    
24. #-------------------------------------------------------------------------------
    
25. # * 特点
    
26. #-------------------------------------------------------------------------------
    
27. # - 真实的灯光
    
28. # - 灯光不会穿过墙、遮挡物和天花板
    
29. # - 静态光源
    
30. # - 动态光源（角色手电）
    
31. # - 多种效果
    
32. # - 使用简单 (注释)
    
33. #
    
34. #-------------------------------------------------------------------------------
    
35. # * 警告 - 表现效果
    
36. #-------------------------------------------------------------------------------
    
37. # 这个脚本对于老人机杀伤力巨大! 本脚本测试于 Core 2 Duo E4500 和 Core i5,
    
38. # 以下为会影响表现效果的地方:
    
39. #
    
40. # 1. 地图大小
    
41. # 本脚本会在地图表面搜索,为了剪切灯光图片.大地图会增加表面的读取，影响动态光源
    
42.   的表现效果。地图大小不会影响静态灯光的效果。
    
43. 
    
44. #
    
45. # 2. 灯光效果数量
    
46. # 本脚本在屏幕上绘制，绘制之前还会判断灯光效果是否在屏幕之外。
    
47. (在地图外的话脚本将不会绘制超出的灯光效果). 太多灯光将会使游戏卡吨，这是我猜的。
    
48. 
    
49. # 3. 灯光效果图片大小
    
50. # 图片越大，将其绘制成动态光源耗时越长，建议图片最大为200x200像素
    
51. #-------------------------------------------------------------------------------
    
52. # * 注意 - 灯光的图片
    
53. #-------------------------------------------------------------------------------
    
54. #      1. 图片大小必须是2的倍数 例如: 150x150
    
55. #      2. 图片长宽相等，例如: 156x156
    
56. #      3. 图片颜色必须要反色
    
57. #-------------------------------------------------------------------------------
    
58. # * 介绍 - 1. 设定你的效果!
    
59. #-------------------------------  ------------------------------------------------
    
60. #
    
61. # 189行为灯光设定
    
62. # 查看默认效果来学习如何使用.
    
63. #
    
64. #-------------------------------------------------------------------------------
    
65. # * 介绍 - 2. 使用你设定的效果!
    
66. #-------------------------------------------------------------------------------
    
67. # 在事件中添加注释
    
68. #
    
69. # [light x]
    
70. #
    
71. # x为效果ID
    
72. #
    
73. #-------------------------------------------------------------------------------
    
74. # * 介绍 - 3. 灯笼效果!
    
75. #-------------------------------------------------------------------------------
    
76. # 动态光源（灯笼）默认是不可见的，这需要你使用脚本呼出来显示灯笼T:
    
77. #
    
78. # l = $game_map.lantern
    
79. #
    
80.    将灯笼放入变量
    
81. 
    
82. # l.set_graphic(i)
    
83. #
    
84. #   设定灯笼的图片为i，i为在Graphics/Lights  里的灯笼图片名
    
85. 
    
86. # l.set_multiple_graphics(h)
    
87. # 将灯笼的图片设定为 h, h必须在下面的哈希表中填写有
    
88. # 结构:
    
89. #
    
90. # h = {2=>"ld",4=>"ll",6=>"lr",8=>"lu"}
    
91. #
    
92. # 其中:
    
93. # "ld" 当用灯笼的角色向下看时的灯光图片
    
94. # "ll" 当用灯笼的角色向左看时的灯光图片
    
95. # "lr" 当用灯笼的角色向右看时的灯光图片
    
96. # "lu" 当用灯笼的角色向上看时的灯光图片
    
97. #
    
98. # l.change_owner(角色)
    
99. # 将灯笼的主人交给某一角色. 角色必须为以下:
    
100.   
     
101. # $game_player           <= 玩家
     
102. # self_event             <= 事件
     
103. # $game_map.events[x]    <= 事件ID
     
104. #
     
105. # l.set_opacity(o,p)
     
106. # 设定灯笼不透明度,
     
107. # o 自身的不透明度;
     
108. # p 是透明度的变化（闪烁）.
     
109. #
     
110. # l.show
     
111. # 以上命令都打完后要以此命令作为结束。
     
112. #
     
113. # l.hide
     
114. # 设定灯笼不可见.
     
115. #
     
116. #-------------------------------------------------------------------------------
     
117. # * 介绍 - 4. 修改画面颜色（黑夜、黄昏效果）!
     
118. #-------------------------------------------------------------------------------
     
119. # 在灯光之下、游戏画面之上还需要有一层暗暗的画面来突出灯光效果，这层画面默认的
     
120.    不透明度为0，你可以用以下脚本来修改画面颜色：
     
121. #
     
122. # s = $game_map.effect_surface  以这个脚本为开头
     
123. #  将画面表面设置变量
     
124. #
     
125. # s.set_color(r,g,b)
     
126. # 立即改变画面颜色, 其中:
     
127. # r => 红色含量;
     
128. # g => 绿色含量;
     
129. # b => 蓝色含量;
     
130. #
     
131. # s.set_alpha(a)
     
132. # 立即改变画面颜色为 a.
     
133. #
     
134. # s.change_color(时间,r,g,b)
     
135. # 在一定时间内逐渐改变画面颜色, 其中:
     
136. # 时间 => 变成黑夜的时间 (帧);
     
137. # r => 红色含量;
     
138. # g => 绿色含量;
     
139. # b => 蓝色含量;
     
140. #
     
141. # s.change_color(时间,r,g,b,a)
     
142. # 在一定时间内逐渐改变画面颜色和不透明度, 其中:
     
143. # 时间 => 变成黑夜的时间 (帧);
     
144. # r => 红色含量;
     
145. # g => 绿色含量;
     
146. # b => 蓝色含量;
     
147. # a => 不透明度
     
148. #
     
149. # s.change_alpha(时间,a)
     
150. # 在一定时间内逐渐改变表面不透明度,其中:
     
151. # 时间 => 变成黑夜的时间 (帧);
     
152. # a => 不透明度
     
153. #
     
154. #-------------------------------------------------------------------------------
     
155. # * 介绍 - 5. 更改画面色调!
     
156. #-------------------------------------------------------------------------------
     
157. # 你可以使用事件命令中的更改画面色调，请将204行的"Surface_UE" 设定改为 true.
     
158. #
     
159. # 如果你决定使用这个功能, 请设置一些细节:
     
160. # 1. 颜色的数值必须在 0 到 255;
     
161. # 2. 时间按帧计算;
     
162. # 3. "灰色" 值将等同于不透明度的数值
     
163. #
     
164. #-------------------------------------------------------------------------------
     
165. # * Instructions - 6. 设定你的图块标志!
     
166. #-------------------------------------------------------------------------------
     
167. # 为了使效果图片有遮挡效果, 地图有三种遮挡效果: 墙, 障碍和屋顶.
     
168. #   墙会和真的墙一样有影子, 所以要和障碍与屋顶区分开来.
     
169. #
     
170. #
     
171. #-------------------------------------------------------------------------------
     
172. # * Setup Part
     
173. #-------------------------------------------------------------------------------
     
174. =end
     
175. module Light_Core
     
176.   Effects = { #  <= 不要碰这个
     
177. #-------------------------------------------------------------------------------
     
178. # 效果设定
     
179. #-------------------------------------------------------------------------------
     
180. # 格式：X => [图片,不透明度,变化,裁剪图片],   <= 记得在这里加一个逗号！
     
181. #
     
182. # X => 在事件中使用，效果的ID.
     
183. # 图片 => 在 Graphics/Lights 文件夹里;
     
184. # 不透明度 => 灯光效果的不透明度;
     
185. # 变化 => 灯光效果的不透明度变化（闪烁）;
     
186. # 裁剪图片 => true：裁剪，false：不裁剪;（制造光线被墙壁遮挡的效果）
     
187. 
     
188. # X => [图片,不透明度,变化,裁剪]
     
189.   0 => ["light",255,0,true],
     
190.   1 => ["torch",200,20,true],
     
191.   2 => ["torch_m",180,30,true],
     
192.   3 => ["light_s",255,0,true],
     
193.   4 => ["light",255,0,false],
     
194. 
     
195.   
     
196. #-------------------------------------------------------------------------------
     
197. # 其他设定
     
198. #-------------------------------------------------------------------------------
     
199.   } #  <= 不要碰这个!
     
200.   
     
201.   # 灯光效果的z轴坐标
     
202.   Surface_Z = 600
     
203.   
     
204.   # 是否允许使用事件的更改画面色调命令？
     
205.   Surface_UE = true
     
206.   
     
207.   # 屋顶的地形标志
     
208.   Roof_Tag = 5
     
209.   # 墙壁的地形标志
     
210.   Wall_Tag = 6
     
211.   # 障碍物的地形标志
     
212.   Block_Tag = 7
     
213.   
     
214.   # 别动它!
     
215.   ACC = Math.tan(Math::PI/26)
     
216. end
     
217. #-------------------------------------------------------------------------------
     
218. # Script
     
219. #-------------------------------------------------------------------------------
     
220. module Cache
     
221.   def self.light(filename)
     
222.     load_bitmap("Graphics/Lights/", filename)
     
223.   end
     
224. end
     
225. module Light_Bitcore
     
226.   include Light_Core
     
227.   def self.initialize
     
228.     @@buffer = {}
     
229.     Effects.values.each { |effect| Light_Bitcore.push(effect[0])}
     
230.   end
     
231.   def self::[](key)
     
232.     return @@buffer[key]
     
233.   end
     
234.   def self.push(key)
     
235.     return if @@buffer.keys.include?(key)
     
236.     @@buffer[key] = Cache.light(key)
     
237.   end
     
238. end
     
239. Light_Bitcore.initialize
     
240. class Light_SSource
     
241.   attr_reader :real_x
     
242.   attr_reader :real_y
     
243.   attr_reader :range
     
244.   attr_accessor :bitmap
     
245.   attr_reader :w
     
246.   attr_reader :h
     
247.   attr_reader :hs
     
248.   def initialize(char,bitmap,opacity,plus,hs)
     
249.     sync(char)
     
250.     @key = bitmap
     
251.     @bitmap = Light_Bitcore[@key].clone
     
252.     @range = @bitmap.width/2
     
253.     @w = @bitmap.width
     
254.     @h = @bitmap.height
     
255.     @mr = @range - 16
     
256.     @opacity = opacity
     
257.     @plus = plus
     
258.     @hs = hs
     
259.     render if @hs
     
260.   end
     
261.   def render
     
262.     tx = x
     
263.     ty = y
     
264.     tsx = x + @range
     
265.     tsy = y + @range
     
266.     dr = @range*2
     
267.     for s in $game_map.surfaces
     
268.       next if !s.visible?(tsx,tsy) || !s.within?(tx,tx+dr,ty,ty+dr)
     
269.       s.render_shadow(tx,ty,tsx,tsy,@range,@bitmap)
     
270.     end
     
271.   end
     
272.   def restore
     
273.     return unless @bitmap.nil?
     
274.     @bitmap = Light_Bitcore[@key].clone
     
275.     render if @hs
     
276.   end
     
277.   def opacity
     
278.     @plus == 0 ? @opacity : (@opacity + rand(@plus))
     
279.   end
     
280.   def sx
     
281.     return $game_map.adjust_x(@real_x)*32-@mr
     
282.   end
     
283.   def sy
     
284.     return $game_map.adjust_y(@real_y)*32-@mr
     
285.   end
     
286.   def sync(char)
     
287.     @real_x = char.real_x
     
288.     @real_y = char.real_y
     
289.   end
     
290.   def x
     
291.     return (@real_x*32 - @mr).to_f
     
292.   end
     
293.   def y
     
294.     return (@real_y*32 - @mr).to_f
     
295.   end
     
296.   def dispose
     
297.     return if @bitmap.nil?
     
298.     @bitmap.dispose
     
299.     @bitmap = nil
     
300.   end
     
301. end
     
302. class Light_DSource < Light_SSource
     
303.   attr_reader :bitmap
     
304.   attr_reader :visible
     
305.   def initialize
     
306.     @key = nil
     
307.     @bitmap = nil
     
308.     @opacity = 255
     
309.     @plus = 0
     
310.     @char = $game_player
     
311.     @visible = false
     
312.   end
     
313.   def set_opacity(o,p)
     
314.     @opacity = o
     
315.     @plus = p
     
316.   end
     
317.   def set_graphic(sb)
     
318.     dispose
     
319.     @key = {2=>sb,4=>sb,6=>sb,8=>sb}
     
320.     Light_Bitcore.push(sb)
     
321.     @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
     
322.     @range = @bitmap[2].width/2
     
323.     @w = @bitmap[2].width
     
324.     @h = @bitmap[2].height
     
325.     @mr = @range - 16
     
326.   end
     
327.   def set_multiple_graphics(ba)
     
328.     dispose
     
329.     @key = ba
     
330.     @key.values.each {|key| Light_Bitcore.push(key)}
     
331.     @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
     
332.     @range = @bitmap[2].width/2
     
333.     @w = @bitmap[2].width
     
334.     @h = @bitmap[2].height
     
335.     @mr = @range - 16
     
336.   end
     
337.   def get_graphic
     
338.     return @bitmap[@char.direction].clone
     
339.   end
     
340.   def show
     
341.     return if @bitmap.nil?
     
342.     @visible = true
     
343.   end
     
344.   def hide
     
345.     @visible = false
     
346.   end
     
347.   def restore
     
348.     return if @key.nil?
     
349.     @key.values.each {|key| Light_Bitcore.push(key)}
     
350.     @bitmap = {2=>Light_Bitcore[@key[2]].clone,4=>Light_Bitcore[@key[4]].clone,6=>Light_Bitcore[@key[6]].clone,8=>Light_Bitcore[@key[8]].clone}
     
351.   end
     
352.   def dispose
     
353.     return if @bitmap.nil?
     
354.     @bitmap.values.each { |b| b.dispose }
     
355.     @bitmap = nil
     
356.   end
     
357.   def change_owner(char)
     
358.     @char = char
     
359.   end
     
360.   def render
     
361.   end
     
362.   def sx
     
363.     return $game_map.adjust_x(@char.real_x)*32-@mr
     
364.   end
     
365.   def sy
     
366.     return $game_map.adjust_y(@char.real_y)*32-@mr
     
367.   end
     
368.   def x
     
369.     return (@char.real_x*32 - @mr).to_f
     
370.   end
     
371.   def y
     
372.     return (@char.real_y*32 - @mr).to_f
     
373.   end
     
374. end
     
375. class Light_Surface
     
376.   def initialize
     
377.     @ta = @a = 0
     
378.     @tr = @r = 255
     
379.     @tg = @g = 255
     
380.     @tb = @b = 255
     
381.     @va = @vr = @vg = @vb = 0.0
     
382.     @timer = 0
     
383.   end
     
384.   def refresh
     
385.     return if @timer == 0
     
386.     @a += @va
     
387.     @r += @vr
     
388.     @g += @vg
     
389.     @b += @vb
     
390.     $game_map.light_surface.opacity = @a
     
391.     @timer -= 1
     
392.   end
     
393.   def change_color(time,r,g,b,a=nil)
     
394.     r = 0 if r < 0; r = 255 if r > 255
     
395.     g = 0 if g < 0; g = 255 if g > 255
     
396.     b = 0 if b < 0; b = 255 if b > 255
     
397.     unless a.nil?
     
398.       a = 0 if a < 0; a = 255 if a > 255
     
399.     end
     
400.     @timer = time
     
401.     @tr = 255-r
     
402.     @tg = 255-g
     
403.     @tb = 255-b
     
404.     @va = (a.nil? ? 0 : (a-@a).to_f/@timer)
     
405.     @vr = (@tr - @r).to_f/@timer
     
406.     @vg = (@tg - @g).to_f/@timer
     
407.     @vb = (@tb - @b).to_f/@timer
     
408.   end
     
409.   def change_alpha(time,a)
     
410.     a = 0 if a < 0; a = 255 if a > 255
     
411.     @timer = time
     
412.     @ta = a
     
413.     @vr = @vg = @vb = 0.0
     
414.     @va = (a-@a).to_f/@timer
     
415.   end
     
416.   def set_color(r,g,b)
     
417.     r = 0 if r < 0; r = 255 if r > 255
     
418.     g = 0 if g < 0; g = 255 if g > 255
     
419.     b = 0 if b < 0; b = 255 if b > 255
     
420.     @tr = @r = 255-r
     
421.     @tg = @g = 255-g
     
422.     @tb = @b = 255-b
     
423.     @va = @vr = @vg = @vb = 0.0
     
424.     @timer = 0
     
425.   end
     
426.   def set_alpha(a)
     
427.     a = 0 if a < 0; a = 255 if a > 255
     
428.     @ta = @a = a
     
429.     $game_map.light_surface.opacity = @a
     
430.     @va = @vr = @vg = @vb = 0.0
     
431.     @timer = 0
     
432.   end
     
433.   def alpha
     
434.     return @a
     
435.   end
     
436.   def color
     
437.     return Color.new(@r,@g,@b)
     
438.   end
     
439. end
     
440. class Game_Map
     
441.   include Light_Core
     
442.   attr_accessor :light_surface
     
443.   attr_accessor :light_sources
     
444.   attr_accessor :surfaces
     
445.   attr_accessor :effect_surface
     
446.   attr_accessor :lantern
     
447.   alias kbl_setup_events setup_events
     
448.   alias kbl_initialize initialize
     
449.   alias kbl_update update
     
450.   def initialize
     
451.     kbl_initialize
     
452.     @effect_surface = Light_Surface.new
     
453.     @lantern = Light_DSource.new
     
454.   end
     
455.   def update(arg)
     
456.     @effect_surface.refresh if arg
     
457.     kbl_update(arg)
     
458.   end
     
459.   def first_tag(x,y)
     
460.     tag = tileset.flags[tile_id(x,y,0)] >> 12
     
461.     return tag > 0 ? tag : 0
     
462.   end
     
463.   def setup_events
     
464.     @light_sources.nil? ? @light_sources = [] : @light_sources.clear
     
465.     setup_surfaces
     
466.     merge_surfaces
     
467.     kbl_setup_events
     
468.   end
     
469.   def setup_surfaces
     
470.     @surfaces = []
     
471.     for x in 0..(width-1)
     
472.       for y in 0..(height-1)
     
473.         tag = first_tag(x,y)
     
474.         if tag == Wall_Tag
     
475.           i = tile_id(x,y,0)
     
476.           if i & 0x02 == 0x02
     
477.             @surfaces << Block_SD.new(x*32,y*32,x*32+32,y*32)
     
478.           end
     
479.           if i & 0x04 == 0x04
     
480.             @surfaces << Block_WR.new(x*32+31,y*32,x*32+31,y*32+32)
     
481.             @surfaces << Block_IL.new(x*32+32,y*32,x*32+32,y*32+32)
     
482.           end
     
483.           if i & 0x01 == 0x01
     
484.             @surfaces << Block_IR.new(x*32-1,y*32,x*32-1,y*32+32)
     
485.             @surfaces << Block_WL.new(x*32,y*32,x*32,y*32+32)
     
486.           end
     
487.         elsif tag == Roof_Tag
     
488.           i = tile_id(x,y,0)
     
489.           @surfaces << Block_SU.new(x*32,y*32,x*32+32,y*32) if i & 0x02 == 0x02
     
490.           @surfaces << Block_SR.new(x*32+31,y*32,x*32+31,y*32+32) if i & 0x04 == 0x04
     
491.           @surfaces << Block_SL.new(x*32,y*32,x*32,y*32+32) if i & 0x01 == 0x01
     
492.         elsif tag == Block_Tag
     
493.           f = tileset.flags[tile_id(x,y,0)]
     
494.           @surfaces << Block_SL.new(x*32,y*32,x*32,y*32+32) if f & 0x02 == 0x02
     
495.           @surfaces << Block_SR.new(x*32+31,y*32,x*32+31,y*32+32) if f & 0x04 == 0x04
     
496.           @surfaces << Block_SU.new(x*32,y*32,x*32+32,y*32) if f & 0x08 == 0x08
     
497.         end
     
498.       end
     
499.     end
     
500.   end
     
501.   def merge_surfaces
     
502.     new_surfaces = []
     
503.     hs = []; vs = []
     
504.     ws = []; is = []
     
505.     for surface in @surfaces
     
506.       if surface.type & 0x05 == 0
     
507.         hs << surface
     
508.       else
     
509.         if surface.type & 0x010 == 0
     
510.           vs << surface
     
511.         else
     
512.           if surface.type & 0x08 == 0
     
513.             ws << surface
     
514.           else
     
515.             is << surface
     
516.           end
     
517.         end
     
518.       end
     
519.     end
     
520.     for surface in hs
     
521.       surface.ready ? next : surface.ready = true
     
522.       for s in hs
     
523.         next if s.ready || s.y1 != surface.y1 || surface.type != s.type
     
524.         if s.x2 == surface.x1
     
525.           surface.x1 = s.x1
     
526.           s.trash = true
     
527.           s.ready = true
     
528.           surface.ready = false
     
529.         elsif s.x1 == surface.x2
     
530.           surface.x2 = s.x2
     
531.           s.trash = true
     
532.           s.ready = true
     
533.           surface.ready = false
     
534.         end
     
535.       end
     
536.     end
     
537.     hs.each { |s| @surfaces.delete(s) if s.trash}
     
538.     for surface in vs
     
539.       surface.ready ? next : surface.ready
     
540.       for s in vs
     
541.         next if s.ready || s.x1 != surface.x1
     
542.         if s.y2 == surface.y1
     
543.           surface.y1 = s.y1
     
544.           s.trash = true
     
545.           s.ready = true
     
546.           surface.ready = false
     
547.         elsif s.y1 == surface.y2
     
548.           surface.y2 = s.y2
     
549.           s.trash = true
     
550.           s.ready = true
     
551.           surface.ready = false
     
552.         end
     
553.       end
     
554.     end
     
555.     vs.each { |s| @surfaces.delete(s) if s.trash}
     
556.     for surface in ws
     
557.       surface.ready ? next : surface.ready
     
558.       for s in ws
     
559.         next if s.ready || s.x1 != surface.x1
     
560.         if s.y2 == surface.y1
     
561.           surface.y1 = s.y1
     
562.           s.trash = true
     
563.           s.ready = true
     
564.           surface.ready = false
     
565.         elsif s.y1 == surface.y2
     
566.           surface.y2 = s.y2
     
567.           s.trash = true
     
568.           s.ready = true
     
569.           surface.ready = false
     
570.         end
     
571.       end
     
572.     end
     
573.     ws.each { |s| @surfaces.delete(s) if s.trash}
     
574.     for surface in is
     
575.       surface.ready ? next : surface.ready
     
576.       for s in is
     
577.         next if s.ready || s.x1 != surface.x1
     
578.         if s.y2 == surface.y1
     
579.           surface.y1 = s.y1
     
580.           s.trash = true
     
581.           s.ready = true
     
582.           surface.ready = false
     
583.         elsif s.y1 == surface.y2
     
584.           surface.y2 = s.y2
     
585.           s.trash = true
     
586.           s.ready = true
     
587.           surface.ready = false
     
588.         end
     
589.       end
     
590.     end
     
591.     is.each { |s| @surfaces.delete(s) if s.trash}
     
592.   end
     
593. end
     
594. class Game_Event < Game_Character
     
595.   alias kbl_initialize initialize
     
596.   alias kbl_setup_page setup_page
     
597.   def initialize(m,e)
     
598.     @light = nil
     
599.     kbl_initialize(m,e)
     
600.   end
     
601.   def setup_page(np)
     
602.     kbl_setup_page(np)
     
603.     setup_light(np.nil?)
     
604.   end
     
605.   def setup_light(dispose)
     
606.     unless @light.nil?
     
607.       $game_map.light_sources.delete(self)
     
608.       @light.dispose
     
609.       @light = nil
     
610.     end
     
611.     unless dispose && @list.nil?
     
612.       for command in @list
     
613.         if command.code == 108 && command.parameters[0].include?("[light")
     
614.           command.parameters[0].scan(/\[light ([0.0-9.9]+)\]/)
     
615.           effect = Light_Core::Effects[$1.to_i]
     
616.           @light = Light_SSource.new(self,effect[0],effect[1],effect[2],effect[3])
     
617.           $game_map.light_sources << self
     
618.           return
     
619.         end
     
620.       end
     
621.     end
     
622.   end
     
623.   def draw_light
     
624.     sx = @light.sx
     
625.     sy = @light.sy
     
626.     w = @light.w
     
627.     h = @light.h
     
628.     return if sx > 544 && sy > 416 && sx + w < 0 && sy + h < 0
     
629.     $game_map.light_surface.bitmap.blt(sx,sy,@light.bitmap,Rect.new(0,0,w,h),@light.opacity)
     
630.   end
     
631.   def dispose_light
     
632.     @light.dispose
     
633.   end
     
634.   def restore_light
     
635.     @light.restore
     
636.   end
     
637. end
     
638. if Light_Core::Surface_UE
     
639.   class Game_Interpreter
     
640.     def command_223
     
641.       $game_map.effect_surface.change_color(@params[1],@params[0].red,@params[0].green,@params[0].blue,@params[0].gray)
     
642.       wait(@params[1]) if @params[2]
     
643.     end
     
644.   end
     
645. end
     
646. class Game_Interpreter
     
647.   def self_event
     
648.     return $game_map.events[@event_id]
     
649.   end
     
650. end
     
651. class Block_Surface
     
652.   include Light_Core
     
653.   attr_accessor :x1
     
654.   attr_accessor :y1
     
655.   attr_accessor :x2
     
656.   attr_accessor :y2
     
657.   attr_accessor :ready
     
658.   attr_accessor :trash
     
659.   def initialize(x1,y1,x2,y2)
     
660.     @x1 = x1
     
661.     @y1 = y1
     
662.     @x2 = x2
     
663.     @y2 = y2
     
664.     @ready = false
     
665.     @trash = false
     
666.   end
     
667.   def within?(min_x,max_x,min_y,max_y)
     
668.     return @x2 > min_x && @x1 < max_x && @y2 > min_y && @y1 < max_y
     
669.   end
     
670. end
     
671. class Block_SL < Block_Surface
     
672.   attr_reader :type
     
673.   def initialize(x1,y1,x2,y2)
     
674.     super(x1,y1,x2,y2)
     
675.     @type = 0x01
     
676.   end
     
677.   def visible?(sx,sy)
     
678.     return sx < @x1
     
679.   end
     
680.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
681.     @m1 = (@y1-sy)/(@x1-sx)
     
682.     @n1 = sy - @m1*sx
     
683.     @m2 = (@y2-sy)/(@x2-sx)
     
684.     @n2 = sy - @m2*sx
     
685.     for x in @x1..(sx+range)
     
686.       init = shadow_iy(x)
     
687.       bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+3)
     
688.     end
     
689.   end
     
690.   def shadow_iy(x)
     
691.     return @m1*x+@n1
     
692.   end
     
693.   def shadow_fy(x)
     
694.     return @m2*x+@n2
     
695.   end
     
696. end
     
697. class Block_SR < Block_Surface
     
698.   attr_reader :type
     
699.   def initialize(x1,y1,x2,y2)
     
700.     super(x1,y1,x2,y2)
     
701.     @type = 0x04
     
702.   end
     
703.   def visible?(sx,sy)
     
704.     return sx > @x1
     
705.   end
     
706.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
707.     @m1 = (@y1-sy)/(@x1-sx)
     
708.     @n1 = sy - @m1*sx
     
709.     @m2 = (@y2-sy)/(@x2-sx)
     
710.     @n2 = sy - @m2*sx
     
711.     for x in (sx-range).to_i..@x1
     
712.       init = shadow_iy(x)
     
713.       bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+3)
     
714.     end
     
715.   end
     
716.   def shadow_iy(x)
     
717.     return @m1*x+@n1
     
718.   end
     
719.   def shadow_fy(x)
     
720.     return @m2*x+@n2
     
721.   end
     
722. end
     
723. class Block_IL < Block_Surface
     
724.   attr_reader :type
     
725.   def initialize(x1,y1,x2,y2)
     
726.     super(x1,y1,x2,y2)
     
727.     @type = 0x019
     
728.   end
     
729.   def visible?(sx,sy)
     
730.     return sx < @x1 && sy > @y1
     
731.   end
     
732.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
733.     @m1 = (@y1-sy)/(@x1-sx)
     
734.     @n1 = @y1 - @m1*@x1
     
735.     @m2 = (@y2-sy)/(@x2-sx)
     
736.     @m2 = 0 if @m2 > 0
     
737.     @n2 = @y2 - @m2*@x2
     
738.     for x in @x1..(sx+range)
     
739.       init = shadow_iy(x).floor
     
740.       bitmap.clear_rect(x-phx,init-3-phy,1,shadow_fy(x)-init+3)
     
741.     end
     
742.   end
     
743.   def shadow_iy(x)
     
744.     return @m1*x+@n1
     
745.   end
     
746.   def shadow_fy(x)
     
747.     return @m2*x+@n2
     
748.   end
     
749. end
     
750. class Block_IR < Block_Surface
     
751.   attr_reader :type
     
752.   def initialize(x1,y1,x2,y2)
     
753.     super(x1,y1,x2,y2)
     
754.     @type = 0x01c
     
755.   end
     
756.   def visible?(sx,sy)
     
757.     return sx > @x1 && sy > @y1
     
758.   end
     
759.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
760.     @m1 = (@y1-sy)/(@x1-sx)
     
761.     @n1 = @y1 - @m1*@x1
     
762.     @m2 = (@y2-sy)/(@x2-sx)
     
763.     @m2 = 0 if @m2 < 0
     
764.     @n2 = @y2 - @m2*@x2
     
765.     for x in (sx-range).to_i..@x1
     
766.       init = shadow_iy(x).floor
     
767.       bitmap.clear_rect(x-phx,init-3-phy,1,shadow_fy(x)-init+3)
     
768.     end
     
769.   end
     
770.   def shadow_iy(x)
     
771.     return @m1*x+@n1
     
772.   end
     
773.   def shadow_fy(x)
     
774.     return @m2*x+@n2
     
775.   end
     
776. end
     
777. class Block_WL < Block_Surface
     
778.   attr_reader :type
     
779.   def initialize(x1,y1,x2,y2)
     
780.     super(x1,y1,x2,y2)
     
781.     @type = 0x011
     
782.   end
     
783.   def visible?(sx,sy)
     
784.     return sx < @x1 && sy < @y2
     
785.   end
     
786.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
787.     @m1 = (@y1-sy)/(@x1-sx)
     
788.     @n1 = sy - @m1*sx
     
789.     @m2 = (@y2-sy)/(@x2-sx)
     
790.     @n2 = sy - @m2*sx
     
791.     for x in @x1..(sx+range)
     
792.       init = shadow_iy(x)
     
793.       bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+2)
     
794.     end
     
795.   end
     
796.   def shadow_iy(x)
     
797.     return @m1*x+@n1
     
798.   end
     
799.   def shadow_fy(x)
     
800.     return @m2*x+@n2
     
801.   end
     
802. end
     
803. class Block_WR < Block_Surface
     
804.   attr_reader :type
     
805.   def initialize(x1,y1,x2,y2)
     
806.     super(x1,y1,x2,y2)
     
807.     @type = 0x014
     
808.   end
     
809.   def visible?(sx,sy)
     
810.     return sx > @x1 && sy < @y2
     
811.   end
     
812.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
813.     @m1 = (@y1-sy)/(@x1-sx)
     
814.     @n1 = sy - @m1*sx
     
815.     @m2 = (@y2-sy)/(@x2-sx)
     
816.     @n2 = sy - @m2*sx
     
817.     for x in (sx-range).to_i..@x1
     
818.       init = shadow_iy(x)
     
819.       bitmap.clear_rect(x-phx,init-phy,1,shadow_fy(x)-init+2)
     
820.     end
     
821.   end
     
822.   def shadow_iy(x)
     
823.     return @m1*x+@n1
     
824.   end
     
825.   def shadow_fy(x)
     
826.     return @m2*x+@n2
     
827.   end
     
828. end
     
829. class Block_SU < Block_Surface
     
830.   attr_reader :type
     
831.   def initialize(x1,y1,x2,y2)
     
832.     super(x1,y1,x2,y2)
     
833.     @type = 0x02
     
834.   end
     
835.   def visible?(sx,sy)
     
836.     return sy < @y1
     
837.   end
     
838.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
839.     if @x1 == sx
     
840.       @m1 = nil
     
841.     else
     
842.       @m1 = (@y1-sy)/(@x1-sx)
     
843.       @m1 += ACC if @m1 < -ACC
     
844.       @n1 = @y1 - @m1*@x1
     
845.     end
     
846.     if @x2 == sx
     
847.       @m2 = nil
     
848.     else
     
849.       @m2 = (@y2-sy)/(@x2-sx)
     
850.       @n2 = sy - @m2*sx
     
851.     end
     
852.     for y in @y1..(sy+range)
     
853.       init = shadow_ix(y)
     
854.       bitmap.clear_rect(init-phx,y-phy,shadow_fx(y)-init+1,1)
     
855.     end
     
856.   end
     
857.   def shadow_ix(y)
     
858.     return @m1.nil? ? @x1 : (y-@n1)/@m1
     
859.   end
     
860.   def shadow_fx(y)
     
861.     return @m2.nil? ? @x2 : (y-@n2)/@m2
     
862.   end
     
863. end
     
864. class Block_SD < Block_Surface
     
865.   attr_reader :type
     
866.   def initialize(x1,y1,x2,y2)
     
867.     super(x1,y1,x2,y2)
     
868.     @type = 0x08
     
869.   end
     
870.   def visible?(sx,sy)
     
871.     return sy > @y1
     
872.   end
     
873.   def render_shadow(phx,phy,sx,sy,range,bitmap)
     
874.     if @x1 == sx
     
875.       @m1 = nil
     
876.     else
     
877.       @m1 = (@y1-sy)/(@x1-sx)
     
878.       @m1 -= ACC if @m1 > ACC
     
879.       @n1 = sy - @m1*sx
     
880.     end
     
881.     if x2 == sx
     
882.       @m2 = nil
     
883.     else
     
884.       @m2 = (@y2-sy)/(@x2-sx)
     
885.       @n2 = sy - @m2*sx
     
886.     end
     
887.     for y in (sy-range).to_i..@y1
     
888.       init = shadow_ix(y)
     
889.       bitmap.clear_rect(init-phx,y-phy,shadow_fx(y)-init+1,1)
     
890.     end
     
891.   end
     
892.   def shadow_ix(y)
     
893.     return @m1.nil? ? @x1 : (y-@n1)/@m1
     
894.   end
     
895.   def shadow_fx(y)
     
896.     return @m2.nil? ? @x2 : (y-@n2)/@m2
     
897.   end
     
898. end
     
899. class Spriteset_Map
     
900.   include Light_Core
     
901.   alias kbl_initialize initialize
     
902.   alias kbl_update update
     
903.   alias kbl_dispose dispose
     
904.   def initialize
     
905.     setup_lights
     
906.     kbl_initialize
     
907.   end
     
908.   def update
     
909.     kbl_update
     
910.     update_lights
     
911.   end
     
912.   def dispose
     
913.     kbl_dispose
     
914.     dispose_lights
     
915.   end
     
916.   def dispose_lights
     
917.     $game_map.lantern.dispose
     
918.     $game_map.light_sources.each { |source| source.dispose_light }
     
919.     $game_map.light_surface.bitmap.dispose
     
920.     $game_map.light_surface.dispose
     
921.     $game_map.light_surface = nil
     
922.   end
     
923.   def update_lights
     
924.     $game_map.light_surface.bitmap.clear
     
925.     $game_map.light_surface.bitmap.fill_rect(0,0,544,416,$game_map.effect_surface.color)
     
926.     $game_map.light_sources.each { |source| source.draw_light }
     
927.     return unless $game_map.lantern.visible
     
928.     @btr = $game_map.lantern.get_graphic
     
929.     x = $game_map.lantern.x
     
930.     y = $game_map.lantern.y
     
931.     r = $game_map.lantern.range
     
932.     sx = x + r
     
933.     sy = y + r
     
934.     dr = r*2
     
935.     $game_map.surfaces.each { |s| s.render_shadow(x,y,sx,sy,r,@btr) if s.visible?(sx,sy) && s.within?(x,x+dr,y,y+dr) }
     
936.     $game_map.light_surface.bitmap.blt($game_map.lantern.sx,$game_map.lantern.sy,@btr,Rect.new(0,0,dr,dr),$game_map.lantern.opacity)
     
937.   end
     
938.   def setup_lights
     
939.     @btr = nil
     
940.     $game_map.lantern.restore
     
941.     $game_map.light_sources.each { |source| source.restore_light }
     
942.     $game_map.light_surface = Sprite.new
     
943.     $game_map.light_surface.bitmap = Bitmap.new(544,416)
     
944.     $game_map.light_surface.bitmap.fill_rect(0,0,544,416,$game_map.effect_surface.color)
     
945.     $game_map.light_surface.blend_type = 2
     
946.     $game_map.light_surface.opacity = $game_map.effect_surface.alpha
     
947.     $game_map.light_surface.z = Surface_Z
     
948.   end
     
949. end

复制代码