Custom Animation Move (Elite Battle System)

[DarrylBD99]

Oh hi, Luka!
BTW, I have got some confusion recently. Are you back in essentials or no? (p.s. I didn't mean to force you to come back as you are an amazing scripter and you deserved the break)

No.

So, does anyone know whether it is still being worked on?

 

[Marin]

So, does anyone know whether it is still being worked on?

It is being worked on, and will come out soon. But it's not been released just yet.

 

[HaloRoute]

WolfPP, I can't find Water Shuriken, Photon Geyser in moves.txt. Where can I find that move?

 

[Golisopod User]

WolfPP, I can't find Water Shuriken, Photon Geyser in moves.txt. Where can I find that move?

Your'e gonna have to add it yourself.

Look for any Gen 6 Resource Pack for Essentials v17.2 on Google and you can find the PBS Data and add it yourself.

Also if you need any other help.

 

[HaloRoute]

Hi guys!
I'll create new animations FOR THE EBS - ELITE BATTLE SYSTEM (by Luka S.J.).

You just need to paste the script into 'MoveAnimations Script', under 'def pbAnimation (moveid, user, target, hitnum = 0)' between last 'end' and bug bite script Like this:

 end
PASTE HERE
  #-----------------------------------------------------------------------------
  #  Bug Bite
  #-----------------------------------------------------------------------------

If you have custom animations and you want to share with us, feel free (and we would even appreciate it).

Dive (move 541)

Spoiler:

#-----------------------------------------------------------------------------
  #  Dive
  #-----------------------------------------------------------------------------
  def pbMoveAnimationSpecific541(userindex,targetindex,hitnum=0,multihit=false)
    if hitnum == 1
      return moveAnimationDiveDown(userindex,targetindex)
    elsif hitnum == 0
      return moveAnimationDiveUp(userindex,targetindex)
    end
  end
   def moveAnimationDiveDown(userindex,targetindex)
    # inital configuration
    usersprite = @sprites["pokemon#{userindex}"]
    targetsprite = @sprites["pokemon#{targetindex}"]
    player = (userindex%2==0)
    defaultvector = @battle.doublebattle ? VECTOR2 : VECTOR1
    vector = getRealVector(userindex,player)
    factor = player ? 2 : 1.5
    # set up animation
    fp = {}
    randx = []
    randy = []
    speed = []
    angle = []
    for m in 0...4
      randx.push([]); randy.push([]); speed.push([]); angle.push([])
        targetsprite = @sprites["pokemon#{m}"]
        next if !usersprite || usersprite.disposed? || usersprite.fainted || !usersprite.visible
      next if m == userindex
      for j in 0...32
        fp["#{j}#{m}"] = Sprite.new(usersprite.viewport)
        fp["#{j}#{m}"].bitmap = pbBitmap("Graphics/Animations/eb541")
        fp["#{j}#{m}"].ox = fp["#{j}#{m}"].bitmap.width/2
        fp["#{j}#{m}"].oy = fp["#{j}#{m}"].bitmap.height/2
        fp["#{j}#{m}"].z = 50
        z = [0.5,0.4,0.3,0.7][rand(4)]
        fp["#{j}#{m}"].zoom_x = z
        fp["#{j}#{m}"].zoom_y = z
        fp["#{j}#{m}"].visible = false
        randx[m].push(rand(82)+(rand(2)==0 ? 82 : 0))
        randy[m].push(rand(32)+32)
        speed[m].push(4)
        angle[m].push((rand(8)+1)*(rand(2)==0 ? -1 : 1))
      end
    end
    # start animation
    @vector.set(vector)
    wait(20,true)
    factor = usersprite.zoom_x
    k = -1
#
    pbSEPlay("#{SE_EXTRA_PATH}Water1")
    for i in 0...92
      for m in 0...4
      targetsprite = @sprites["pokemon#{m}"]
      next if !usersprite || usersprite.disposed? || usersprite.fainted || !usersprite.visible
        next if m == userindex
        cx, cy = getCenter(usersprite,true)
        for j in 0...32
          next if j>(i/2)
          if !fp["#{j}#{m}"].visible
            fp["#{j}#{m}"].visible = true
            fp["#{j}#{m}"].x = cx - 82*usersprite.zoom_x + randx[m][j]*usersprite.zoom_x
            fp["#{j}#{m}"].y = usersprite.y
            fp["#{j}#{m}"].zoom_x *= usersprite.zoom_x
            fp["#{j}#{m}"].zoom_y *= usersprite.zoom_y
          end
          fp["#{j}#{m}"].y -= speed[m][j]*2*usersprite.zoom_y
          speed[m][j] *= -1 if (fp["#{j}#{m}"].y <= usersprite.y - randy[m][j]*usersprite.zoom_y) || (fp["#{j}#{m}"].y >= usersprite.y)
          fp["#{j}#{m}"].opacity -= 35 if speed[m][j] < 0
          fp["#{j}#{m}"].angle += angle[m][j]
        end
      end
      usersprite.zoom_x -= 0.2/6 if usersprite.zoom_x > factor
      usersprite.zoom_y += 0.2/6 if usersprite.zoom_y < factor
      
      k *= -1 if i%3==0
      if i%32==0
        pbSEPlay("#{SE_EXTRA_PATH}Water2",60)
        usersprite.zoom_x = factor*1.2
        usersprite.zoom_y = factor*0.8
      end
      wait(1,false)
    end
    usersprite.visible = false
    usersprite.hidden = true
    pbDisposeSpriteHash(fp)
    @vector.set(defaultvector)
    wait(20,true)
    return true
  end
  
  def moveAnimationDiveUp(userindex,targetindex)
    # inital configuration
    usersprite = @sprites["pokemon#{userindex}"]
    targetsprite = @sprites["pokemon#{targetindex}"]
    player = (targetindex%2==0)
    itself = (userindex==targetindex)
    defaultvector = @battle.doublebattle ? VECTOR2 : VECTOR1
    vector = getRealVector(targetindex,player)
    factor = targetsprite.zoom_x
    #factor = player ? 2 : 1.5
    @vector.set(getRealVector(targetindex,player))
    wait(16,true)
    # set up animation
    fp = {}
    rndx = []
    rndy = []
    for i in 0...16
      fp["#{i}"] = Sprite.new(targetsprite.viewport)
      fp["#{i}"].bitmap = pbBitmap("Graphics/Animations/eb541_2")
      fp["#{i}"].ox = 6
      fp["#{i}"].oy = 6
      fp["#{i}"].opacity = 0
      fp["#{i}"].z = 50
      r = rand(3)
      fp["#{i}"].zoom_x = (targetsprite.zoom_x)*(r==0 ? 1 : 0.5)
      fp["#{i}"].zoom_y = (targetsprite.zoom_y)*(r==0 ? 1 : 0.5)
      fp["#{i}"].tone = Tone.new(60,60,60)
      rndx.push(rand(128))
      rndy.push(rand(128))
    end
    factor = 1
    frame = Sprite.new(targetsprite.viewport)
    frame.z = 50
    frame.bitmap = pbBitmap("Graphics/Animations/eb520")
    frame.src_rect.set(0,0,114,114)
    frame.ox = 57
    frame.oy = 57
    frame.zoom_x = 0.5*factor
    frame.zoom_y = 0.5*factor
    frame.x, frame.y = getCenter(targetsprite,true)
    frame.opacity = 0
    frame.tone = Tone.new(255,255,255)
    # start animation
    for i in 1..30
      if i == 6
        pbSEPlay("#{SE_EXTRA_PATH}Water3",90)
        pbSEPlay("#{SE_EXTRA_PATH}Water3",80)
      end
      if i.between?(1,5)
        targetsprite.still
        targetsprite.zoom_y-=0.05*factor
        targetsprite.toneAll(-12.8)
        frame.zoom_x += 0.1*factor
        frame.zoom_y += 0.1*factor
        frame.opacity += 51
      end
      frame.tone = Tone.new(0,0,0) if i == 6
      if i.between?(6,10)
        targetsprite.still
        targetsprite.zoom_y+=0.05*factor
        targetsprite.toneAll(+12.8)
        frame.angle += 2
      end
      frame.src_rect.x = 114 if i == 10
      if i >= 10
        frame.opacity -= 25.5
        frame.zoom_x += 0.1*factor
        frame.zoom_y += 0.1*factor
        frame.angle += 2
      end
      for j in 0...16
        next if i < 6
        cx = frame.x; cy = frame.y
        if fp["#{j}"].opacity == 0 && fp["#{j}"].visible
          fp["#{j}"].x = cx
          fp["#{j}"].y = cy
        end
        x2 = cx - 64*targetsprite.zoom_x + rndx[j]*targetsprite.zoom_x
        y2 = cy - 64*targetsprite.zoom_y + rndy[j]*targetsprite.zoom_y
        x0 = fp["#{j}"].x
        y0 = fp["#{j}"].y
        fp["#{j}"].x += (x2 - x0)*0.2
        fp["#{j}"].y += (y2 - y0)*0.2
        fp["#{j}"].zoom_x += 0.01
        fp["#{j}"].zoom_y += 0.01
        fp["#{j}"].angle += 2
        if i < 20
          fp["#{j}"].tone.red -= 6; fp["#{j}"].tone.blue -= 6; fp["#{j}"].tone.green -= 6
        end
        if (x2 - x0)*0.2 < 1 && (y2 - y0)*0.2 < 1
          fp["#{j}"].opacity -= 51
        else
          fp["#{j}"].opacity += 51
        end
        fp["#{j}"].visible = false if fp["#{j}"].opacity <= 0
      end
      wait(1)
    end
    usersprite.hidden = false
    usersprite.visible = true
    frame.dispose
    pbDisposeSpriteHash(fp)
    @vector.set(defaultvector)
    return true
  end

Download the attachment (eb541, eb541_2)
Hope anyone continue to post!

 

[HaloRoute]

Another post

Hi guys!
I'll create new animations FOR THE EBS - ELITE BATTLE SYSTEM (by Luka S.J.).

You just need to paste the script into 'MoveAnimations Script', under 'def pbAnimation (moveid, user, target, hitnum = 0)' between last 'end' and bug bite script like this:

 end
PASTE HERE
  #-----------------------------------------------------------------------------
  #  Bug Bite
  #-----------------------------------------------------------------------------

If you have custom animations and you want to share with us, feel free (and we would even appreciate it).

Water Pulse (move 548)

Spoiler:

#-----------------------------------------------------------------------------
  #  Water Pulse
  #-----------------------------------------------------------------------------
  def pbMoveAnimationSpecific548(userindex,targetindex,hitnum=0,multihit=false)
    # inital configuration
    usersprite = @sprites["pokemon#{userindex}"]
    targetsprite = @sprites["pokemon#{targetindex}"]
    player = (targetindex%2==0)
    player2 = (userindex%2==0)
    defaultvector = @battle.doublebattle ? VECTOR2 : VECTOR1
    vector = getRealVector(targetindex,player)
    vector2 = getRealVector(userindex,player2)
    # set up animation
    fp = {}
    rndx = []; prndx = []
    rndy = []; prndy = []
    rangl = []
    dx = []
    dy = []
    fp["bg"] = ScrollingSprite.new(targetsprite.viewport)
    fp["bg"].speed = 64
    fp["bg"].setBitmap("Graphics/Animations/eb086_bg")
    fp["bg"].color = Color.new(0,0,0,255)
    fp["bg"].opacity = 0
    
    fp["cir"] = Sprite.new(targetsprite.viewport)
    fp["cir"].bitmap = pbBitmap("Graphics/Animations/eb093")
    fp["cir"].ox = fp["cir"].bitmap.width/2
    fp["cir"].oy = fp["cir"].bitmap.height/2
    fp["cir"].z = usersprite.z + 1
    fp["cir"].mirror = player2
    fp["cir"].zoom_x = (player ? 0.75 : 1)
    fp["cir"].zoom_y = (player ? 0.75 : 1)
    fp["cir"].opacity = 0
    
    shake = 4
    k = 0
    # start animation
    for i in 0...40
      if i < 8
        fp["bg"].opacity += 32
      else
        fp["bg"].color.alpha -= 32
        fp["cir"].x, fp["cir"].y = getCenter(usersprite)
        fp["cir"].angle += 24*(player2 ? -1 : 1)
        fp["cir"].opacity += 24
      end
      if i == 8 
        @vector.set(vector2)
        pbSEPlay("#{SE_EXTRA_PATH}Wind8")
      end
      fp["bg"].update
      wait(1,true)
    end
    cx, cy = getCenter(usersprite,true)
    dx = []
    dy = []
    for i in 0...8
      fp["#{i}s"] = Sprite.new(targetsprite.viewport)
      fp["#{i}s"].bitmap = pbBitmap("Graphics/Animations/eb093_2")
      fp["#{i}s"].src_rect.set(rand(3)*36,0,36,36)
      fp["#{i}s"].ox = fp["#{i}s"].src_rect.width/2
      fp["#{i}s"].oy = fp["#{i}s"].src_rect.height/2
      r = 128*usersprite.zoom_x
      z = [0.5,0.25,1,0.75][rand(4)]
      x, y = randCircleCord(r)
      x = cx - r + x
      y = cy - r + y
      fp["#{i}s"].x = cx
      fp["#{i}s"].y = cy
      fp["#{i}s"].zoom_x = z*usersprite.zoom_x
      fp["#{i}s"].zoom_y = z*usersprite.zoom_x
      fp["#{i}s"].visible = false
      fp["#{i}s"].z = usersprite.z + 1
      dx.push(x)
      dy.push(y)
    end
    
    fp["shot"] = Sprite.new(targetsprite.viewport)
    fp["shot"].bitmap = pbBitmap("Graphics/Animations/eb093_3")
    fp["shot"].ox = fp["shot"].bitmap.width/2
    fp["shot"].oy = fp["shot"].bitmap.height/2
    fp["shot"].z = usersprite.z + 1
    fp["shot"].zoom_x = usersprite.zoom_x
    fp["shot"].zoom_y = usersprite.zoom_x
    fp["shot"].opacity = 0
    
    x = defaultvector[0]; y = defaultvector[1]
    x2, y2 = @vector.spoof(defaultvector)
    fp["shot"].x = cx
    fp["shot"].y = cy
    pbSEPlay("#{SE_EXTRA_PATH}Water5")
    k = -1
    for i in 0...20
      cx, cy = getCenter(usersprite)
      @vector.set(defaultvector) if i == 0
      if i > 0
        fp["shot"].angle = Math.atan(1.0*(@[email protected])/(@[email protected]))*(180.0/Math::PI) + (player ? 180 : 0)
        fp["shot"].opacity += 32
        fp["shot"].zoom_x -= (fp["shot"].zoom_x - targetsprite.zoom_x)*0.1
        fp["shot"].zoom_y -= (fp["shot"].zoom_y - targetsprite.zoom_y)*0.1
        fp["shot"].x += (player ? -1 : 1)*(x2 - x)/24
        fp["shot"].y -= (player ? -1 : 1)*(y - y2)/24
        for j in 0...8
          fp["#{j}s"].visible = true
          fp["#{j}s"].opacity -= 32
          fp["#{j}s"].x -= (fp["#{j}s"].x - dx[j])*0.2
          fp["#{j}s"].y -= (fp["#{j}s"].y - dy[j])*0.2
        end
        fp["cir"].angle += 24*(player2 ? -1 : 1)
        fp["cir"].opacity -= 16
        fp["cir"].x = cx
        fp["cir"].y = cy
      end
      fp["bg"].update
      factor = targetsprite.zoom_x if i == 12
      if i >= 12
        k *= -1 if i%4==0
        targetsprite.zoom_x -= factor*0.01*k
        targetsprite.zoom_y += factor*0.04*k
        targetsprite.still
      end
      cx, cy = getCenter(targetsprite,true)
      if !player
        fp["shot"].z = targetsprite.z - 1 if fp["shot"].x > cx && fp["shot"].y < cy
      else
        fp["shot"].z = targetsprite.z + 1 if fp["shot"].x < cx && fp["shot"].y > cy
      end
      wait(1,i < 12)
    end
    shake = 2
    16.times do
      fp["shot"].angle = Math.atan(1.0*(@[email protected])/(@[email protected]))*(180.0/Math::PI) + (player ? 180 : 0)
      fp["shot"].opacity += 32
      fp["shot"].zoom_x -= (fp["shot"].zoom_x - targetsprite.zoom_x)*0.1
      fp["shot"].zoom_y -= (fp["shot"].zoom_y - targetsprite.zoom_y)*0.1
      fp["shot"].x += (player ? -1 : 1)*(x2 - x)/24
      fp["shot"].y -= (player ? -1 : 1)*(y - y2)/24
      fp["bg"].color.alpha += 16
      fp["bg"].update
      targetsprite.addOx(shake)
      shake = -2 if targetsprite.ox > targetsprite.bitmap.width/2 + 4
      shake = 2 if targetsprite.ox < targetsprite.bitmap.width/2 - 4
      targetsprite.still
      cx, cy = getCenter(targetsprite,true)
      if !player
        fp["shot"].z = targetsprite.z - 1 if fp["shot"].x > cx && fp["shot"].y < cy
      else
        fp["shot"].z = targetsprite.z + 1 if fp["shot"].x < cx && fp["shot"].y > cy
      end
      wait(1,true)
    end
    targetsprite.ox = targetsprite.bitmap.width/2
    16.times do
      targetsprite.still
      wait(1,true)
    end
    16.times do
      fp["bg"].opacity -= 16
      wait(1,true)
    end
    pbDisposeSpriteHash(fp)
    return true
  end