怎样让图片不随人物移动而移动

sunluck109

  是这样，正在用Auto/Event-Light Reborn 光影脚本做图，但是图做好后设定在地图里显示后，人物上下移动后，图片也会移动，想固定图片不动怎么设置，请帮助下，本人英文菜鸟。。。  （另：哪位使用过这个脚本的好心人能给下这个脚本使用说明，或简短介绍，在下感激不尽。）




#------------------------------------------------------------------------------#
# Name:     Auto/Event-Light Reborn                                            #
# By:       SojaBird                                                           #
# Version:  Reborn 4.1                                                         #
#                                                                              #
# Date:     30-08-09                                                           #
#------------------------------------------------------------------------------#

$imported = {} if $imported == nil
$imported["SojaBird_AutoLight"] = true

#------------------------------------------------------------------------------#
# Call Script                                                                  #
#------------------------------------------------------------------------------#
# - AL.mode(val)                 #                                             #
# - AL.light(parm, val)          # parm: name, opacity, blend, visible         #
# - AL.shadow(parm, val)         # parm: name, opacity, blend, visible         #
# - AL.spot(parm, val)           # parm: name, opacity, blend, visible         #
# - AL.flicker(parm, val)        # parm: opacity, width, height, x, y          #
#                                #                                             #
# - EL.bitmap(val, index = nil)  #                                             #
# - EL.color(val, index = nil)   #                                             #
# - EL.opacity(val, index = nil) #                                             #
# - EL.blend(val, index = nil)   #                                             #
# - EL.visible(val, index = nil) #                                             #
# - EL.zoom(val, index = nil)    #                                             #
#------------------------------------------------------------------------------#

#------------------------------------------------------------------------------#
# How to use                                                                   #
#------------------------------------------------------------------------------#
# *AutoLight                                                                   #
#  MODE 0/2                                                                    #
#   To use autolights, put a light- and/or shadow-map picture in the           #
#   folder ../Graphics/Pictures/                                               #
#   Name to picture correct! Start with the, by you set, light- and/or         #
#   shadow-map name, followed by the corresponding map-ID.                     #
#   Put the AutoLight mode to 0 or 2 to show light- and/or shadow-maps.        #
#                                                                              #
#  MODE 1/2                                                                    #
#   To use the spot, put your spotpicture in the folder ../Graphics/Pictures/  #
#   and set the name correct!                                                  #
#   Put the AutoLight mode to 1 or 2 to show the spot.                         #
#                                                                              #
#                                                                              #
# *EventLight                                                                  #
#   To make a event cast a light, give it a comment with the following code:   #
#     cast(*picture, *color, *opacity, *blend_type, *zoom)                     #
#   All the parameters are optional. Default they are set to:                  #
#     picture:    Default, set in the module                                   #
#     color:      White                                                        #
#     opacity:    255                                                          #
#     blend_type: 1                                                            #
#     zoom:       100                                                          #
#   For the color you can choose:                                              #
#    - white                                                                   #
#    - red                                                                     #
#    - green                                                                   #
#    - blue                                                                    #
#    - yellow                                                                  #
#    - orange                                                                  #
#    - purple                                                                  #
#    - random (one of above, but not the same as it is at the moment (if set)) #
#                                                                              #
#------------------------------------------------------------------------------#

#--------------------------#
# Customization AutoLights #
#--------------------------#
module AL
  
  #0 = Light and/or Shadow
  #1 = Spot
  #2 = Both
  Mode = 0
  
  module Light
    Name    = "Light"
    Opacity = 150
    Blend   = 1
    Visible = true
   
  end
  module Shadow
    Name    = "Shadow"
    Opacity = 150
    Blend   = 2
    Visible = true
   
  end
  module Spot
    Name    = "Spot"
    Opacity = 255
    Blend   = 2
    Visible = true
   
    module Flicker
      Opacity = 2 #Random opacity change
      Width   = 2 #Random horizontal zoom
      Height  = 2 #Random vertical zoom
      X       = 2 #Random horizontal movement
      Y       = 2 #Random vertical movement
    end
   
  end
  
end


#---------------------------#
# Customization EventLights #
#---------------------------#
module EL

  Default = "EventLight"
  
  module Flicker
    Opacity = 2 #Random opacity change
    Width   = 2 #Random horizontal zoom
    Height  = 2 #Random vertical zoom
    X       = 2 #Random horizontal movement
    Y       = 2 #Random vertical movement
  end
  
end


#\####/\####/\####/\####/\##------------------------##/\####/\####/\####/\####/#
##\##/##\##/##\##/##\##/##\# DON'T CROSS THIS LINE! #/##\##/##\##/##\##/##\##/##
###\/####\/####\/####\/####\------------------------/####\/####\/####\/####\/###


#---------------------------#
# Script playerlight engine #
#---------------------------#
class AutoLight
  
  include AL
  
  def initialize
    @map_id = $game_map.map_id
    @light_exist = check_existence("#{Light::Name}#{@map_id}")
    @shadow_exist = check_existence("#{Shadow::Name}#{@map_id}")
    @spot_exist = check_existence("#{Spot::Name}")
    create_lights
  end
  
  def check_existence(file)
    format_list = [".png", ".jpeg", ".jpg"]
    format_list.each do |format|
      return true if FileTest.exist?("Graphics/Pictures/#{file}#{format}")
    end
    return false
  end
  
  def create_lights
    @viewport = Viewport.new(0, 0, 544, 416)
    case Mode
    when 0
      draw_light
      draw_shadow
    when 1
      draw_spot
    when 2
      draw_light
      draw_shadow
      draw_spot
    end
    update
  end
  
  def draw_light
    return if !@light_exist
    @light = Sprite.new(@viewport)
    @light.bitmap = Cache.picture("#{Light::Name}#{@map_id}")
    @light.z = 9998
    @light.opacity = Light::Opacity
    @light.blend_type = Light::Blend
    @light.visible = Light::Visible
  end
  
  def draw_shadow
    return if !@shadow_exist
    @Shadow = Sprite.new(@viewport)
    @shadow.bitmap = Cache.picture("#{Shadow::Name}#{@map_id}")
    @shadow.z = 9997
    @shadow.opacity = Shadow::Opacity
    @shadow.blend_type = Shadow::Blend
    @shadow.visible = Shadow::Visible
  end
  
  def draw_spot
    return if !@spot_exist
    @spot = Sprite.new(@viewport)
    @spot.bitmap = Cache.picture("#{Spot::Name}")
    @spot.z = 9999
    @spot.opacity = Spot::Opacity
    @spot.blend_type = Spot::Blend
    @spot.visible = Spot::Visible
  end
  
  def update
    @map_x = $game_map.display_x    / 8
    @map_y = $game_map.display_y    / 8
    @player_x = $game_player.real_x / 8
    @player_y = $game_player.real_y / 8
    case Mode
    when 0
      update_light
      update_shadow
    when 1
      update_spot
    when 2
      update_light
      update_shadow
      update_spot
    end
  end
  
  def update_light
    return if !(@light_exist and [email protected]?)
    @light.visible = Light::Visible
    return if !(@light.x == 0 or
                @light.y == 0 or
                @light.x != @map_x / 256 or
                @light.y != @map_y / 256)
    @light.x = -@map_x
    @light.y = -@map_y
  end
  
  def update_shadow
    return if !(@shadow_exist and [email protected]?)
    @shadow.visible = Shadow::Visible
    return if !(@shadow.x == 0 or
                @shadow.y == 0 or
                @shadow.x != @map_x / 256 or
                @shadow.y != @map_y / 256)
    @shadow.x = -@map_x
    @shadow.y = -@map_y
  end
  
  def update_spot
    return if !(@spot_exist and [email protected]?)
    @spot.visible = Spot::Visible
    @spot.opacity = Spot::Opacity + rand(Spot::Flicker::Opacity) -
                                    rand(Spot::Flicker::Opacity)
    @spot.zoom_x = 1 + (rand(Spot::Flicker::Width)  / 100.0) -
                       (rand(Spot::Flicker::Width)  / 100.0)
    @spot.x = @player_x - @map_x - (@spot.width / 2) + 16 +
                        rand(Spot::Flicker::X) - rand(Spot::Flicker::X)
    @spot.zoom_y = 1 + (rand(Spot::Flicker::Height) / 100.0) -
                       (rand(Spot::Flicker::Height) / 100.0)
    @spot.y = @player_y - @map_y - (@spot.height / 2) + 16 +
                        rand(Spot::Flicker::Y) - rand(Spot::Flicker::Y)
  end
  
  def dispose
    case Mode
    when 0
      dispose_light
      dispose_shadow
    when 1
      dispose_spot
    when 2
      dispose_light
      dispose_shadow
      dispose_spot
    end
    @viewport.dispose
  end
  
  def dispose_light
    return if !(@light_exist and [email protected]?)
    @light.dispose
  end
  
  def dispose_shadow
    return if !(@shadow_exist and [email protected]?)
    @shadow.dispose
  end
  
  def dispose_spot
    return if !(@spot_exist and [email protected]?)
    @spot.dispose
  end
  
end


#--------------------------#
# Script eventlight engine #
#--------------------------#
class EventLight
  
  attr_reader :event_lights
  
  def initialize
    create_autolights
  end
  
  def create_autolights
    @event_lights = {}
    $game_map.events.values.each do |event|
      next if event.list == nil
      event.list.each do |list|
        if (list.code == 108 or list.code == 408) and
        list.parameters[0].include?("cast")
          data = eval(list.parameters[0])
          el = Event_LightHolder.new(event, data)
          settings(el, data)
          @event_lights[event.id] = el
          update
        end
      end
    end
  end
  
  def cast(pic = EL::Default,
           color = "white",
           opacity = 255,
           blend_type = 1,
           zoom = 100,
           range = 0)
    return [pic, color, opacity, blend_type, zoom, range]
  end
  
  def settings(event_light, data)
    event_light.el.tone       = pick_color(data[1])
    event_light.el.opacity    = data[2]
    event_light.el.blend_type = data[3]
    event_light.el.zoom_x     = event_light.el.zoom_y = data[4] / 100.0
  end
  
  def dispose
    @event_lights.each_value do |light|
      light.el.dispose
    end
    @event_lights.clear
  end
  
  def update
    @event_lights.each_value do |light|
      light.el.opacity = light.el.opacity + rand(EL::Flicker::Opacity) -
                                            rand(EL::Flicker::Opacity)
      x_zoom = light.el.zoom_x
      y_zoom = light.el.zoom_y
      light.el.zoom_x = x_zoom + (rand(EL::Flicker::Width)  / 100.0) -
                                 (rand(EL::Flicker::Width)  / 100.0)
      light.el.zoom_y = y_zoom + (rand(EL::Flicker::Height) / 100.0) -
                                 (rand(EL::Flicker::Height) / 100.0)
      light.el.x = (light.event.real_x - $game_map.display_x) / 8 -
                   ((light.el.width * x_zoom) / 2) + 16 +
                    rand(EL::Flicker::X) - rand(EL::Flicker::X)
      light.el.y = (light.event.real_y - $game_map.display_y) / 8 -
                   ((light.el.height * y_zoom) / 2) + 16 +
                    rand(EL::Flicker::Y) - rand(EL::Flicker::Y)
    end
  end
  
end


#-----------------#
# Event lightdata #
#-----------------#
class Event_LightHolder
  
  attr_reader   :event
        attr_accessor :el
  attr_accessor :range
        
        def initialize(event, data)
    @event = event
                @el = Sprite.new
    @el.visible = true
                settings(data)
        end
  
  def settings(data)
    @el.bitmap = Cache.picture(data[0])
    @el.tone = pick_color(data[1])
    @el.opacity = data[2]
    @el.blend_type = data[3]
    @el.zoom_x = @el.zoom_y = data[4]
    @range = data[5]
  end
  
end


#--------------#
# Color picker #
#--------------#
def pick_color(color, old_value = Tone.new(0, 0, 0, 0))
  @color = color
  colors = {"white"   =>  Tone.new(255, 255, 255, 255),
            "red"     =>  Tone.new(255, -255, -255, 255),
            "green"   =>  Tone.new(-255, 255, -255, 255),
            "blue"    =>  Tone.new(-255, -255, 255, 255),
            "yellow"  =>  Tone.new(255, 255, -255, 255),
            "orange"  =>  Tone.new(255, -128, -255, 255),
            "purple"  =>  Tone.new(255, -255, 255, 255)
            }
  if @color == "random"
    @color = colors.keys[rand(colors.size)]
    until colors[@color] != old_value
      @color = colors.keys[rand(colors.size)]
    end
  end
  return colors[@color]
end


#----------------#
# On map display #
#----------------#
class Scene_Map < Scene_Base
  
  alias autolight_start start
  alias autolight_terminate terminate
  alias autolight_update update
  alias autolight_fadein fadein
  
  def start
    autolight_start
    light_start
  end
  
  def light_start
    $AutoLight = AutoLight.new
    $EventLight = EventLight.new
  end
  
  def terminate
    autolight_terminate
    light_terminate
  end
  
  def light_terminate
    $AutoLight.dispose
    $EventLight.dispose
  end
  
  def update
    light_update
    autolight_update
  end
  
  def light_update
    $AutoLight.update
    $EventLight.update
  end
  
  def fadein(duration)
    light_fade
    autolight_fadein(duration)
  end
  
  def light_fade
    $AutoLight.dispose
    $AutoLight = AutoLight.new
    $EventLight.dispose
    $EventLight = EventLight.new
  end
  
end


#---------------#
# Read event_id #
#---------------#
class Game_Interpreter
  
  attr_reader :event_id
  
end


#---------------------#
# Change Functions AL #
#---------------------#
module AL
  
  def self.mode(val)
    @val = val
    return if !fixnum?(@val)
    eval("AL::Mode = #{@val}")
    $AutoLight.dispose
    $AutoLight = AutoLight.new
  end
  
  def self.light(parm, val)
    @val = val
    case parm.capitalize
    when "Name";    @val.to_s!
    when "Visible"; return if !boolean?(@val)
    else;           return if !fixnum?(@val)
    end
    eval("AL::Light::#{parm.capitalize} = #{@val}")
    $AutoLight.dispose
    $AutoLight = AutoLight.new
  end
  
  def self.shadow(parm, val)
    @val = val
    case parm.capitalize
    when "Name";    @val.to_s!
    when "Visible"; return if !boolean?(@val)
    else;           return if !fixnum?(@val)
    end
    eval("AL::Shadow::#{parm.capitalize} = #{@val}")
    $AutoLight.dispose
    $AutoLight = AutoLight.new
  end
  
  def self.spot(parm, val)
    @val = val
    case parm.capitalize
    when "Name";    @val.to_s!
    when "Visible"; return if !boolean?(@val)
    else;           return if !fixnum?(@val)
    end
    eval("AL::Spot::#{parm.capitalize} = #{@val}")
    $AutoLight.dispose
    $AutoLight = AutoLight.new
  end
  
  def self.flicker(parm, val)
    @val = val
    return if !fixnum?(@val)
    eval("AL::Spot::Flicker::#{parm.capitalize} = #{@val}")
    $AutoLight.dispose
    $AutoLight = AutoLight.new
  end
   
end


#---------------------#
# Change Functions EL #
#---------------------#
module EL
  
  def self.bitmap(val, index = nil)
    @val = val
    index = $game_map.interpreter.event_id if index == nil
    $EventLight.event_lights[index].el.bitmap = Cache.picture(@val)
  end
  
  def self.color(val, index = nil)
    @val = val
    index = $game_map.interpreter.event_id if index == nil
    old_value = $EventLight.event_lights[index].el.tone
    $EventLight.event_lights[index].el.tone = pick_color(@val, old_value)
  end
  
  def self.opacity(val, index = nil)
    @val = val
    return if !fixnum?(@val)
    index = $game_map.interpreter.event_id if index == nil
    $EventLight.event_lights[index].el.opacity = @val
  end
  
  def self.blend(val, index = nil)
    @val = val
    return if !fixnum?(@val)
    index = $game_map.interpreter.event_id if index == nil
    $EventLight.event_lights[index].el.blend_type = @val
  end
  
  def self.visible(val, index = nil)
    @val = val
    return if !boolean?(@val)
    index = $game_map.interpreter.event_id if index == nil
    $EventLight.event_lights[index].el.visible = @val
  end
  
  def self.zoom(val, index = nil)
    @val = val
    return if !fixnum?(@val)
    index = $game_map.interpreter.event_id if index == nil
    $EventLight.event_lights[index].el.zoom_x = @val / 100.0
    $EventLight.event_lights[index].el.zoom_y = @val / 100.0
  end
  
  def self.range(val, index = nil)
    @val = val
    return if !fixnum?(@val)
    index = $game_map.interpreter.event_id if index == nil
    $EventLight.event_lights[index].range = @val
  end
  
end


#-----------------#
# Wrong input fix #
#-----------------#

# String/Fixnum -> Boolean
def boolean?(val)
  return false if !(val.is_a? FalseClass or
                    val.is_a? TrueClass  or
                    val.is_a? String     or
                    val.is_a? Fixnum)
  @val = eval(val) if val.is_a? String
  if val.is_a? Fixnum or @val.is_a? Fixnum
    val = @val if @val.is_a? Fixnum
    if val == -1 or val == 1; @val = true
    elsif val == 0;           @val = false
    else;                     return false
    end
  end
  return true
end

# String -> Fixnum
def fixnum?(val)
  return false if !(val.is_a? Fixnum or val.is_a? String)
  @val = val.to_i if val.is_a? String
  return true
end