Ruby Quellcode

#==============================================================================
# ** Dynamic Shadows
#------------------------------------------------------------------------------
# Rataime
# Version 4.0
# 06/05/2007 (2007-05-06)
# Version 1.0 was based on Genzai Kawakami's shadows, extra features Boushy
#==============================================================================
 
#==============================================================================
# Here's the brand new free configuration feature
# The comments will be compared to the pattern using Regexp, except that I did
# the entire work for you, so you don't have to know regexps at all.
# Just choose the trigger ('s', 'begin shadow' or whatever), and the pattern
# The pattern can be one line or a list to use multiple comment lines.
# arg1 is the minimum angle
# arg2 is the maximum angle
# arg3 is the maximum distance
# The only thing you must do is using 'trigger' before the arguments
# Examples :
# 
# SHADOWS_SOURCE_COMMENT_TRIGGER = 's'
# SHADOWS_SOURCE_COMMENT_PATTERN = ['trigger','arg1','arg2','arg3']
# SHADOWS_CHAR_COMMENT_TRIGGER = 'o'
# SHADOWS_CHAR_COMMENT_PATTERN = 'trigger'
# is the old way to use shadows, with a single 's' in the first line, and the
# arguments in following lines
#
# SHADOWS_SOURCE_COMMENT_TRIGGER = 'begin shadow source'
# SHADOWS_SOURCE_COMMENT_PATTERN = 
# ['trigger','anglemin arg1','anglemax arg2','distancemax arg3']
# SHADOWS_CHAR_COMMENT_TRIGGER = 'begin shadow'
# SHADOWS_CHAR_COMMENT_PATTERN = 'trigger'
# will work with :
# Comment "begin shadow source"
# Comment "anglemin 0"
# Comment "anglemax 0"
# Comment "distancemax 250"
#
# Take the time to choose something you like, and something compatible with other
# scripts.
# Note that the comments will be detected even if they aren't in the beginning
# of the event's action list. Ah, and you can switch the arguments if you like
#==============================================================================
 
#==============================================================================
# Here is the method I like best, because of its compatibility with other
# scripts. But don't hesitate to change it.
# It will react to something like Shadow|0|0|250
#==============================================================================
 
SHADOWS_SOURCE_COMMENT_TRIGGER = 'Shadow'
SHADOWS_SOURCE_COMMENT_PATTERN = 'trigger|arg1|arg2|arg3'
SHADOWS_CHAR_COMMENT_TRIGGER = 'o'
SHADOWS_CHAR_COMMENT_PATTERN = 'trigger'
 
#==============================================================================
# An important option : if you set it to true, the shadows will get longer if
# you are far from the source. Nice, but induces lag : it will eat your CPU,
# and quite possibly your first born if you try that on a big map.
#==============================================================================
 
 SHADOW_GETS_LONGER = true
 
#==============================================================================
# Misc options
# If an event has its opacity below SHADOWS_OPACITY_THRESHOLD, no shadow will
# be displayed.
# Set SHADOWS_CATERPILLAR_COMPATIBLE to true if you uses the caterpillar script
#==============================================================================
 
 SHADOWS_OPACITY_THRESHOLD = 254
 SHADOWS_CATERPILLAR_COMPATIBLE = false
 
#==============================================================================
# You probably won't need to touch this : it's the 'map' of how to display the
# shadow depending on the event's direction and his relative position to the
# source. a minus means the shadow is mirrored. It seems complex, and it is.
# Complain to Enterbrain (why didn't they use something clockwise or counter-
# clockwise ? I suspect it's because of the rm2k legacy. More explanations 
# below.
#==============================================================================
 
SHADOWS_DIRECTION_ARRAY = Array.new
SHADOWS_DIRECTION_ARRAY[2] = [ -3, 4, -2, 1 ]
SHADOWS_DIRECTION_ARRAY[4] = [ 4, -2, 1, -3 ]
SHADOWS_DIRECTION_ARRAY[6] = [ 1, -3, 4, -2 ]
SHADOWS_DIRECTION_ARRAY[8] = [ -2, 1, -3, 4 ]
 
#------------------------------------------------------------------------------
# * SDK Log Script and Check requirements
#------------------------------------------------------------------------------
#SDK.log('Shadows', 'rataime', 1.00, '05.06.2007')
#SDK.check_requirements(2, [1,2])
 
#==============================================================================
# ** Game_Party, for compatibility with the caterpillar script.
#==============================================================================
 
class Game_Party
  attr_reader :characters
end
 
#==============================================================================
# ** Sprite_Shadow, the meat of this script
#==============================================================================
 
class Sprite_Shadow < RPG::Sprite
 
  attr_accessor :character
 
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil,source = nil,anglemin=0, \
                 anglemax=0,distancemax=700)
    super(viewport)
    @anglemin=anglemin.to_f
    @anglemax=anglemax.to_f
    @distancemax=distancemax.to_f
    @character = character
    @source = source
    self.color = Color.new(0, 0, 0)
    update
  end
 
  #--------------------------------------------------------------------------
  # * Update
  #-------------------------------------------------------------------------- 
  def update
    if @character.transparent or @character.opacity <= SHADOWS_OPACITY_THRESHOLD
      self.visible = false
      return
    end
    @deltax=(@source.real_x-@character.real_x)/4
    @deltay= (@source.real_y-@character.real_y)/4
    @distance = (((@deltax ** 2) + (@deltay ** 2))** 0.5)
    if @distancemax !=0 and @distance>@distancemax
      self.visible = false
      return
    end
    self.angle = 57.3*Math.atan2(@deltax, @deltay )
    @angle_trigo= (self.angle+90) % 360
    if @anglemin !=0 or @anglemax !=0
      if (@angle_trigo<@anglemin or @angle_trigo>@anglemax) and \
          @anglemin<@anglemax
        self.visible = false
        return
      elsif (@angle_trigo<@anglemin and @angle_trigo>@anglemax) and \
             @anglemin>@anglemax
        self.visible = false
        return
      end     
    end
    super
    if @tile_id != @character.tile_id or
       @character_name != @character.character_name or
       @character_hue != @character.character_hue
       @tile_id = @character.tile_id
      @character_name = @character.character_name
      @character_hue = @character.character_hue
      if @tile_id >= 384
        self.bitmap = RPG::Cache.tile($game_map.tileset_name,
        @tile_id, @character.character_hue)
        self.src_rect.set(0, 0, 32, 32)
        self.ox = 16
        self.oy = 32
      else
        self.bitmap = RPG::Cache.character(@character.character_name,
          @character.character_hue)
        @cw = bitmap.width / 4
        @ch = bitmap.height / 4
        self.ox = @cw / 2
        self.oy = @ch
      end
    end
    self.visible = true
    self.x = @character.screen_x
    self.y = @character.screen_y-8
    self.z = @character.screen_z(@ch)-1
    if @character.animation_id != 0
      animation = $data_animations[@character.animation_id]
      animation(animation, true)
      @character.animation_id = 0
    end
    if @tile_id == 0
      sx = @character.pattern * @cw
      quarter = ((@angle_trigo/90+0.5).floor)%4
      # The quarter is the position of the event relative to the source.
      # Imagine the source is the o point (0,0). Trace the 2 lines
      # y=x and y=-x : you get something like a big X
      # On the right, quarter=0. Up, quarter = 1, and so on
      # Take the @character.direction row (2,4,6,8), and the quarter
      # column (0,1,2,3) (remember, it starts at 0), and you'll get
      # a number between 1 and 4. It correspond to the row of the charset
      # the shadow will be, and mirrored if negative.
      # Yes, it isn't obvious, but I didn't find any simple operation to
      # get those.
     magic = SHADOWS_DIRECTION_ARRAY[@character.direction][quarter]
      magic = -magic
      if magic < 0
        self.mirror = true
        magic = -magic
      else
        self.mirror = false
      end
      sy = (magic-1)*@ch
      self.src_rect.set(sx, sy, @cw, @ch)
    end
    # This is the formula of the opacity in function of the distance
    # ** 2 means square
    self.opacity = 1200/((@distance ** 2)/ 1000 + 6)
    # This is the formula of the size in function of the distance
    # The 0.75 is here so you have a size of 1:1 when next to the source.
    self.zoom_y=0.75 + @distance / 256 if SHADOW_GETS_LONGER
  end
 
end
 
#======================================================================
# ** Sprite_Character EDIT
#======================================================================
#    All those things could go somewhere else, but they
#    work quite well here.
#======================================================================
 
class Sprite_Character < RPG::Sprite
 
  @@regexp_source = nil
  @@regexp_source_short = nil
  @@regexp_char = nil
  @@regexp_char_short = nil
 
  alias rataime_shadow_initialize initialize
 
  #--------------------------------------------------------------------------
  # * Initialize
  #--------------------------------------------------------------------------
  def initialize(viewport, character = nil)
 
    if @@regexp_source == nil
      regexp_initialize
    end
    @character = character
    super(viewport)
    @ombrelist=[]
    if (character.is_a?(Game_Event) and character.list!=nil)
      # Let's check the comments in our event list
      for j_list in 0..character.list.size-1
        #p [@@regexp_source_short, character.list[j_list].parameters[0]]
        if (character.list[j_list].code == 108 and \
            @@regexp_source_short.match(character.list[j_list].parameters[0])!= nil)
          # Haha ! We found a trigger tag ! Time to retrieve the parameters !
          parameter_string = character.list[j_list].parameters[0]
          j_list += 1
          while j_list < character.list.size and \
                (character.list[j_list].code == 108 or \
                 character.list[j_list].code == 408)
            parameter_string = parameter_string + "\n" + \
                               character.list[j_list].parameters[0]
            j_list += 1
          end
          # The following line is a nifty piece of code. Really. 
          @anglemin,@anglemax,@distancemax = \
          (regexp_get_parameters(parameter_string, true)+[nil]*3)[0..2]
          # We have our source parameters. Let's find which events we should
          # make have a shadow
          for i in $game_map.events.keys.sort
            if ($game_map.events[i].is_a?(Game_Event) and \
                $game_map.events[i].list!=nil)
              for i_list in 0..$game_map.events[i].list.size-1  
                if (($game_map.events[i].list[i_list].code == 108 or \
                     $game_map.events[i].list[i_list].code == 408 )and \
                    @@regexp_char_short.match( \
                      $game_map.events[i].list[i_list].parameters[0])!= nil)
                  @ombrelist[i+1] = Sprite_Shadow.new(viewport, $game_map.events[i],\
                                              self,@anglemin,@anglemax,@distancemax)
                  break # no need to add more than one shadow per source per event
                end
              end # end for                                
            end                                 
          end # end for
          @ombrelist[1] = Sprite_Shadow.new(viewport, $game_player,self,@anglemin,\
                                             @anglemax,@distancemax)
          #===================================================
          # Compatibility with fukuyama's caterpillar script
          #===================================================
          if SHADOWS_CATERPILLAR_COMPATIBLE and $game_party.characters!=nil
 
            for member in $game_party.characters
              @ombrelist.push(Sprite_Shadow.new(viewport, member,self,@anglemin,\
                                                @anglemax,@distancemax))
            end
 
          end
          #===================================================
          # End of the compatibility
          #===================================================
        end
        break # We don't need to go further in the source's list
      end # end for
    end
    rataime_shadow_initialize(viewport, @character)
  end
 
  alias rataime_shadow_update update
  #--------------------------------------------------------------------------
  # * Update
  #--------------------------------------------------------------------------
  def update
    rataime_shadow_update
    if @ombrelist!=[]
      for i in 1..@ombrelist.size
        if @ombrelist[i]!=nil
          @ombrelist[i].update
        end
      end
    end
  end  
 
  #--------------------------------------------------------------------------
  # * Real_x : it just returns the character's real_x
  #--------------------------------------------------------------------------
  def real_x
    return @character.real_x
  end
 
  #--------------------------------------------------------------------------
  # * Real_y : it just returns the character's real_y
  #--------------------------------------------------------------------------
  def real_y
    return @character.real_y
  end
 
  #--------------------------------------------------------------------------
  # * regexp_initialize : the brand new configuration function
  #   This function generate the regexps based on the configuration
  #--------------------------------------------------------------------------
  def regexp_initialize
    @@regexp_source = regexp_generate(true)
    @@regexp_char = regexp_generate(false)
    @@regexp_source_short = @@regexp_source
    @@regexp_char_short = @@regexp_char
    if SHADOWS_SOURCE_COMMENT_PATTERN.is_a?(Array)
      @@regexp_source_short = regexp_generate_short(@@regexp_source)
    end
    if SHADOWS_CHAR_COMMENT_PATTERN.is_a?(Array)
      @@regexp_char_short = regexp_generate_short(@@regexp_char)
    end
  end
  #--------------------------------------------------------------------------
  # * regexp_generate generate a full length regexp including the arguments
  #   detection.
  #--------------------------------------------------------------------------
  def regexp_generate(source = false)
    if source
      pattern = SHADOWS_SOURCE_COMMENT_PATTERN
      trigger = SHADOWS_SOURCE_COMMENT_TRIGGER
      @@argument_indexes_source = []
      indexes = @@argument_indexes_source
    else
      pattern = SHADOWS_CHAR_COMMENT_PATTERN
      trigger = SHADOWS_CHAR_COMMENT_TRIGGER
      @@argument_indexes_char = []
      indexes = @@argument_indexes_char
    end
    if pattern.is_a?(Array)
      string = Regexp.escape(pattern.join("\n"))
    else
      string = Regexp.escape(pattern)
    end
    string = string.gsub('trigger',')('+trigger+')(')
    splitted = string.split('arg')
    regexp = '\A(' + splitted[0] + '(\d+)){0,1}'
    for i in 1..splitted.size-1
      if splitted[i][0..0].to_i == 0
        p 'Error : You probably forgot a digit after an arg'
        raise
      else
        indexes.push(splitted[i][0..0].to_i)
        regexp = regexp + '(' + splitted[i][1..splitted[i].size-1] + '(\d+)){0,1}'
      end
    end
    return Regexp.new(regexp.chomp('(\d+)){0,1}') + ')')
  end
  #--------------------------------------------------------------------------
  # * Will return a shorter regexp, but still able to identify the trigger
  #--------------------------------------------------------------------------
  def regexp_generate_short(regexp)
    string = regexp.inspect
    string = string.split('\n')[0]
    string = string[1..string.size-2]
    return Regexp.new(string)
  end
  #--------------------------------------------------------------------------
  # * regexp_get_parameters is called whenever a trigger has been identify,
  #   and the script wants to know the arguments. It returns an array in the
  #   right orger [arg1,arg2,arg3]
  #--------------------------------------------------------------------------
  def regexp_get_parameters(string, source = false)
    if source
      regexp = @@regexp_source
      indexes = @@argument_indexes_source.dup
    else
      regexp = @@regexp_char
      indexes = @@argument_indexes_char.dup
    end
    indexes = indexes.reverse!
    match_array = regexp.match(string).captures
    return_array = Array.new
    if match_array.size > 3
      for i in 2..match_array.size-1
        if ((i.to_f/2).ceil)*2 != i and match_array[i]!=nil
          return_array[indexes.pop-1] = match_array[i]
        end
      end
    end
    return return_array
  end
 
end