the “long awaited” artillery code is now out!

This mod adds a fully working 2A65 Msta-B artillery system with manual firing, automatic targeting, recoil, reload animations, shell loading, blast damage, knockback, and terrain destruction “!artillery” gives you the normal artillery. Place it down facing the direction you want it to fire. Use “!fire” to fire the cannon with muzzle flash, sound, recoil, recoil displacement, and reload animation without creating any real damage. Use “!fire X Y Z” or “!fire at X, Y, Z” to fire a real artillery round at those coordinates Automatic artillery can detect targets from up to 3000 blocks away, rotate toward them, adjust barrel elevation, fire automatically, reload, and continue tracking “!Auto Artillery Player” targets players only “!Auto Artillery Mob” targets mobs only “!Auto Artillery All” or “!Auto Artillery” targets both players and mobs “!Auto Artillery Player Training” targets players but causes no health damage, knockback, or terrain destruction. “!Auto Artillery Player NP” also works for this mode Switching to a different artillery mode automatically replaces your old artillery slabs with the new type There’s also a “!help” command that explains how to use everything sorry for no videos cant put vids and photos in 1 post but trust me it works quite well also i just figured out how to compress code its blown my mind 5000 line code to 500 ;-; anyways enjoy! ITS ALL IN WORLD CODE PASTE IT IN WORLD CODE AND DO !HELP

you can find it here (PASTE IT IN WORLD CODE!!!)

https://bloxdhub.com/workshop/working-artillery-2a65-msta-b-artillery-m4691

ill add it too bloxdium soon as well!

These are SUPER useful if your base is getting raided! You can place them in sneaky spots where enemies won’t notice them, making them perfect for traps and defending your base.

Just type “!claymore” in chat to receive 50 Claymores and start placing them!

The Claymores are fully modeled, including the red indicator lights. :D

All of the Claymore code is in the WORLD CODE!!! so everything you need is already there. no code blocks needed

Hope you enjoy it! and remember type “!claymore” in chat to get 50 claymores!!

also they do not explode if you are in creative or spectator!

also i am _Balance_HT3 my other device was blown up D:

Paste this in WORLD CODE!!!

// created by _Balance_HT3

let claymores = []
let claymoreHeldCache = {}
let claymoreDetonationQueue = []

let nextClaymoreId = 1

let claymoreRange = 1.5
let claymoreHalfAngle = Math.PI * 28 / 180
let claymoreBeepDelayTicks = 6

tick = () =&gt; {
  try {
    updateClaymoreHeldCache()
    detectClaymoreTargets()
    processClaymoreDetonations()
  } catch {}
}

onPlayerChat = (playerId, message) =&gt; {
  try {
    if (
      message.toLowerCase().trim() !==
      "!claymore"
    ) {
      return
    }

    let added = api.giveItem(
      playerId,
      "Green Concrete Slab",
      50,
      {
        customDisplayName: "Claymore",
        customDescription:
          "Directional proximity mine | Range: 1.5 blocks",
        customAttributes: {
          isClaymore: true
        }
      }
    )

    api.sendMessage(
      playerId,
      "Claymores received: " + added,
      { color: "green" }
    )

    return false
  } catch {
    return false
  }
}

onPlayerSelectInventorySlot = (
  playerId,
  slotIndex
) =&gt; {
  try {
    let item =
      api.getItemSlot(
        playerId,
        slotIndex
      )

    claymoreHeldCache[playerId] = {
      isClaymore:
        isClaymoreItem(item),
      time:
        api.now()
    }
  } catch {}
}

onPlayerChangeBlock = (
  playerId,
  x,
  y,
  z,
  fromBlock,
  toBlock
) =&gt; {
  try {
    if (
      fromBlock !== "Air" ||
      toBlock !== "Green Concrete Slab"
    ) {
      return
    }

    let held = null

    try {
      held =
        api.getHeldItem(
          playerId
        )
    } catch {}

    let isClaymore =
      isClaymoreItem(held)

    if (!isClaymore) {
      let cached =
        claymoreHeldCache[playerId]

      if (
        cached &amp;&amp;
        cached.isClaymore &amp;&amp;
        api.now() - cached.time &lt; 500
      ) {
        isClaymore = true
      }
    }

    if (!isClaymore) return

    let facing = null

    try {
      facing =
        api.getPlayerFacingInfo(
          playerId
        )
    } catch {}

    let fx = 0
    let fz = 1

    if (
      facing &amp;&amp;
      facing.dir
    ) {
      fx = facing.dir[0]
      fz = facing.dir[2]
    }

    let horizontalLength =
      Math.sqrt(
        fx * fx +
        fz * fz
      )

    if (
      horizontalLength &lt;
      0.05
    ) {
      let playerPos =
        api.getPosition(
          playerId
        )

      fx =
        x + 0.5 -
        playerPos[0]

      fz =
        z + 0.5 -
        playerPos[2]

      horizontalLength =
        Math.sqrt(
          fx * fx +
          fz * fz
        )
    }

    if (
      horizontalLength &lt;
      0.05
    ) {
      fx = 0
      fz = 1
      horizontalLength = 1
    }

    fx /= horizontalLength
    fz /= horizontalLength

    let mine =
      createClaymore(
        playerId,
        x,
        y,
        z,
        fx,
        fz
      )

    if (!mine) {
      try {
        api.setBlock(
          x,
          y,
          z,
          "Air"
        )

        api.giveItem(
          playerId,
          "Green Concrete Slab",
          1,
          {
            customDisplayName:
              "Claymore",
            customDescription:
              "Directional proximity mine | Range: 1.5 blocks",
            customAttributes: {
              isClaymore: true
            }
          }
        )
      } catch {}

      return
    }

    api.setBlock(
      x,
      y,
      z,
      "Air"
    )

    claymores.push(mine)

    claymoreHeldCache[playerId] = {
      isClaymore: true,
      time: api.now()
    }
  } catch {}
}

function isClaymoreItem(item) {
  if (!item) return false

  if (
    item.name !==
    "Green Concrete Slab"
  ) {
    return false
  }

  let attributes =
    item.attributes

  if (!attributes) {
    return false
  }

  if (
    attributes.customDisplayName ===
    "Claymore"
  ) {
    return true
  }

  if (
    attributes.customAttributes &amp;&amp;
    attributes.customAttributes.isClaymore === true
  ) {
    return true
  }

  return false
}

function updateClaymoreHeldCache() {
  let players =
    api.getPlayerIds()

  for (
    let playerId of players
  ) {
    try {
      let held =
        api.getHeldItem(
          playerId
        )

      if (
        isClaymoreItem(
          held
        )
      ) {
        claymoreHeldCache[playerId] = {
          isClaymore: true,
          time: api.now()
        }
      }
    } catch {}
  }
}

function createClaymore(
  ownerId,
  blockX,
  blockY,
  blockZ,
  fx,
  fz
) {
  let mineId =
    nextClaymoreId++

  let meshIds = []

  let center = [
    blockX + 0.5,
    blockY,
    blockZ + 0.5
  ]

  let rx = fz
  let rz = -fx

  let yaw =
    Math.atan2(
      fx,
      fz
    )

  let mine = {
    id: mineId,

    ownerId:
      ownerId,

    pos: [
      center[0],
      blockY,
      center[2]
    ],

    forward: [
      fx,
      fz
    ],

    right: [
      rx,
      rz
    ],

    meshIds:
      meshIds,

    active:
      true,

    triggered:
      false
  }

  let mainBody =
    createClaymorePart(
      mine,
      {
        width: 0.82,
        height: 0.42,
        depth: 0.15,
        diffuseColor:
          [48, 70, 32]
      },
      0,
      0.52,
      0,
      yaw
    )

  if (!mainBody) {
    cleanupFailedClaymore(mine)
    return null
  }

  let frontPlate =
    createClaymorePart(
      mine,
      {
        width: 0.70,
        height: 0.30,
        depth: 0.035,
        diffuseColor:
          [68, 91, 45]
      },
      0,
      0.52,
      0.093,
      yaw
    )

  if (!frontPlate) {
    cleanupFailedClaymore(mine)
    return null
  }

  let topRidge =
    createClaymorePart(
      mine,
      {
        width: 0.58,
        height: 0.07,
        depth: 0.14,
        diffuseColor:
          [35, 52, 26]
      },
      0,
      0.755,
      -0.01,
      yaw
    )

  if (!topRidge) {
    cleanupFailedClaymore(mine)
    return null
  }

  let leftCap =
    createClaymorePart(
      mine,
      {
        width: 0.07,
        height: 0.35,
        depth: 0.18,
        diffuseColor:
          [30, 46, 23]
      },
      -0.43,
      0.51,
      0,
      yaw
    )

  if (!leftCap) {
    cleanupFailedClaymore(mine)
    return null
  }

  let rightCap =
    createClaymorePart(
      mine,
      {
        width: 0.07,
        height: 0.35,
        depth: 0.18,
        diffuseColor:
          [30, 46, 23]
      },
      0.43,
      0.51,
      0,
      yaw
    )

  if (!rightCap) {
    cleanupFailedClaymore(mine)
    return null
  }

  let leftLeg =
    createClaymorePart(
      mine,
      {
        width: 0.045,
        height: 0.38,
        depth: 0.045,
        diffuseColor:
          [45, 55, 35]
      },
      -0.27,
      0.18,
      -0.01,
      yaw
    )

  if (!leftLeg) {
    cleanupFailedClaymore(mine)
    return null
  }

  let rightLeg =
    createClaymorePart(
      mine,
      {
        width: 0.045,
        height: 0.38,
        depth: 0.045,
        diffuseColor:
          [45, 55, 35]
      },
      0.27,
      0.18,
      -0.01,
      yaw
    )

  if (!rightLeg) {
    cleanupFailedClaymore(mine)
    return null
  }

  let leftBeam =
    createClaymoreBeam(
      mine,
      -claymoreHalfAngle
    )

  if (!leftBeam) {
    cleanupFailedClaymore(mine)
    return null
  }

  let rightBeam =
    createClaymoreBeam(
      mine,
      claymoreHalfAngle
    )

  if (!rightBeam) {
    cleanupFailedClaymore(mine)
    return null
  }

  return mine
}

function createClaymorePart(
  mine,
  options,
  localX,
  localY,
  localZ,
  yaw
) {
  let entityId = null

  try {
    entityId =
      api.attemptCreateMeshEntity(
        "Box",
        options,
        ""
      )
  } catch {}

  if (!entityId) {
    return null
  }

  let world =
    claymoreLocalToWorld(
      mine,
      localX,
      localY,
      localZ
    )

  try {
    api.setPosition(
      entityId,
      world[0],
      world[1],
      world[2]
    )

    api.setEntityRotation(
      entityId,
      0,
      yaw,
      0
    )
  } catch {
    try {
      api.deleteMeshEntity(
        entityId
      )
    } catch {}

    return null
  }

  mine.meshIds.push(
    entityId
  )

  return entityId
}

function createClaymoreBeam(
  mine,
  angleOffset
) {
  let fx =
    mine.forward[0]

  let fz =
    mine.forward[1]

  let cosA =
    Math.cos(
      angleOffset
    )

  let sinA =
    Math.sin(
      angleOffset
    )

  let beamX =
    fx * cosA -
    fz * sinA

  let beamZ =
    fx * sinA +
    fz * cosA

  let beamLength =
    claymoreRange - 0.12

  let startDistance =
    0.12

  let middleDistance =
    startDistance +
    beamLength / 2

  let entityId = null

  try {
    entityId =
      api.attemptCreateMeshEntity(
        "Box",
        {
          width: 0.022,
          height: 0.022,
          depth: beamLength,

          diffuseColor:
            [255, 0, 0],

          emissiveColor:
            [255, 0, 0],

          backFaceCulling:
            false
        },
        ""
      )
  } catch {}

  if (!entityId) {
    return null
  }

  let beamY =
    mine.pos[1] +
    0.53

  try {
    api.setPosition(
      entityId,

      mine.pos[0] +
        beamX *
          middleDistance,

      beamY,

      mine.pos[2] +
        beamZ *
          middleDistance
    )

    api.setEntityRotation(
      entityId,
      0,
      Math.atan2(
        beamX,
        beamZ
      ),
      0
    )
  } catch {
    try {
      api.deleteMeshEntity(
        entityId
      )
    } catch {}

    return null
  }

  mine.meshIds.push(
    entityId
  )

  return entityId
}

function claymoreLocalToWorld(
  mine,
  localX,
  localY,
  localZ
) {
  return [
    mine.pos[0] +
      mine.right[0] *
        localX +
      mine.forward[0] *
        localZ,

    mine.pos[1] +
      localY,

    mine.pos[2] +
      mine.right[1] *
        localX +
      mine.forward[1] *
        localZ
  ]
}

function playerIsIgnoredByClaymore(
  playerId
) {
  try {
    if (
      api.getClientOption(
        playerId,
        "creative"
      ) === true
    ) {
      return true
    }
  } catch {}

  try {
    if (
      api.getClientOption(
        playerId,
        "invincible"
      ) === true
    ) {
      return true
    }
  } catch {}

  try {
    if (
      api.getClientOption(
        playerId,
        "initialHealth"
      ) === null
    ) {
      return true
    }
  } catch {}

  return false
}

function detectClaymoreTargets() {
  if (
    claymores.length === 0
  ) {
    return
  }

  let players =
    api.getPlayerIds()

  for (
    let mineIndex =
      claymores.length - 1;
    mineIndex &gt;= 0;
    mineIndex--
  ) {
    let mine =
      claymores[
        mineIndex
      ]

    if (
      !mine.active ||
      mine.triggered
    ) {
      continue
    }

    for (
      let playerId of players
    ) {
      if (
        playerIsIgnoredByClaymore(
          playerId
        )
      ) {
        continue
      }

      let playerPos = null

      try {
        playerPos =
          api.getPosition(
            playerId
          )
      } catch {}

      if (!playerPos) {
        continue
      }

      if (
        playerPos[1] &lt;
          mine.pos[1] -
            0.5 ||
        playerPos[1] &gt;
          mine.pos[1] +
            2.2
      ) {
        continue
      }

      let dx =
        playerPos[0] -
        mine.pos[0]

      let dz =
        playerPos[2] -
        mine.pos[2]

      let horizontalDistance =
        Math.sqrt(
          dx * dx +
          dz * dz
        )

      if (
        horizontalDistance &gt;
          claymoreRange ||
        horizontalDistance &lt;
          0.05
      ) {
        continue
      }

      let forwardDistance =
        dx *
          mine.forward[0] +
        dz *
          mine.forward[1]

      if (
        forwardDistance &lt;= 0
      ) {
        continue
      }

      let lateralDistance =
        Math.abs(
          dx *
            mine.right[0] +
          dz *
            mine.right[1]
        )

      let allowedLateral =
        Math.tan(
          claymoreHalfAngle
        ) *
        forwardDistance

      if (
        lateralDistance &gt;
          allowedLateral +
            0.12
      ) {
        continue
      }

      armClaymoreDetonation(
        mine,
        playerId
      )

      break
    }
  }
}

function armClaymoreDetonation(
  mine,
  targetPlayerId
) {
  if (
    !mine.active ||
    mine.triggered
  ) {
    return
  }

  mine.triggered = true

  try {
    api.broadcastSound(
      "beep",
      1,
      2,
      {
        playerIdOrPos:
          mine.pos
      }
    )
  } catch {}

  claymoreDetonationQueue.push({
    mineId:
      mine.id,

    targetPlayerId:
      targetPlayerId,

    ticks:
      claymoreBeepDelayTicks
  })
}

function processClaymoreDetonations() {
  for (
    let i =
      claymoreDetonationQueue.length - 1;
    i &gt;= 0;
    i--
  ) {
    let detonation =
      claymoreDetonationQueue[i]

    detonation.ticks--

    if (
      detonation.ticks &gt; 0
    ) {
      continue
    }

    let mine =
      getClaymoreById(
        detonation.mineId
      )

    if (mine) {
      explodeClaymore(
        mine,
        detonation.targetPlayerId
      )
    }

    claymoreDetonationQueue.splice(
      i,
      1
    )
  }
}

function explodeClaymore(
  mine,
  targetPlayerId
) {
  if (!mine.active) {
    return
  }

  mine.active = false

  let mineIndex =
    getClaymoreIndexById(
      mine.id
    )

  playClaymoreExplosion(
    mine
  )

  try {
    api.broadcastSound(
      "cannonFire1",
      1,
      1.5,
      {
        playerIdOrPos:
          mine.pos
      }
    )
  } catch {}

  try {
    if (
      !playerIsIgnoredByClaymore(
        targetPlayerId
      )
    ) {
      api.killLifeform(
        targetPlayerId
      )
    }
  } catch {}

  deleteClaymoreMeshes(
    mine
  )

  if (
    mineIndex &gt;= 0
  ) {
    claymores.splice(
      mineIndex,
      1
    )
  }
}

function playClaymoreExplosion(
  mine
) {
  let fx =
    mine.forward[0]

  let fz =
    mine.forward[1]

  let rx =
    mine.right[0]

  let rz =
    mine.right[1]

  try {
    api.playParticleEffect({
      texture:
        "critical_hit",

      pos1: [
        mine.pos[0] -
          0.4,
        mine.pos[1] +
          0.15,
        mine.pos[2] -
          0.4
      ],

      pos2: [
        mine.pos[0] +
          0.4,
        mine.pos[1] +
          1.0,
        mine.pos[2] +
          0.4
      ],

      dir1: [
        fx * 3 -
          rx * 2.5,
        0.2,
        fz * 3 -
          rz * 2.5
      ],

      dir2: [
        fx * 6 +
          rx * 2.5,
        3,
        fz * 6 +
          rz * 2.5
      ],

      minLifeTime:
        0.2,

      maxLifeTime:
        0.6,

      minEmitPower:
        2,

      maxEmitPower:
        6,

      minSize:
        0.25,

      maxSize:
        0.8,

      manualEmitCount:
        80,

      gravity:
        [0, -2.5, 0],

      colorGradients: [
        {
          timeFraction: 0,

          minColor:
            [255, 50, 10, 1],

          maxColor:
            [255, 230, 100, 1]
        },

        {
          timeFraction: 0.5,

          minColor:
            [180, 40, 10, 0.9],

          maxColor:
            [255, 110, 20, 0.8]
        }
      ],

      velocityGradients: [
        {
          timeFraction: 0,
          factor: 1,
          factor2: 1.5
        }
      ],

      blendMode:
        1,

      hideDist:
        100
    })
  } catch {}

  try {
    api.playParticleEffect({
      texture:
        "soul_0",

      pos1: [
        mine.pos[0] -
          0.25,
        mine.pos[1] +
          0.25,
        mine.pos[2] -
          0.25
      ],

      pos2: [
        mine.pos[0] +
          0.25,
        mine.pos[1] +
          0.9,
        mine.pos[2] +
          0.25
      ],

      dir1: [
        fx * 0.5 -
          rx,
        0.5,
        fz * 0.5 -
          rz
      ],

      dir2: [
        fx * 2 +
          rx,
        3,
        fz * 2 +
          rz
      ],

      minLifeTime:
        0.8,

      maxLifeTime:
        1.7,

      minEmitPower:
        0.7,

      maxEmitPower:
        2.2,

      minSize:
        0.4,

      maxSize:
        1.2,

      manualEmitCount:
        32,

      gravity:
        [0, 0.5, 0],

      colorGradients: [
        {
          timeFraction: 0,

          minColor:
            [50, 50, 50, 0.9],

          maxColor:
            [110, 110, 110, 0.8]
        },

        {
          timeFraction: 1,

          minColor:
            [20, 20, 20, 0],

          maxColor:
            [60, 60, 60, 0]
        }
      ],

      velocityGradients: [
        {
          timeFraction: 0,
          factor: 0.7,
          factor2: 1
        }
      ],

      blendMode:
        1,

      hideDist:
        100
    })
  } catch {}
}

function getClaymoreById(
  mineId
) {
  for (
    let mine of claymores
  ) {
    if (
      mine.id === mineId
    ) {
      return mine
    }
  }

  return null
}

function getClaymoreIndexById(
  mineId
) {
  for (
    let i = 0;
    i &lt; claymores.length;
    i++
  ) {
    if (
      claymores[i].id ===
      mineId
    ) {
      return i
    }
  }

  return -1
}

function deleteClaymoreMeshes(
  mine
) {
  for (
    let meshId of
      mine.meshIds
  ) {
    try {
      api.deleteMeshEntity(
        meshId
      )
    } catch {}
  }

  mine.meshIds = []
}

function cleanupFailedClaymore(
  mine
) {
  deleteClaymoreMeshes(
    mine
  )
}

u/Green-Outside4897

Gaijin when?

MIM- 104 Patwiot

WORKING ARTILLERY!! 2A65 Msta-B Artillery

the “long awaited” artillery code is now out!

I LOVE THIS NEW SYSTEM!

Check out this 1:1 CL-1201! Built by my friend Kiryu_Mechagodzilla!!

Getting 3 kills in a row is so satisfying to see

Speed aint doing NOTHING

It’s like one of those reels where they show the before and after

Since Russia has announced a new model and name for the BMPT Terminator the BMPT "Spiridon" do you think Gaijin will rename the BMPT terminator to BMPT “Spiridon” or make a whole new BMPT?

2 rockets beat 1 rocket

Some cool screenshots i got

WTH DID MY CODE EVEN DO 😭🙏

Giving my artillery cannon a mind of its own it can now detect players and mobs!!!

Adding working artillery to bloxd! WIP

Belt-fed minigun and Ammo backpack

Belt-fed Minigun and ammo backpack. WIP

Claymores!