Dynamic Lights & Shadows

[GR-FoxDie]

Dynamic Lights & Shadows
Version: 1.5

Übersetzt mit goggle sprachtool.

Features
 Grundsätzlich die gleichen wie Rataime's Shadow-Skript. Doch!
 
 * Schatten-Overlay, das System wissen, wann die Anzeige der Schatten oder nicht
 * Es besteht die Möglichkeit zur Kontrolle der Quelle: schalten Sie das Licht an / aus, die Richtung ändern, um es zu bewegen
 * Größe der Objekte wird, nicht mehr 1 Fall pro Stück für die Schatten einer Säule
 * Auto-Screen Tönung nach der Anzahl der Lichter ausgeschaltet

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Features
Basically the same as Rataime's Shadow script. But!

    * Shadows overlay, the system know when to display the shadow or not
    * Possibility to control the source: turn the light on/off, change its direction, make it move
    * Height of objects is handled, no more 1 event per tile for the shadow of a pillar
    * Auto-Screen tint according to the number of lights off

Credits by Trebor777

Spoiler for Hiden:

Code: [Auswählen]

=begin
  ===========================================================================
===
   ** Dynamic Light & Shadows
  ------------------------------------------------------------------------------
   Trebor777
   Version 1.5
   16/11/2007
   Version 1.5 is based on Rataime's shadows script,Rewrote the code structure
   and Added extra features
  
  ===========================================================================
===
  Instructions
  ===========================================================================
===
  To create a source light:
  Write a comment on 2 lines
    Light
    arg1|arg2|arg3|arg4|arg5
  
  arg1, is the minimum angle.
  arg2, is the maximum angle
  arg3, the distance in pixel covered by the light
  arg4, the height, in tiles where the light is.
  arg5, the direction of the light, use the same numbers as RMXP is using:
  up: 8, right: 6, down: 2, left: 4
  It will turn the event automatically to this direction and
  draw the light according to it, using its min and max angle.
  
  The 0 is always on the left of the direction.
  example,
  the light "look at" the right, so its direction is 6.
  the min angle is 0, so it'll start from the tile above to whatever
   the max angle is, in a clockwise way.
  
  So if you need to create a light, who covers only a cone of 60?, facing to the
  right, at a height of 1 tile, covering a radius of 150pixels:
      Light
      60|120|150|1|6
      
      
  I might do in the future, a simpler version for that.
  _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-
  To have an event with a shadow:
  Write a comment on 2 lines
    Shadow
    arg1
  
  arg1, is the maximum height of the object, so if you have a pillar on your map
  covering several tiles in height, just create a shadow event at its base,
  and give the height of that pillar as arg1.
  
  For characters, just use a height of 0.
  
  To turn off/on a light:
  Use a script call:
  a simple "self.off=true" (to turn off) or "self.off=false" to turn on is needed.
  What is important is where you use this script call:
  
  If the event switching the light is not the same as the source, you need use the
  "call script" command inside the "set move route" command
    (of course, don't forget to say on which event it applies)
  instead of the default "call script" command found on page3.
  
  ===========================================================================
===
  Configuration
  ===========================================================================
===
  ===========================================================================
===
   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.
  ===========================================================================
==
  =end
  SDK.log('DL&S', "trebor777", 1, "16.11.07")
  if SDK.state('DL&S')
  
  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 ]
  
  #==========================================================================
====
  # 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 = true
  
  #==========================================================================
====
  # Class Light
  #==========================================================================
====
  class Light
    @@lights=[]
    attr_reader :character, :parameters
    #--------------------------------------------------------------------------
    def initialize(viewport,character, param)
      @character = character
      @viewport = viewport
      unless param.nil?
        @parameters = param[0].split('|')
        @anglemin =  @parameters.first.to_i
        @anglemax = @parameters[1].to_i
        @distancemax = @parameters[2].to_i
        @light_height = @parameters[3].to_i
        @base_face_at = @parameters.last.to_i
        @character.direction=@base_face_at
        test = @@lights.find_all{|l| l.character==@character and l.parameters==@parameters}
        if test.size==0
          draw_lights
          update
          @@lights.push(self)
        end
      end
    end
    #--------------------------------------------------------------------------
    def Light.set
      return @@lights
    end
    #--------------------------------------------------------------------------
    def Light.off_size
      result=0
      @@lights.each do |light|
        result+=1 if light.character.off
      end
      return result
    end
    #--------------------------------------------------------------------------
    def dispose
      @s_light.dispose
      @@lights.delete(self)
    end
    #--------------------------------------------------------------------------
    def update
      unless @s_light.nil?
        @s_light.visible=!@character.off
        @s_light.angle=0 if @character.direction==2
        @s_light.angle=-90 if @character.direction==4
        @s_light.angle=180 if @character.direction==8
        @s_light.angle=90 if @character.direction==6
        @s_light.x=@character.screen_x
        @s_light.y=@character.screen_y+32*@light_height
        @s_light.z=@character.screen_z
      end
    end
    #--------------------------------------------------------------------------
    def draw_lights
  
      return if @@lights.include?(self) or (@@lights.find_all{|l| l.character==@character and l.parameters==@parameters}).size>0
      
      radius = @distancemax
      @s_light=Sprite.new(@viewport)
      @s_light.x=@character.screen_x
      @s_light.y=@character.screen_y+32*@light_height
      @s_light.z=@character.screen_z
      @s_light.bitmap=Bitmap.new(radius*2,radius*2)
      @s_light.opacity=90
      @s_light.ox+=radius
      @s_light.oy+=radius
      @s_light.angle=0 if @base_face_at==2
      @s_light.angle=270 if @base_face_at==4
      @s_light.angle=180 if @base_face_at==8
      @s_light.angle=90 if @base_face_at==6
      @s_light.bitmap.draw_pie(radius,radius,radius,Color.new(255,255,100,90),@anglemin, @anglemax)
    end
  end
  #==========================================================================
====
  # Class shadow
  #==========================================================================
====
  class Shadow
    attr_accessor :character
    attr_reader :distance, :distancemax, :overlayed
    @@shadows=[]
    #--------------------------------------------------------------------------
    def initialize(viewport,character, param,light)
      @character = character
      @viewport = viewport
      unless param.nil?
        @parameters = param[0].split('|')
        @shadow_max_height = @parameters[1].to_i
        @anglemin=light.parameters[0].to_f
        @anglemax=light.parameters[1].to_f
        @distancemax=light.parameters[2].to_f
        @light_height= light.parameters[3].to_i
        @source = light
        @s_shadow = RPG::Sprite.new(@viewport)
        @s_shadow.color = Color.new(0, 0, 0)
        update
      end
      @@shadows.push(self)
    end
    #--------------------------------------------------------------------------
    def Shadow.set
      return @@shadows
    end
    #--------------------------------------------------------------------------
    def sprite
      return @s_shadow
    end
    #--------------------------------------------------------------------------
    def dispose
      @s_shadow.dispose
      @@shadows.delete(self)
    end
    #--------------------------------------------------------------------------
    def in_light_range?
      return (@distance<=@distancemax)
    end
    #--------------------------------------------------------------------------
    def overlayed?
      @overlayed =  false
      @@shadows.each do |i|
        s = i.sprite
        next if s.nil? or i == self or @character.tile_id!=0 or s.disposed?
        if (@s_shadow.z)>s.z and @s_shadow.angle.between?(s.angle-1.5,s.angle+1.5)\
         and ((@character.x-i.character.x)**2 + (@character.y-i.character.y)**2)**0.5<=s.zoom_y \
         and s.z>=0
          @s_shadow.visible=false
          @overlayed = true
        end
        return if !@s_shadow.visible
      end
      
      return @overlayed
    end
    #--------------------------------------------------------------------------
    def update
      # set shadow visibility according to the light state
      @s_shadow.visible = !@source.character.off
      if @character.transparent or @character.opacity <= SHADOWS_OPACITY_THRESHOLD
        @s_shadow.visible = false
        return
      end
      if @old_amin.nil? and @old_amax.nil? and @old_dir.nil?
        @old_amin= @anglemin
        @old_amax= @anglemax
        @old_dir = @source.character.direction
      end
      # adapt the angle according to the source direction
      case @source.character.direction
        when 2
          @anglemin= @old_amin+180
          @anglemax= @old_amax+180
        when 4
          @anglemin= @old_amin+90
          @anglemax= @old_amax+90
        when 8
          @anglemin= @old_amin
          @anglemax= @old_amax
        when 6
          @anglemin= @old_amin+270
          @anglemax= @old_amax+270
        end
      if @old_dir!=@source.character.direction
        @old_dir = @source.character.direction
      end
      # simplify the angles if more than 360 or less than 0
      @anglemin%=360;@anglemax%=360
      
      tile_height= @shadow_max_height
      @deltax=(@source.character.real_x-@character.real_x)/4
      @deltay= ((@source.character.real_y+@light_height*128)-(@character.real_y+tile_height*128))/4
      @distance = (((@deltax ** 2) + (@deltay ** 2))** 0.5)
      if @distancemax !=0 and @distance>@distancemax
        @s_shadow.visible = false
        return
      end
      
      @s_shadow.angle = 57.3*Math.atan2(@deltax, @deltay )
      @angle_trigo= (@s_shadow.angle+90) % 360
      
      #test if there is a shadow above it, from something close,and then
      # don't display its shadow
      return if overlayed?
      
      if @anglemin !=0 or @anglemax !=0
        if (@angle_trigo<@anglemin or @angle_trigo>@anglemax) and \
            @anglemin<@anglemax
          @s_shadow.visible = false
          return
        elsif (@angle_trigo<@anglemin and @angle_trigo>@anglemax) and \
               @anglemin>@anglemax
          @s_shadow.visible = false
          return
        end    
      end
      @s_shadow.update
      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
          @s_shadow.bitmap = RPG::Cache.tile($game_map.tileset_name,
          @tile_id, @character.character_hue)
          @s_shadow.src_rect.set(0, 0, 32, 32)
          @s_shadow.ox = 16
          @s_shadow.oy = 32
        else
          @s_shadow.bitmap = RPG::Cache.character(@character.character_name,
            @character.character_hue)
          @cw = @s_shadow.bitmap.width / 4
          @ch = @s_shadow.bitmap.height / 4
          @s_shadow.ox = @cw / 2
          @s_shadow.oy = @ch
        end
      end
      @s_shadow.x = @character.screen_x
      @s_shadow.y = @character.screen_y-8
      @s_shadow.z = @character.screen_z(@ch)-1
      
      if @tile_id!=0 # if the sprite graphic is from the tileset
        # set the Z-Index using the tileset priority settings
        @s_shadow.z = ($game_map.priorities[@tile_id])*32
        # convert the shadow angle, into 8-directions (0-7)
        direction_shadow=((@s_shadow.angle/45+45/2.0+90).round)%8
        # for the middle-Top and top layers,
        for i in [1, 2]
          # get the tile from the converted angle
          tile_around=[$game_map.data[@character.x,@character.y-1,i],
          $game_map.data[@character.x-1,@character.y-1,i],
          $game_map.data[@character.x-1,@character.y,i],
          $game_map.data[@character.x-1,@character.y+1,i],  
          $game_map.data[@character.x,@character.y+1,i],
          $game_map.data[@character.x+1,@character.y+1,i],
          $game_map.data[@character.x+1,@character.y,i],
          $game_map.data[@character.x+1,@character.y-1,i]]
          # if the tile is the empty one go to the next layer
          next if tile_around[direction_shadow]==0
          # else, lower the Z-index if the tile around is "above" or at the same
          # priority of our tile
          @s_shadow.z-=32 if $game_map.priorities[tile_around[direction_shadow]]>=$game_map.priorities[@tile_id]
        end
      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
          @s_shadow.mirror = true
          magic = -magic
        else
          @s_shadow.mirror = false
        end
        sy = (magic-1)*@ch
        @s_shadow.src_rect.set(sx, sy, @cw, @ch)
      end
      # This is the formula of the opacity in function of the distance
      # ** 2 means square
      @s_shadow.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.
      @s_shadow.zoom_y=0.75*(@shadow_max_height+1) + (@distance) / 256 if SHADOW_GETS_LONGER
    end
  end
  #==========================================================================
====
  # ** Zlib    
  #==========================================================================
====
  
  module Zlib
    #==========================================================================
  ==
    # ** Png_File    
    #==========================================================================
  ==
  
    class Png_File < GzipWriter
      #--------------------------------------------------------------------------
      # * Make PNG
      #--------------------------------------------------------------------------
      def make_png(bitmap, mode = 0)
        # Save Bitmap & Mode
        @bitmap, @mode = bitmap, mode
        # Create & Save PNG
        self.write(make_header)
        self.write(make_ihdr)
        self.write(make_idat)
        self.write(make_iend)
      end
      #--------------------------------------------------------------------------
      # * Make Header
      #--------------------------------------------------------------------------
      def make_header
        return [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a].pack('C*')
      end
      #--------------------------------------------------------------------------
      # * Make IHDR
      #--------------------------------------------------------------------------
      def make_ihdr
        ih_size               = [13].pack("N")
        ih_sign               = 'IHDR'
        ih_width              = [@bitmap.width].pack('N')
        ih_height             = [@bitmap.height].pack('N')
        ih_bit_depth          = [8].pack('C')
        ih_color_type         = [6].pack('C')
        ih_compression_method = [0].pack('C')
        ih_filter_method      = [0].pack('C')
        ih_interlace_method   = [0].pack('C')
        string = ih_sign + ih_width + ih_height + ih_bit_depth + ih_color_type +
                 ih_compression_method + ih_filter_method + ih_interlace_method
        ih_crc = [Zlib.crc32(string)].pack('N')
        return ih_size + string + ih_crc
      end
      #--------------------------------------------------------------------------
      # * Make IDAT
      #--------------------------------------------------------------------------
      def make_idat
        header  = "\x49\x44\x41\x54"
        data    = @mode == 0 ? make_bitmap_data0 : make_bitmap_data1
        data    = Zlib::Deflate.deflate(data, 8)
        crc     = [Zlib.crc32(header + data)].pack('N')
        size    = [data.length].pack('N')
        return size + header + data + crc
      end
      #--------------------------------------------------------------------------
      # * Make Bitmap Data 0
      #--------------------------------------------------------------------------
      def make_bitmap_data0
        gz = Zlib::GzipWriter.open('hoge.gz')
        t_Fx = 0
        w = @bitmap.width
        h = @bitmap.height
        data = []
        for y in 0...h
          data.push(0)
          for x in 0...w
            t_Fx += 1
            if t_Fx % 10000 == 0
              Graphics.update
            end
            if t_Fx % 100000 == 0
              s = data.pack("C*")
              gz.write(s)
              data.clear
            end
            color = @bitmap.get_pixel(x, y)
            red = color.red
            green = color.green
            blue = color.blue
            alpha = color.alpha
            data.push(red)
            data.push(green)
            data.push(blue)
            data.push(alpha)
          end
        end
        s = data.pack("C*")
        gz.write(s)
        gz.close  
        data.clear
        gz = Zlib::GzipReader.open('hoge.gz')
        data = gz.read
        gz.close
        File.delete('hoge.gz')
        return data
      end
      #--------------------------------------------------------------------------
      # * Make Bitmap Data Mode 1
      #--------------------------------------------------------------------------
      def make_bitmap_data1
        w = @bitmap.width
        h = @bitmap.height
        data = []
        for y in 0...h
          data.push(0)
          for x in 0...w
            color = @bitmap.get_pixel(x, y)
            red = color.red
            green = color.green
            blue = color.blue
            alpha = color.alpha
            data.push(red)
            data.push(green)
            data.push(blue)
            data.push(alpha)
          end
        end
        return data.pack("C*")
      end
      #--------------------------------------------------------------------------
      # * Make IEND
      #--------------------------------------------------------------------------
      def make_iend
        ie_size = [0].pack('N')
        ie_sign = 'IEND'
        ie_crc  = [Zlib.crc32(ie_sign)].pack('N')
        return ie_size + ie_sign + ie_crc
      end
    end
  end
  #==========================================================================
====
  # Class Game Event
  #==========================================================================
====
  class Game_Event
    alias treb_mobile_source_game_event_initialize initialize
    attr_accessor :off, :direction
    def initialize(*args)
      # create the off attribute, only used for the lights
      @off = false
      treb_mobile_source_game_event_initialize(*args)
    end
  end
  #==========================================================================
====
  # class Spriteset Map
  #==========================================================================
====
  class Spriteset_Map
    alias trebor777_DLS_spriteset_map_init_characters init_characters
    alias trebor777_DLS_spriteset_map_update_character_sprites update_character_sprites
    alias trebor777_DLS_spriteset_map_dispose dispose
    #--------------------------------------------------------------------------
    def init_characters
      trebor777_DLS_spriteset_map_init_characters
      # create the lights and shadows arrays
      @lights = []
      @shadows = []
      @viewport1.visible=false
      @viewport2.visible=false
      @viewport3.visible=false
      for i in $game_map.events.keys.sort
        # Search for light trigger
        light_param = SDK.event_comment_input($game_map.events[i], 1, "Light")
        # if not found go to the next iteration
        next if light_param.nil?
        # else add it to the Lights Hash, and create a new light
        @lights.push( Light.new(@viewport1,$game_map.events[i],light_param) )
        # create the shadow for the player.
        @shadows.push( Shadow.new(@viewport1,$game_player, ['0'], @lights.last) )
      end
      for i in $game_map.events.keys.sort
        for light in @lights
          # Search for shadow trigger
          shadow_param = SDK.event_comment_input($game_map.events[i], 1, "Shadow")
          next if shadow_param.nil?
          @shadows.push( Shadow.new(@viewport1,$game_map.events[i], shadow_param, light) )
        end
      end
      @viewport1.visible=true
      @viewport2.visible=true
      @viewport3.visible=true
    end
    #--------------------------------------------------------------------------
    def update_character_sprites
      trebor777_DLS_spriteset_map_update_character_sprites
      lights_off = 0
      # Update the lights
      for light in @lights
        light.update
        # count the number of lights off
        lights_off+=1 if light.character.off
      end
      # Update the Shadows
      for shade in @shadows
        shade.update
      end
      if @lights.size>0
        # updating screen tinting according to the number of lights on
        value=((lights_off.to_f/@lights.size)*(-180)).round
        $game_screen.start_tone_change(Tone.new(value,value,value,value), 1)
      else
        $game_screen.start_tone_change(Tone.new(0,0,0,0), 1)
      end
    end
   #--------------------------------------------------------------------------
    def dispose
      for light in @lights
        light.dispose
      end
      # Update the Shadows
      for shade in @shadows
        shade.dispose
      end
      @lights = []
      @shadows = []
    end
  end
  #==========================================================================
====
  # Class Bitmap
  #==========================================================================
====
  class Bitmap
    #--------------------------------------------------------------------------
    def draw_line(x1, y1, x2, y2, width = 1, color = Color.new(255, 255, 255))
      # Return if width is less than or 0
      return if width <= 0
      # Reverse all parameters sent if 2 x is less than the first x
      x1, x2, y1, y2 = x2, x1, y2, y1 if x2 < x1    
      # Get S (1/2 width)
      s = width / 2.0
      # If X Coordinates are equal
      if x1 == x2
        # Draw Vertical line
        fill_rect(x1 - s, [y1, y2].min, width, (y2 - y1).abs, color)
      # If Y Coordinates are equal
      elsif y1 == y2
        # Draw Horizontal line
        fill_rect(x1, y1 - s, x2 - x1, width, color)
      end
      # Get Length
      length = x2 - x1 < (y2 - y1).abs ? (y2 - y1).abs : x2 - x1
      # Get Increments
      x_increment, y_increment = (x2 - x1) / length.to_f, (y2 - y1) / length.to_f
      # Get Current X and Y
      x, y = x1, y1
      # While Current X is less than end X
      while x < x2
        # Draw Box of width width and width height
        fill_rect(x-s, y-s, width, width, color)
        # Increment X and Y
        x += x_increment
        y += y_increment
      end
    end
    #--------------------------------------------------------------------------
    # Draw pie, take quite a long time as it draws each line.
    #--------------------------------------------------------------------------
    def draw_pie(x,y,radius,color = Color.new(255, 255, 255, 255),start_angle=0,end_angle=360)
      end_angle+=360 if end_angle
      name_string="#{radius}_#{start_angle}_#{end_angle}"
      #filename="Graphics/Pictures/#{name_string}.png"
      if FileTest.exist?("Graphics/Pictures/#{name_string}.png")
        temp = RPG::Cache.picture(name_string)
        blt(0,0,temp,temp.rect)
      else
        Graphics.transition
        t = Progress_Bar.new(160,240,320,20,end_angle-start_angle+2 )
        for i in start_angle...end_angle
          t.current_step+=1
          t.update
          Graphics.update
          for j in 0..2
            x_=(Math::cos((i+j/2.0)*Math::PI/180)*radius).round+x
            y_=(Math::sin((i+j/2.0)*Math::PI/180)*radius).round+y
            draw_line(x, y, x_, y_, 2,color)
          end
        end
        t.current_step+=1
        t.update
        Graphics.update
        make_png(name_string, 'Graphics/Pictures/')
        t.current_step+=1
        t.update
        Graphics.update
        t.dispose
      end
    end
    def make_png(name = 'like', path = '', mode = 0)
      Dir.make_dir(path) if path != '' and !FileTest.directory?(path)
      Zlib::Png_File.open('temp.gz')   { |gz| gz.make_png(self, mode) }
      Zlib::GzipReader.open('temp.gz') { |gz| $read = gz.read }
      f = File.open(path + name + '.png', 'wb')
      f.write($read)
      f.close
      File.delete('temp.gz')
    end
  end
  
  class Progress_Bar < Sprite
    #--------------------------------------------------------------------------
    # * Public Instance Variables
    #--------------------------------------------------------------------------
    attr_accessor :current_step   # The Current Step
    attr_accessor :steps          # The max amount of steps
    #----------------------------------------------------------------------------
    # * Initialize Object
    #----------------------------------------------------------------------------
    def initialize(x,y,width,height=16,steps=100,start=0)
      super()
      @steps = steps
      self.x = x
      self.y = y
      @current_step= start
      @width = width
      @height = height
      @w = 9
      @nb_bars = @width/@w
      @c1 = Color.new(46,211,49,255)
      @c2 = Color.new(46,211,49,227)
      @c3 = Color.new(46,211,49,202)
      @c4 = Color.new(46,211,49,177)
      @c5 = Color.new(46,211,49,152)
      @c6 = Color.new(46,211,49,127)
      @stretch_c = (@height-4)/16.0
      self.bitmap = Bitmap.new(@width, @height)
      self.bitmap.clear
      self.bitmap.fill_rect(0, 0, @width, @height, Color.new(59,59,59,167))
      draw
    end
    #----------------------------------------------------------------------------
    # * Draw Bar
    #----------------------------------------------------------------------------
    def draw
      self.bitmap.fill_rect(1, 1, @width-2, @height-2, Color.new(59,59,59,0))
      for i in 0...((@current_step/@steps.to_f)*@nb_bars).round
        self.bitmap.fill_rect(i*@w+1,2,@w-2,@height-4,@c6)
        self.bitmap.fill_rect(i*@w+1,3*@stretch_c,@w-2,@height-6*@stretch_c,@c5)
        self.bitmap.fill_rect(i*@w+1,4*@stretch_c,@w-2,@height-8*@stretch_c,@c4)
        self.bitmap.fill_rect(i*@w+1,5*@stretch_c,@w-2,@height-10*@stretch_c,@c3)
        self.bitmap.fill_rect(i*@w+1,6*@stretch_c,@w-2,@height-12*@stretch_c,@c2)
        self.bitmap.fill_rect(i*@w+1,7*@stretch_c,@w-2,@height-14*@stretch_c,@c1)
      end
      @old = @current_step
    end
    #----------------------------------------------------------------------------
    # * Update
    #----------------------------------------------------------------------------
    def update
      draw if @current_step != @old
    end
  end
  #SDK test
  end

[Noa3]

Hört sich ganz interessant an aer kanz jemand auf deutsch übersetzen
ich bin leider nicht ganz der hellste beim englisch XD

[Noa3]

ok thx kann mann das zufällig für den vx rausbringen?
leider ist ja der rgss und der rgss2 script ein wenig anders
ich verstehe den leider net



aber trozdem
good work^^

[GR-FoxDie]

Hört sich ganz interessant an aer kanz jemand auf deutsch übersetzen
ich bin leider nicht ganz der hellste beim englisch XD

 Habe es nochmal mit google sprachtool für alle übersetzt.

Werde es jetzt bei allen sachen machen die ich poste.