Aldeia RPG

Gostaria de reagir a esta mensagem? Crie uma conta em poucos cliques ou inicie sessão para continuar.

Suporte no desenvolvimento de jogos


5 participantes

    Engine de destruição

    avatar
    samuel6406
    Banido
    Banido

    Mensagens : 49
    Créditos : 11

    Engine de destruição Empty Engine de destruição

    Mensagem por samuel6406 Ter Jun 12, 2012 10:26 pm

    .:ENGINE DE DESTRUIÇÃO:.



    .:INTRODUÇÃO:.


    Esse script super interessante permite criar animações de destruição dos eventos dinamicamente, variando de cortes com espada à machadadas.

    .:CARACTERISTICAS:.


    Plug and Play
    Grande opções para destruir eventos

    .:SCRIPT:.

    Código:
    #==============================================================================
    # ■ Destruction Engine
    #------------------------------------------------------------------------------
    #  By: Rataime
    #  Date: 12/06/2005
    #
    #------------------------------------------------------------------------------

    #  The Destruction Engine is a powerfull way to cut, slice, chop, destroy...
    #  events. It can be customized to fit your ideas
    #
    #------------------------------------------------------------------------------

    #  To use it, you must use the following commands :
    #  - $DE.init
    #  - A target command ($DE.target_event(id) or $DE.target_is_in_front_of_me)
    #  - A set of commands
    #  - $DE.clear 

    #------------------------------------------------------------------------------

    #  Call'n watch action commands (see the next ● for descriptions and options) :
    #  - $DE.decapitate
    #  - $DE.samurai_slash
    #  - $DE.axe_attack
    #  - $DE.double_samurai_slash
    #  - $DE.glass_breaking

    #------------------------------------------------------------------------------
    #
    #  The main command :

    #  $DE.add_line(start_x, start_y, end_x, end_y,speed)
    #  with coordinates corresponding to those on the charset,
    #  mainly 0<x<32 and 0<y<48
    #  and speed the drawing speed (1<=speed<=10).
    #  Speed is optionnal, the default speed will be used if only 4 parameters are given

    #  $DE.add_line draws a line, and define where the event will be cut.
    #  Eg : 2 crossing lines defined with $DE.add_line => 4 pieces.

    #------------------------------------------------------------------------------

    #  Line commands :

    #  $DE.hide_lines :
    #  Will hide future lines

    #  $DE.show_lines :
    #  Won't hide future lines anymore

    #  $DE.erase_lines :
    #  Erases all lines
    #  The pieces will still be there, only line sprites will removed

    #  $DE.draw_line(start_x, start_y, end_x, end_y,speed)
    #  Same as $DE.add_line, but won't actually "cut" the event

    #  $DE.change_line_color(red,green,blue)
    #  Change future lines color
    #  The component values are >=0 and <=255

    #  $DE.change_line_speed(speed)
    #  Change the default line drawing speed
    #  Speed is >=1 and <=10

    #  $DE.change_line_width(pixels)
    #  Change future lines width,in pixels

    #==============================================================================# 

    #  Piece commands, usually used after having cut the event

    #  $DE.collapse
    #  Will collapse every piece the FF way (ie red&transparent)
    #
    #  $DE.fadeout
    #  Will fadeout every piece
    #
    #  $DE.explose
    #  Will make the target explose. Not perfect yet

    #  $DE.refresh_centre
    #  Will readjust pieces centers. Useful before rotating those...
    #
    #  $DE.glass_falling(speed)
    #  Will let the glass pieces fall until they reach the ground

    #  DE_Slide.new(line,number)
    #  Create a slide movement, using a line and a max number of pieces to slide
    #  Pieces are selected from the top to the bottom
    #  Check the call'n watch function samurai_slash for a basic example

    #  $DE.map.pieces[i] :
    #  Refers to the pieces.
    #  pieces[0] is the top one, pieces[$DE.map.pieces.size-1] the bottom one
    #  You can use standard sprite functions, eg :
    #  @map.pieces[0].angle=90
    #  @map.pieces[0].x+=1

    #  $DE.target.reappear :
    #  Will reset target's transparency and passability

    #==============================================================================

    #  Notes :

    #  - The DE is far from perfect : if you experiment a problem, try changing
    #    the order of the add_lines functions

    #  - When changing scenes (eg : opening the menu), the DE will be reset.
    #    Think to disable the menu if you don't want it to happen

    #  - The target event will be invisible & passable, but still fonctionnal :
    #    It's up to you to use a switch or anything to prevent its re-use

    #  - If you see a colored triangle, it is because the script thinks that the
    #    first pixel is transparent. Move the character on the charset, or resize
    #    the charset...
    #
    #  - Bonus for those who read that far :
    #    If you are lazy, use $DE.tiifom instead of $DE.target_is_in_front_of_me...

    #==============================================================================
    # ● Here are the call'n watch functions (aka the "no-brainer functions")
    #    You have to call $DE.init, then the appropriate target function
    #    (eg : $DE.target_is_in_front_of_me) and one of those functions
    #    (eg : $DE.decapitate).
    #    You still can change the lines visibility, color...
    #    Some have facultative options. Eg : To have the head roll on the left, use $DE.decapitate(true)
    #    When you have finished (and removed the head from the floor),
    #    call $DE.clear
    #
    #    Don't hesitate to make your own functions, you can even send them to me and
    #    I'll add them in the next release if they are worthful
    #==============================================================================
    class Destruction_Engine
     
      #=============================================================================
      # ▼ decapitate(roll_on_the_left,hide_the_second_line) by Rataime
      #    Set roll_on_the_left to true to have an inversed animation
      #    Set hide_the_second_line to true to only show the first line
      #=============================================================================

      def decapitate(roll_on_the_left=false , hide_the_second_line=false)
        Audio.se_play("Audio/SE/099-Attack11",80)
        add_line(0,14,32,31,@default_speed)
        hide_the_second_line=false if @hide_line
        if hide_the_second_line
          hide_lines
          add_line(32,14,0,31,10)
          show_lines
        else
          add_line(32,14,0,31,@default_speed)
        end
        refresh_centre # Adjust ox and oy to their correct place. Needed to rotate smoother...
        delta=1
        delta=-1 if roll_on_the_left
        erase_lines
        for i in 1..30
          @map.pieces[0].y+=1 if i%2==0 # every 2 i
          @map.pieces[0].x+=1*delta if i%2==0
          @map.pieces[0].angle-=3*delta
          Graphics.update
        end
        Audio.se_play("Audio/SE/042-Knock03",80)
        erase_lines
      end
     
      #=============================================================================
      # ▼ axe_attack(x) by Rataime
      #    Set time_interval in ms to have a pause between movements
      #=============================================================================

      def axe_attack(time_interval=0,collapsing=false)
        Audio.se_play("Audio/SE/095-Attack07",80)
        add_line(@bmpw/2,0,@bmpw/2,@bmph,@default_speed)
        erase_lines
        refresh_centre # Adjust ox and oy to their correct place. Needed to rotate smoother...
        for i in 1..30*(time_interval+1)
          @map.pieces[0].angle+=3 if i%(time_interval+1)==0
          @map.pieces[1].angle-=3 if i%(time_interval+1)==0
          Audio.se_play("Audio/SE/103-Attack15",80) if i==27*(time_interval+1) or i==28*(time_interval+1)
          Graphics.update
        end
        collapse if collapsing
      end
     
     
      #=============================================================================
      # ▼ samurai_slash(time_interval,collapsing) by Rataime
      #    Set time_interval in ms to have a pause between sliding movements
      #    Set collapsing to true to have it collapse in the end
      #=============================================================================
     
      def samurai_slash(time_interval=0,collapsing=true)
        Audio.se_play("Audio/SE/094-Attack06",80)
        line1 = add_line(0,0.3*@bmph,@bmpw,0.67*@bmph,@default_speed)
        slide1=DE_Slide.new(line1,1)
        erase_lines
        for i in 1..15*(time_interval+1)
          slide1.update if i%(time_interval+1)==0
          Graphics.update
        end
        collapse if collapsing
      end
     
      #=============================================================================
      # ▼ double_samurai_slash(time_interval) by Rataime
      #    Set time_interval in ms to have a pause between sliding movements
      #    Set collapsing to true to have it collapse in the end
      #=============================================================================
     
      def double_samurai_slash(time_interval=0,collapsing=true)
        Audio.se_play("Audio/SE/094-Attack06",80)
        line1 = add_line(0,0.5*@bmph,@bmpw,@bmph-2,@default_speed)
        Audio.se_play("Audio/SE/094-Attack06",80)
        line2 = add_line(0,0.35*@bmph,@bmpw,0.20*@bmph,@default_speed)
        slide1=DE_Slide.new(line2,1)
        slide2=DE_Slide.new(line1,2)
        erase_lines
        for i in 1..15*(time_interval+1)
          slide1.update if i%(time_interval+1)==0
          slide2.update if i%(time_interval+1)==0
          Graphics.update
        end
        collapse if collapsing
      end
     
      #=============================================================================
      # ▼ glass_breaking(sound,speed) by Rataime
      #    Set sound to true to have the glass breaking sound (needs a non-rtp SE)
      #    Set speed to 1 or 2 (>2 is too fast)
      #=============================================================================
     
      def glass_breaking(sound=false,speed=2)
        Audio.se_play("Audio/SE/100-Attack12",80)
        add_line(@bmpw/4,0,@bmpw*3/4,@bmph,@default_speed)
        Audio.se_play("Audio/SE/096-Attack08",80,130)
        add_line(0,0.15*@bmph,@bmpw,0.4*@bmph,@default_speed)
        Audio.se_play("Audio/SE/100-Attack12",80,80)
        add_line(0,0.35*@bmph,@bmpw,0.7*@bmph,@default_speed)
        Audio.se_play("Audio/SE/Glass",80,70)
        hide_lines
        add_line(0,80,@bmpw,80)
        show_lines
        erase_lines
        refresh_centre
        for i in 1..2
          for to_break in 0..@map.pieces.size-1
            if @map.pieces[to_break].x<@bmpx+@bmpw/2
              @map.pieces[to_break].x-=1
            else
              @map.pieces[to_break].x+=1
            end
          end
          Graphics.update
        end
        glass_falling(speed)
      end
     
    #==============================================================================
    # ● Here are the pieces manipulation functions
    #    Usually called after having cut the sprite
    #==============================================================================

      def collapse
        Audio.se_play("Audio/SE/012-System12",80)
        @map.collapse
      end
     
      def fadeout
        @map.fadeout
      end
     
      def explose
        explosion=[]
        refresh_centre
        for to_explose in 0..@map.pieces.size-1
          #This is a hack, wasn't working so I "forced" things to work...
          #I will have to fix that one day !
          end_x=@map.pieces[to_explose].src_rect.width/2+@map.pieces[to_explose].x
          end_y=@map.pieces[to_explose].src_rect.height/2+@map.pieces[to_explose].y
          start_x=@bmpx+@bmpw/2+@bmpw/6
          start_y=@bmpy+@bmph
          explosion[to_explose]=DE_Explosion.new([(end_x - start_x).to_f,-(end_y - start_y).to_f,0],to_explose)
        end
        Audio.se_play("Audio/SE/054-Cannon03",80)
        for i in 1..51
          for to_explose in 0..@map.pieces.size-1
            explosion[to_explose].update
          end
          Graphics.update
        end
      end
     
      def refresh_centre
        @map.refresh_centre
      end

      def glass_falling(speed=2)
        for i in 1..90
          for to_break in 0..@map.pieces.size-1
            if @map.pieces[to_break].y<@bmpy+@bmph+2
              @map.pieces[to_break].y+=1*speed if 2*(@map.pieces.size-to_break)<i
              @map.pieces[to_break].angle+=abovezero(rand(5)-3)*(to_break+1)/(to_break+1).abs
            else
              @map.pieces[to_break].opacity-=20
            end
          end
          Graphics.update
        end
      end
     
    end

    class DE_Slide

      def initialize(line,num)
        @dy=0
        @y=-line[1]
        @x=line[0]
        if @y<0
          @y=-@y
          @x=-@x
        end
        @y=@y/(@x.abs).to_f
        @x=@x/@x.abs
        @num=num
        @map=$DE.map
      end
     
      def update
          @correcty=false
          @dy+=@y-@y.floor
          if @dy>=1
            @dy-=1
            @correcty=true
          end
          for i in 0..@num-1
            @map.pieces[i].x+=@x
            @map.pieces[i].y+=@y.floor
            @map.pieces[i].y+=1 if @correcty
          end
        end
      end
     
      class DE_Explosion

      def initialize(line,num)
        @dy=0
        @y=-line[1]
        @x=line[0]
        @sign=1
        @sign=-1 if @y<0
        @y=@y/(@x.abs).to_f*2
        @x=@x/@x.abs*2
        @num=num
        @map=$DE.map
      end
     
      def update
          @correcty=false
          @dy+=(@y-@y.floor).abs
          if @dy>=1
            @dy-=1
            @correcty=true
          end
          @map.pieces[@num].x+=@x
          @map.pieces[@num].x
          #@map.pieces[@num].zoom_x=0.1+@map.pieces[@num].zoom_x
          #@map.pieces[@num].zoom_y=0.1+@map.pieces[@num].zoom_y
          @map.pieces[@num].y+=@y.floor
          @map.pieces[@num].y+=1*@sign if @correcty
          @map.pieces[@num].opacity-=5
          @map.pieces[@num].angle+=1*@sign
        end
      end
    #==============================================================================
    # ■ DE
    # An unloaded DE
    #==============================================================================

    class DE

      def init
        $DE=Destruction_Engine.new
      end
     
      def Init
        $DE=Destruction_Engine.new
      end
     
    end

    #==============================================================================
    # ■ Destruction_Engine
    # The actual DE. Contains every functions you need to use the DE
    #==============================================================================

    class Destruction_Engine
     
    attr_accessor :slot
    attr_accessor :map
    attr_accessor :target
    attr_accessor :hide_line

    #==============================================================================
    # ● General functions
    #==============================================================================

    def initialize
      @width=2
      @default_speed=5
      @color=Color.new(255, 255, 255)
    end

    def init(n = nil)
      if n==nil
        p "Initialisation already done. Don't forget to $DE.clear"
      else
        @slot[n]=Destruction_Engine.new
      end
    end

    def Init(n = nil)
      init(n)
    end

    def clear
      for i in @map.pieces
        i.opacity=0
      end
      GC::start
      $DE = DE.new
    end

    def Clear
      clear
    end

    def update
      if @map!=nil
        for i in @map.pieces
          i.update
        end
      end
    end

    def abovezero(num)
      if num>0
        return num
      else
        return 0
      end
    end


    def wait(seconds) # Dubealex's delay function
      for i in 0...(seconds * 10)
        sleep 0.1
        Graphics.update
      end
    end

    #==============================================================================
    # ● Target functions
    #==============================================================================

    def target_event(id = nil)
      if id!=nil and $game_map.events[id].is_a?(Game_Event) and @target==nil
        @target = $game_map.events[id]
        @map=DE_Map.new(@target)
          bitmap = RPG::Cache.character(@target.character_name,@target.character_hue)
          @z_line=@target.screen_z(bitmap.height / 4)+5
          @bmpx=@target.screen_x-bitmap.width/8
          @bmpy=@target.screen_y-bitmap.height/4
          @bmph=bitmap.height/4
          @bmpw=bitmap.width/4
          @color_b=bitmap.get_pixel(0,0)
          @linebmp=Linebmp.new(@bmpx,@bmpy,@z_line,@bmpw,@bmph)
      end
    end

    def Target_event(id = nil)
      target_event(id)
    end

    def tiifom
      check_x=$game_player.x
      check_y=$game_player.y
      case $game_player.direction
      when 2
        check_y+=1
      when 4
        check_x-=1
      when 6
        check_x+=1
      when 8
        check_y-=1
      end
      check=$game_map.check_event(check_x, check_y)
      if check.type==Fixnum and @target==nil
        @target=$game_map.events[check]
        @map=DE_Map.new(@target)
          bitmap = RPG::Cache.character(@target.character_name,@target.character_hue)
          @z_line=@target.screen_z(bitmap.height / 4)+5
          @bmpx=@target.screen_x-bitmap.width/8
          @bmpy=@target.screen_y-bitmap.height/4
          @bmph=bitmap.height/4
          @bmpw=bitmap.width/4
          @color_b=bitmap.get_pixel(0,0)
          @linebmp=Linebmp.new(@bmpx,@bmpy,@z_line,@bmpw,@bmph)
      end
    end

    def target_is_in_front_of_me
      tiifom
    end

    #==============================================================================
    # ● Line functions
    #==============================================================================

    def hide_lines
      @hide_line=true
    end

    def show_lines
      @hide_line=false
    end

    def erase_lines
      @linebmp.erase
    end

    def change_line_width(pixels)
      if (pixels>10 or pixels<1)
        p "DE error : Width argument out of range !"
      else
        @width=pixels
      end
    end

    def change_line_color(r,g,b)
      @color=Color.new(r, g, b)
    end

    def change_line_speed(speed)
      if (speed>10 or speed<1)
        p "DE error : Speed argument out of range !"
      else
        @default_speed=speed
      end
    end

    def draw_line(start_x, start_y, end_x, end_y,speed=@default_speed)
      @map.draw_line(start_x, start_y, end_x, end_y,speed,@width,@color)
    end

    #==============================================================================
    # ● The core function. Draw lines & separate sprites into smaller sprites
    #    Reading this can be bad for your health.
    #==============================================================================

    def addline(start_x, start_y, end_x, end_y,speed=@default_speed)
      add_line(start_x, start_y, end_x, end_y,speed)
    end

    def add_line(start_x, start_y, end_x, end_y,speed=@default_speed)
      if (speed>10 or speed<1) or (start_x==end_x and start_y==end_y)
        p "DE error : Speed argument out of range, or the line is a point !"
      else
      if @target!=nil
        @linebmp.draw_line(start_x, start_y, end_x, end_y,speed,@width,@color)
        #ay+bx+c
        a = (end_x - start_x).to_f
        b = -(end_y - start_y).to_f
        c = (-a * start_y - b * start_x).to_f
        @a=a
        @b=b
        @c=c
        sx = @target.pattern * @bmpw
        sy = (@target.direction - 2) / 2 * @bmph
        @sx=sx
        @sy=sy
        for i in 0..@map.pieces.size-1
          s_rect=@map.pieces[i].src_rect
        if true
        if start_x==end_x
          if s_rect.x<start_x+sx and start_x+sx<s_rect.x+s_rect.width
            @map.cloning(@map.pieces[i])
            @map.pieces[i].bitmap.fill_rect(sx+start_x, sy, @bmpw-start_x, s_rect.height, @color_b )
            @map.pieces.last.bitmap.fill_rect(sx,sy, start_x, s_rect.height, @color_b )
            @map.pieces.last.src_rect.set(start_x+sx,s_rect.y,abovezero(s_rect.x+s_rect.width-start_x-sx),s_rect.height)
            @map.pieces[i].src_rect.set(s_rect.x,s_rect.y,abovezero(start_x+sx-s_rect.x),s_rect.height)
            @map.pieces.last.x=@bmpx+start_x+@bmpw/2
            @map.pieces[i].x=@bmpx+s_rect.x-sx+@bmpw/2
          end
        else
          if start_y==end_y
            if s_rect.y<start_y+sy and start_y+sy<s_rect.y+s_rect.height
              @map.cloning(@map.pieces[i])
              @map.pieces[i].bitmap.fill_rect(sx, sy+start_y, s_rect.width, @bmph-start_y, @color_b )
              @map.pieces.last.bitmap.fill_rect(sx, sy, s_rect.width, start_y, @color_b )
              @map.pieces.last.src_rect.set(s_rect.x,sy+start_y,s_rect.width,abovezero(s_rect.y-sy-start_y+s_rect.height))
              @map.pieces[i].src_rect.set(s_rect.x,s_rect.y,s_rect.width, abovezero(start_y+sy-s_rect.y))
              @map.pieces.last.y=@bmpy+start_y+@bmph
              @map.pieces[i].y=@bmpy+s_rect.y-sy+@bmph
            end
          else
            if b/a<0
              dist1=(a*(s_rect.y+s_rect.height-sy)+ b*(s_rect.x-sx) + c)/((a**2+b**2)**0.5)
              dist2=(a*(s_rect.y-sy)+ b*(s_rect.x+s_rect.width-sx) + c)/((a**2+b**2)**0.5)
              square=(s_rect.height**2+s_rect.width**2)**0.5
              #p (b/a,-c/a,dist1,dist2,square,1)
              if dist1.abs<square and dist2.abs<square and dist1*dist2<0
                #p "slope neg"
                if -b/a*(s_rect.x-sx)-c/a<(s_rect.y-sy)
                  if -b/a*(s_rect.x-sx+s_rect.width)-c/a<(s_rect.y-sy+s_rect.height)
                    #p "above, above"
                    @map.cloning(@map.pieces[i])
                    xt=(-a/b*(s_rect.y-sy)-c/b).to_i
                    yt=(-b/a*(s_rect.x-sx+s_rect.width)-c/a).to_i
                    @map.triangle(@map.pieces.last,sx+xt,s_rect.y,s_rect.x+s_rect.width,sy+yt,s_rect.x+s_rect.width,s_rect.y,true)
                    @map.triangle(@map.pieces[i],sx+xt,s_rect.y,s_rect.x+s_rect.width,sy+yt,s_rect.x+s_rect.width,s_rect.y)
                    @map.pieces.last.x-=s_rect.x-(sx+xt)
                    @map.pieces.last.src_rect.set(sx+xt,s_rect.y,s_rect.x-sx+s_rect.width-xt,yt-(s_rect.y-sy))
                  else
                    #p "above, under"
                    @map.cloning(@map.pieces[i])
                    xt=(-a/b*(s_rect.y-sy)-c/b).to_i
                    xtp=(-a/b*(s_rect.y-sy+s_rect.height)-c/b).to_i
                    yt=(-b/a*(s_rect.x-sx)-c/a).to_i
                    ytp=(-b/a*(s_rect.x-sx+s_rect.width)-c/a).to_i
                    @map.triangle(@map.pieces.last,s_rect.x,sy+yt,s_rect.x+s_rect.width,sy+ytp,s_rect.x,sy+s_rect.height,true)
                    @map.triangle(@map.pieces[i],s_rect.x,sy+yt,s_rect.x+s_rect.width,sy+ytp,s_rect.x,sy+s_rect.height)
                    @map.pieces[i].x-=s_rect.x-(sx+xt)
                    @map.pieces.last.src_rect.set(s_rect.x,s_rect.y,xtp-(s_rect.x-sx),s_rect.height)
                    @map.pieces[i].src_rect.set(sx+xt,s_rect.y,s_rect.x-sx+s_rect.width-xt,s_rect.height)
                  end
                else
                  if -b/a*(s_rect.x-sx+s_rect.width)-c/a>(s_rect.y-sy+s_rect.height)
                    #p "under, under"
                    @map.cloning(@map.pieces[i])
                    xt=(-a/b*(s_rect.y-sy+s_rect.height)-c/b).to_i
                    yt=(-b/a*(s_rect.x-sx)-c/a).to_i
                    @map.triangle(@map.pieces.last,s_rect.x,yt+sy,s_rect.x,s_rect.y+s_rect.height,xt+sx,s_rect.y+s_rect.height,true)
                    @map.triangle(@map.pieces[i],s_rect.x,yt+sy,s_rect.x,s_rect.y+s_rect.height,xt+sx,s_rect.y+s_rect.height)
                    @map.pieces.last.src_rect.set(s_rect.x,sy+yt,xt-(s_rect.x-sx),s_rect.y-sy+s_rect.height-yt)
                    @map.pieces.last.y-=-yt-sy+s_rect.y
                  else
                    #p "under, above"
                    @map.cloning(@map.pieces[i])
                    xt=(-a/b*(s_rect.y-sy)-c/b).to_i
                    xtp=(-a/b*(s_rect.y-sy+s_rect.height)-c/b).to_i
                    yt=(-b/a*(s_rect.x-sx)-c/a).to_i
                    ytp=(-b/a*(s_rect.x-sx+s_rect.width)-c/a).to_i
                    @map.triangle(@map.pieces.last,sx+xt,s_rect.y,sx+xtp,s_rect.y+s_rect.height,sx+xtp,s_rect.y,true)
                    @map.triangle(@map.pieces[i],sx+xt,s_rect.y,sx+xtp,s_rect.y+s_rect.height,sx+xtp,s_rect.y)
                    @map.pieces.last.src_rect.set(s_rect.x,s_rect.y,s_rect.width,ytp-(s_rect.y-sy))
                    @map.pieces[i].y+=-s_rect.y+sy+yt
                    @map.pieces[i].src_rect.set(s_rect.x,sy+yt,s_rect.width,s_rect.y-sy+s_rect.height-yt)
                  end
                end
              end
            else
              dist1=(a*(s_rect.y-sy)+ b*(s_rect.x-sx) + c)/(a**2+b**2)**0.5
              dist2=(a*(s_rect.y+s_rect.height-sy)+ b*(s_rect.x+s_rect.width-sx) + c)/(a**2+b**2)**0.5
              square=(s_rect.height**2+s_rect.width**2)**0.5
              #p (-b/a,-c/a,dist1,dist2,square,2)
              if dist1.abs<square and dist2.abs<square and dist1*dist2<0
                #p "slope pos"
                if -b/a*(s_rect.x-sx)-c/a<(s_rect.y-sy+s_rect.height)
                  if -b/a*(s_rect.x-sx+s_rect.width)-c/a<(s_rect.y-sy)
                    #p "above, above"
                    @map.cloning(@map.pieces[i])
                    xt=(-a/b*(s_rect.y-sy)-c/b).to_i
                    yt=(-b/a*(s_rect.x-sx)-c/a).to_i
                    @map.triangle(@map.pieces.last,s_rect.x,yt+sy,s_rect.x,s_rect.y,xt+sx,s_rect.y,true)
                    @map.triangle(@map.pieces[i],s_rect.x,yt+sy,s_rect.x,s_rect.y,xt+sx,s_rect.y)
                    @map.pieces.last.src_rect.set(s_rect.x,s_rect.y,xt-(s_rect.x-sx),yt-(s_rect.y-sy))
                  else
                    #p "above, under"
                    @map.cloning(@map.pieces[i])
                    xt=(-a/b*(s_rect.y-sy)-c/b).to_i
                    xtp=(-a/b*(s_rect.y-sy+s_rect.height)-c/b).to_i
                    ytp=(-b/a*(s_rect.x-sx)-c/a).to_i
                    yt=(-b/a*(s_rect.x-sx+s_rect.width)-c/a).to_i
                    @map.triangle(@map.pieces.last,sx+xt,s_rect.y,sx+xtp,s_rect.y+s_rect.height,sx+xtp,s_rect.y,true)
                    @map.triangle(@map.pieces[i],sx+xt,s_rect.y,sx+xtp,s_rect.y+s_rect.height,sx+xtp,s_rect.y)
                    @map.pieces.last.src_rect.set(s_rect.x,s_rect.y,s_rect.width,ytp-(s_rect.y-sy))
                    @map.pieces[i].y+=-s_rect.y+sy+yt
                    @map.pieces[i].src_rect.set(s_rect.x,sy+yt,s_rect.width,s_rect.y-sy+s_rect.height-yt)
                  end
                else
                  if -b/a*(s_rect.x-sx+s_rect.width)-c/a>(s_rect.y-sy)
                    #p "under, under"
                    @map.cloning(@map.pieces[i])
                    xt=(-a/b*(s_rect.y-sy+s_rect.height)-c/b).to_i
                    yt=(-b/a*(s_rect.x-sx+s_rect.width)-c/a).to_i
                    @map.triangle(@map.pieces.last,s_rect.x+s_rect.width,s_rect.y+s_rect.height,s_rect.x+s_rect.width,sy+yt,sx+xt,s_rect.y+s_rect.height,true)
                    @map.triangle(@map.pieces[i],s_rect.x+s_rect.width,s_rect.y+s_rect.height,s_rect.x+s_rect.width,sy+yt,sx+xt,s_rect.y+s_rect.height)
                    @map.pieces.last.src_rect.set(s_rect.x+xt,s_rect.y+yt,s_rect.x-sx+s_rect.width-xt,s_rect.y-sy+s_rect.height-yt)
                    @map.pieces.last.y-=-yt-sy+s_rect.y
                    @map.pieces.last.x-=s_rect.x-(sx+xt)
                  else
                    #p "under, above"
                    @map.cloning(@map.pieces[i])
                    xtp=(-a/b*(s_rect.y-sy)-c/b).to_i
                    xt=(-a/b*(s_rect.y-sy+s_rect.height)-c/b).to_i
                    yt=(-b/a*(s_rect.x-sx)-c/a).to_i
                    ytp=(-b/a*(s_rect.x-sx+s_rect.width)-c/a).to_i
                    @map.triangle(@map.pieces.last,s_rect.x,sy+yt,s_rect.x+s_rect.width,sy+ytp,s_rect.x,sy+ytp,true)
                    @map.triangle(@map.pieces[i],s_rect.x,sy+yt,s_rect.x+s_rect.width,sy+ytp,s_rect.x,sy+ytp)
                    @map.pieces.last.src_rect.set(s_rect.x,s_rect.y,xtp-(s_rect.x-sx),s_rect.height)
                    @map.pieces[i].x-=s_rect.x-(sx+xt)
                    @map.pieces[i].src_rect.set(sx+xt,s_rect.y,s_rect.x-sx+s_rect.width-xt,s_rect.height)
                  end
                end
              end
            end
          end
        end
        end
        end
        @map.pieces=@map.pieces.sort{|d,e| d.src_rect.y <=> e.src_rect.y}
        Graphics.update
        return [a,b,c]
      else
        p "DE error : No target selected"
      end
      end

    end

    def testing_sort#DO NOT USE IT
      p @map.pieces.size
        for i in 0..@map.pieces.size-1
          @map.pieces[i].x=@bmpx+30*i+20
          #p (1,@map.pieces[1].x)
          #p (3,@map.pieces[3].x) if @map.pieces[3]!=nil
        end
    end

    end

    #==============================================================================
    # ■ DE_Map
    # Manage pieces creation, cloning and modification
    #==============================================================================

    class DE_Map
     
      attr_accessor :pieces
     
      def initialize(target)
        @target=target
        @pieces=Array.new
        @target.transparent=true
        $DE_spriteset.update
        @pieces[0]=DE_Piece.new($DE_viewport,@target,true)
        Graphics.update
      end
     
      def cloning(to_dup)
        @pieces.push(DE_Piece.new($DE_viewport,@target))
        @pieces.last.bitmap=to_dup.bitmap.clone
        @pieces.last.x=to_dup.x
        @pieces.last.y=to_dup.y
        @pieces.last.z=to_dup.z
        @pieces.last.src_rect.x=to_dup.src_rect.x
        @pieces.last.src_rect.y=to_dup.src_rect.y
        @pieces.last.src_rect.width=to_dup.src_rect.width
        @pieces.last.src_rect.height=to_dup.src_rect.height
      end
     
      def refresh_centre
        for to_centre in pieces
          ox=to_centre.ox
          oy=to_centre.oy
          to_centre.ox = to_centre.src_rect.width / 2
          to_centre.oy = to_centre.src_rect.height
          to_centre.x+=to_centre.ox-ox
          to_centre.y+=(to_centre.oy-oy)
        end
       
      end
     
      def collapse
        for to_collapse in pieces
          to_collapse.collapse if to_collapse.opacity!=0
        end
        for i in 1..48
          for to_collapse in pieces
            to_collapse.update
          end
          Graphics.update
        end
      end
     
      def fadeout
        for to_fadeout in pieces
          to_fadeout.escape if to_fadeout.opacity!=0
        end
        for i in 1..48
          for to_fadeout in pieces
            to_fadeout.update
          end
          Graphics.update
        end
      end

    #==============================================================================
    # ● Draw a triangle which erase either what is inside or outside
    #==============================================================================
     
      def triangle(bmp = nil, x1 = 0, y1 = 0, x2 = 0, y2 = 0, x3 = 0, y3 = 0, invert = false)
     
      if x1==x2 and y1==y2
        # Fix an error : 2 points of the triangle are equal
        triangle(bmp, x1, y1+1, x2, y2, x3, y3,invert)
        return true
      end 
      if x2==x3 and y2==y3
        # Fix an error : 2 points of the triangle are equal
        triangle(bmp, x1, y1, x2, y2+1, x3, y3,invert)
        return true
      end
      if x1==x3 and y1==y3
        # Fix an error : 2 points of the triangle are equal
        triangle(bmp, x1, y1, x2, y2, x3, y3+1,invert)
        return true
      end 
     
      if Math.atan2( y1 - y2, x1-x2) - Math.atan2( y3 - y2, x3-x2) >0
        # Fix an error : The triangle doesn't appear due to its convexity...
        triangle(bmp, x1, y1, x3, y3, x2, y2,invert)
        return true
      end
     
      color = bmp.bitmap.get_pixel(0, 0)
     
     
        #==============================================================================
        # ● Here's the rasterization algorithm (whatever this is Successful, but this one wasn't easy to find and adapt !)
        #==============================================================================
         
        # Deltas

        dx12 = x1 - x2
        dx23 = x2 - x3
        dx31 = x3 - x1

        dy12 = y1 - y2
        dy23 = y2 - y3
        dy31 = y3 - y1
       
        # Bounding Rectangle
       
        min_x = [x1,x2,x3].min
        max_x = [x1,x2,x3].max
        min_y = [y1,y2,y3].min
        max_y = [y1,y2,y3].max
       
        # Half-edge constants
       
        c1 = dy12 * x1 - dx12 * y1
        c2 = dy23 * x2 - dx23 * y2
        c3 = dy31 * x3 - dx31 * y3
       
        # Let's Calculate !

        cy1 = c1 + dx12 * min_y - dy12 * min_x
        cy2 = c2 + dx23 * min_y - dy23 * min_x
        cy3 = c3 + dx31 * min_y - dy31 * min_x

      for y_coord in min_y..max_y-1
        cx1=cy1
        cx2=cy2
        cx3=cy3
        for x_coord in min_x..max_x-1
          if (cx1 > 0 and cx3 > 0 and cx2 > 0)!=invert
            bmp.bitmap.set_pixel(x_coord, y_coord ,color)
          end
          cx1 -= dy12
          cx2 -= dy23
          cx3 -= dy31
        end
        cy1 += dx12
        cy2 += dx23
        cy3 += dx31
      end
     
      end
     
    end

    #==============================================================================
    # ■ DE_Piece
    # This is the piece cut from the original sprite
    #==============================================================================

    class DE_Piece < RPG::Sprite
     
      def initialize(viewport, character = nil,first=false)
        super(viewport)
        @character = character
        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) if !first
            self.bitmap = RPG::Cache.character(@character.character_name,@character.character_hue).clone if first
            @character.go_through if first
            @cw = bitmap.width / 4
            @ch = bitmap.height / 4
            self.ox = @cw / 2
            self.oy = @ch
           
          sx = @character.pattern * @cw
          sy = (@character.direction - 2) / 2 * @ch
          self.src_rect.set(sx, sy, @cw, @ch)
          end
        end
        @x=$game_map.display_x
        @y=$game_map.display_y
        self.x = @character.screen_x
        self.y = @character.screen_y
        self.z = @character.screen_z(bitmap.height/4)
        self.opacity = @character.opacity
        self.blend_type = @character.blend_type
        self.bush_depth = @character.bush_depth
        update
      end
      def update
        super
        self.x+=(@x-$game_map.display_x)/4
        self.y+=(@y-$game_map.display_y)/4
        @x=$game_map.display_x
        @y=$game_map.display_y
        self.z = @character.screen_z(bitmap.height/4)
      end
    end

    #==============================================================================
    # ■ Linebmp
    # Adds the ability to draw lines. Original by XRSX, adapted heavily to fit the DE
    #==============================================================================

    class Linebmp
     
      attr_accessor :bmp
     
      def initialize(x=0,y=0,z=0,w=32,h=48)
        @w=w
        @h=h
        @bmp = Sprite.new($DE_viewport)
        @bmp.x=x
        @bmp.y=y
        @bmp.z=z
        @bmp.bitmap = Bitmap.new(@w,@h)
      end
       
      def erase
        @bmp.bitmap = Bitmap.new(@w,@h)
      end
     
      def draw_line(start_x, start_y, end_x, end_y,speed,width,color=Color.new(255, 255, 255))
      count=0 
      distance = (start_x - end_x).abs + (start_y - end_y).abs
          for i in 1..distance
            x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
            y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
            if !$DE.hide_line
            if width == 1
              @bmp.bitmap.set_pixel(x, y, color)
            else
              @bmp.bitmap.fill_rect(x, y, width, width, color)
            end
            end
            count+=1
            if count>=speed
              sleep 0.01
              Graphics.update
              count=0
            end
          end
      end
    end

    #===================================================
    # ▼ CLASS Sprite_Character edit
    #===================================================

    class Sprite_Character < RPG::Sprite
      alias de_initialize initialize
     
      def initialize(viewport, character)
        #character.reappear
        if character.is_a?(Game_Player)
          $DE_viewport=viewport
        end
        de_initialize(viewport, character)
      end
     
    end

    #===================================================
    # ▼ CLASS Game_Character edit
    #===================================================

    class Game_Character
     
      alias de_Game_Character_initialize initialize

      def initialize
        de_Game_Character_initialize
        @transparentde=@transparent
        @throughde=@through
      end
     
      alias de_Game_Character_update update
     
      def go_through
        @through=true
      end
     
      def reappear
        @transparent=@transparentde
        @through=@throughde
      end
     
      def dont_go_through
        @through=false
      end
     
    end

    #===================================================
    # ▼ CLASS Spriteset_Map edit
    #===================================================

    class Spriteset_Map
     
    alias de_spriteset_update update
    alias de_spriteset_initialize initialize

      def initialize
        $DE = DE.new
        de_spriteset_initialize
        $DE_spriteset = self
      end

      def update
      $DE.update if $DE.is_a?(Destruction_Engine)
      de_spriteset_update
      end
    end
    .:INSTRUÇÕES:.

    Cole acima do main.

    Para ativar o script, use o comando chamar script num evento e use a sintaxe:
    Código:
    $DE.init

    $DE.target_is_in_front_of_me

    <Comando>

    $DE.clear
    Onde em , você escolhe como quer que o evento seja destruido.

    Mais funções de destruição e os comandos contidos no script e na demo.
    .:SCREENSHOTS:.

    Engine de destruição 111

    Engine de destruição 222_3

    Créditos:
    Rataime Por Postar No santuario Rpg Maker
    MalucaoBeleza
    MalucaoBeleza
    Desenvolvedor
    Desenvolvedor

    Medalhas : Engine de destruição ILtUbYveyXDIf
    Mensagens : 723
    Créditos : 58

    Engine de destruição Empty Re: Engine de destruição

    Mensagem por MalucaoBeleza Ter Jun 12, 2012 10:31 pm

    kk
    legal cara talvez eu utilize
    +Cred

    kk achei engraçado o char se repartindo
    muito legal msm
    avatar
    samuel6406
    Banido
    Banido

    Mensagens : 49
    Créditos : 11

    Engine de destruição Empty Re: Engine de destruição

    Mensagem por samuel6406 Ter Jun 12, 2012 10:48 pm

    kkkk' eu também achei emgraçado, vlw pelo cred Irmão Very Happy
    Daniel Carvalho
    Daniel Carvalho
    Ocasional
    Ocasional

    Mensagens : 231
    Créditos : 19

    Ficha do personagem
    Nível: 1
    Experiência:
    Engine de destruição Left_bar_bleue0/50Engine de destruição Empty_bar_bleue  (0/50)
    Vida:
    Engine de destruição Left_bar_bleue30/30Engine de destruição Empty_bar_bleue  (30/30)

    Engine de destruição Empty Re: Engine de destruição

    Mensagem por Daniel Carvalho Ter Jun 12, 2012 11:13 pm

    kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk legal Very Happy +1 cred
    ele funfa em netplays?
    RD12
    RD12
    Lenda
    Lenda

    Medalhas : Engine de destruição 48080450Engine de destruição Trophy11Engine de destruição GIueZEngine de destruição ZgLkiRU
    Mensagens : 1946
    Créditos : 745

    Engine de destruição Empty Re: Engine de destruição

    Mensagem por RD12 Qua Jun 13, 2012 10:17 am

    Bem legal mesmo kk. +1 Créd, ótimo script.
    avatar
    samuel6406
    Banido
    Banido

    Mensagens : 49
    Créditos : 11

    Engine de destruição Empty Re: Engine de destruição

    Mensagem por samuel6406 Qua Jun 13, 2012 12:53 pm

    @Daniel Carvalho escreveu:kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk legal Very Happy +1 cred
    ele funfa em netplays?

    Vou testar hoje aqui no Netplay v3 se funfar eu digo aqui ok? vlw pelo cred
    @edit
    car aqui nao funfou no netplay mais vou tentar adaptalo (:
    KnowVFX
    KnowVFX
    Semi-Experiente
    Semi-Experiente

    Mensagens : 140
    Créditos : 3

    Engine de destruição Empty Re: Engine de destruição

    Mensagem por KnowVFX Sex Jun 22, 2012 11:49 am

    = ) Deviam fechar o topico
    1° Usuario banido
    2 nem vai poder responder mais

    Conteúdo patrocinado

    Engine de destruição Empty Re: Engine de destruição

    Mensagem por Conteúdo patrocinado


      Data/hora atual: Seg Out 25, 2021 2:52 pm