Chaos Project

#==============================================================================
# �¡ Sprite_Shadow (Sprite_Ombre )
# Based on Genzai Kawakami's shadows, dynamisme&features by Rataime, extra features Boushy
#==============================================================================

CATERPILLAR_COMPATIBLE = true

class Game_Party
 attr_reader :characters
end

class Sprite_Shadow < RPG::Sprite

 attr_accessor :character

 def initialize(viewport, character = nil,source = nil,anglemin=0,anglemax=0,distancemax=0)
   super(viewport)
   @anglemin=anglemin.to_f
   @anglemax=anglemax.to_f
   @distancemax=distancemax.to_f
   @character = character
   @source = source
   update
 end

 def update
   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 = (not @character.transparent)
   if @tile_id == 0
     sx = @character.pattern * @cw
     sy = (@character.direction - 2) / 2 * @ch
     if self.angle>90 or angle<-90
       if @character.direction== 6
              sy = ( 4- 2) / 2 * @ch
       end
       if @character.direction== 4
              sy = ( 6- 2) / 2 * @ch
       end
       if @character.direction== 2
              sy = ( 8- 2) / 2 * @ch
       end
       if @character.direction== 8
              sy = ( 2- 2) / 2 * @ch
       end
     end
     self.src_rect.set(sx, sy, @cw, @ch)
   end
   self.x = @character.screen_x
   self.y = @character.screen_y-5
   self.z = @character.screen_z(@ch)-1
   self.opacity = @character.opacity
   self.blend_type = @character.blend_type
   self.bush_depth = @character.bush_depth
   if @character.animation_id != 0
     animation = $data_animations[@character.animation_id]
     animation(animation, true)
     @character.animation_id = 0
   end
   @deltax=@source.x-self.x
   @deltay= @source.y-self.y
   self.angle = 57.3*Math.atan2(@deltax, @deltay )
   @angle_trigo=self.angle+90
   if @angle_trigo<0
     @angle_trigo=360+@angle_trigo
   end
   self.color = Color.new(0, 0, 0)
   @distance = ((@deltax ** 2) + (@deltay ** 2))
   if$game_map.shadows==-1
     self.opacity = 0
   else
     self.opacity = 400000/(@distance+8000)   
   end
   @distance = @distance ** 0.5
   if @distancemax !=0 and @distance>=@distancemax
     self.opacity=0
   end
   if @anglemin !=0 or @anglemax !=0
      if (@angle_trigo<@anglemin or @angle_trigo>@anglemax) and @anglemin<@anglemax
        self.opacity=0
      end
      if (@angle_trigo<@anglemin and @angle_trigo>@anglemax) and @anglemin>@anglemax
        self.opacity=0
      end    
   end
 end
end

#===================================================
# �¥ CLASS Sprite_Character edit
#===================================================

class Sprite_Character < RPG::Sprite
 alias shadow_initialize initialize
 
 def initialize(viewport, character = nil)
   @character = character
   super(viewport)
   @ombrelist=[]
   if (character.is_a?(Game_Event) and character.list!=nil and character.list[0].code == 108 and character.list[0].parameters == ["s"])
     if (character.list[1]!=nil and character.list[1].code == 108)
       @anglemin=character.list[1].parameters[0]
     end
     if (character.list[2]!=nil and character.list[2].code == 108)
       @anglemax=character.list[2].parameters[0]
     end
     if (character.list[3]!=nil and character.list[3].code == 108)
       @distancemax=character.list[3].parameters[0]
     end 
    for i in $game_map.events.keys.sort
     if ($game_map.events[i].is_a?(Game_Event) and $game_map.events[i].list!=nil and $game_map.events[i].list[0].code == 108 and $game_map.events[i].list[0].parameters == ["o"])
       @ombrelist[i+1] = Sprite_Shadow.new(viewport, $game_map.events[i],self,@anglemin,@anglemax,@distancemax)
     end
    end
    @ombrelist[1] = Sprite_Shadow.new(viewport, $game_player,self,@anglemin,@anglemax,@distancemax)
#===================================================
# �œ Compatibility with fukuyama's caterpillar script
#===================================================
if 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
   shadow_initialize(viewport, @character)
 end
 
 alias shadow_update update
 
 def update
   shadow_update
   if @ombrelist!=[]
     for i in 1..@ombrelist.size
       if @ombrelist[i]!=nil
         @ombrelist[i].update
       end
     end
   end
 end 
 
end

#===================================================
# �¥ CLASS Scene_Save edit
#===================================================
class Scene_Save < Scene_File
 
 alias shadows_write_save_data write_save_data
 
 def write_save_data(file)
   $game_map.shadows = nil
   shadows_write_save_data(file)
 end
end

#===================================================
# �¥ CLASS Game_Map edit
#===================================================
class Game_Map
 attr_accessor :shadows
end

class Game_Map
  # Returns true if the tile is considered to have a graphic displayed under
  # the character's sprite.
  def bottom_graphic_tile?(x, y)
    if @map_id != 0
      for i in [2, 1, 0]
        tile_id = data[x, y, i]
        if tile_id == nil
          return false
        elsif @terrain_tags[tile_id] == 7
          return true
        end
      end
    end
    return false
  end
  
  def tile_id(x, y, h = nil)
    if @map_id != 0
      return tile_id[x,y,h] unless h.nil?
      for i in [2, 1, 0]
        tile_id = data[x, y, i]
        next if tile_id == nil or tile_id == 0
        return data[x,y,i]
      end
    end
    return nil
  end
  
end

#==============================================================================
# ** Sprite_Character
#------------------------------------------------------------------------------
#  This sprite is used to display the character.It observes the Game_Character
#  class and automatically changes sprite conditions.
#==============================================================================

class Sprite_Character < RPG::Sprite
  
  alias reinit_this_again_for_tiles initialize
  def initialize(viewport, character = nil)
    @over_special_tile = false
    @grass_sprite = Sprite.new(viewport)
    @grass_sprite.bitmap = Bitmap.new(32, 5)
    reinit_this_again_for_tiles(viewport, character)
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  alias update_grass_graphic_after update
  def update
    # Call alias update method
    update_grass_graphic_after
    # If tile that the character is over is a 'special' tile
    cx, cy = character.real_x/128, character.real_y/128
    # Check if moving over a layer tile
    if $game_map.bottom_graphic_tile?(cx, cy) or
    $game_map.bottom_graphic_tile?(cx+1, cy) or
    $game_map.bottom_graphic_tile?(cx, cy+1)
      # Initialize overlaying graphic
      @grass_sprite.bitmap.clear
      #@grass_sprite.bitmap.dispose unless @grass_sprite.bitmap.nil?
      #@grass_sprite.bitmap = nil
      # Set bitmap to width of 32 and height of 5
      #@grass_sprite.bitmap = Bitmap.new(32, 5) #if @grass_sprite.bitmap.nil?
      # Get tileset graphic
      tileset_bitmap = RPG::Cache.tileset($game_map.tileset_name)
      
      # Get tile IDs (current, to the right, to the south)
      tile_id1 = $game_map.tile_id(cx, cy)
      tile_id2 = $game_map.tile_id(cx+1, cy)
      tile_id3 = $game_map.tile_id(cx, cy+1)
      #p [tile_id1,tile_id2,tile_id3] if Input.trigger?(Input::SHIFT)
      # Condition checking variables
      current_grassy = (tile_id1 >= 384 and $game_map.bottom_graphic_tile?(cx, cy))
      right_grassy = (tile_id2 >= 384 and $game_map.bottom_graphic_tile?(cx+1, cy))
      bottom_grassy = (tile_id3 >= 384 and $game_map.bottom_graphic_tile?(cx, cy+1))
      tile_id1 -= 384
      tile_id2 -= 384
      tile_id3 -= 384
      #If current tile is grassy, and not moving
      if current_grassy and !@character.moving?
        sox, soy = (tile_id1 % 8) * 32, (tile_id1 / 8) * 32 + 26
        rect = Rect.new(sox, soy, 32, 5)
        @grass_sprite.bitmap.blt(0, 0, tileset_bitmap, rect)
        
      elsif !current_grassy and !@character.moving?
        
      #If on grass and moving down to grass: Draw all the rectangles from x,y to x,y+1.
      elsif current_grassy and bottom_grassy and @character.real_y / 128 < @character.y
        height_remaining = 5
        y1 = (@character.real_y % 128) / 4
        p y1 if Input.trigger?(Input::SHIFT)
        unless y1 >= 5
          sox, soy = (tile_id1 % 8) * 32, (tile_id1 / 8) * 32 + 26 + y1
          h = 5-y1
          rect = Rect.new(sox,soy,32,h)
          @grass_sprite.bitmap.blt(0, 0, tileset_bitmap, rect)
          height_remaining -= h
        end
        if height_remaining > 0
          sox, soy = (tile_id3 % 8) * 32, (tile_id3 / 8) * 32 + [y1 - 5, 0].max
          rect = Rect.new(sox,soy,32,height_remaining)
          @grass_sprite.bitmap.blt(0, 5-height_remaining, tileset_bitmap, rect)
        end
        
      #If on grass and moving down off grass: Do not bother to draw rectangles at all
      elsif current_grassy and !bottom_grassy and @character.real_y / 128 < @character.y
        
      #If on grass and moving up to grass: Same as first condition
      elsif bottom_grassy and current_grassy and @character.real_y / 128 >= @character.y
        height_remaining = 5
        y1 = (@character.real_y % 128) / 4
        unless y1 == 0 #<- Is that even possible? I don't think so
          sox, soy = (tile_id3 % 8) * 32, (tile_id3 / 8) * 32 + [y1 - 5, 0].max
          h = [y1, 5].min
          height_remaining -= h
          rect = Rect.new(sox,soy,32,h)
          @grass_sprite.bitmap.blt(0, [height_remaining, 0].max, tileset_bitmap, rect)
        end
        if height_remaining > 0
          sox, soy = (tile_id1 % 8) * 32, (tile_id1 / 8) * 32 + (31 - y1)
          rect = Rect.new(sox,soy,32,height_remaining)
          @grass_sprite.bitmap.blt(0, 0, tileset_bitmap, rect)
        end
      
      #If on grass and moving up to nothing: Draw rectangles all the way to the last possible spot
      elsif bottom_grassy and !current_grassy and @character.real_y / 128 >= @character.y
        y1 = (@character.real_y % 128) / 4
        p y1 if Input.trigger?(Input::SHIFT)
        unless y1 == 0 #<- Is that even possible? I don't think so
          sox, soy = (tile_id3 % 8) * 32, (tile_id3 / 8) * 32 + [y1 - 5, 0].max
          h = [y1, 5].min
          rect = Rect.new(sox,soy,32,h)
          @grass_sprite.bitmap.blt(0, 0, tileset_bitmap, rect)
        end
        
        
      #If not on grass and moving down onto grass: Reverse process of above
      elsif !current_grassy and bottom_grassy and @character.real_y / 128 < @character.y
        y1 = (@character.real_y % 128) / 4
        unless y1 == 0 #<- Is that even possible? I don't think so
          sox, soy = (tile_id3 % 8) * 32, (tile_id3 / 8) * 32 + [y1 - 5, 0].max
          h = [y1, 5].min
          rect = Rect.new(sox,soy,32,h)
          @grass_sprite.bitmap.blt(0, 0, tileset_bitmap, rect)
        end
        
      #If not on grass and moving up onto grass: Do not bother to draw rectangles
      elsif !bottom_grassy and current_grassy
        
      end
    end
    @grass_sprite.x = @character.screen_x - 16
    @grass_sprite.y = @character.screen_y - 5
    @grass_sprite.z = @character.screen_z + 32
  end
  
end