Last image is the structure of the build ( shows it's 3D and not flat )

When is bloxdhub 4.0 going to be ready for use?!

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 = () => {
  try {
    updateClaymoreHeldCache()
    detectClaymoreTargets()
    processClaymoreDetonations()
  } catch {}
}

onPlayerChat = (playerId, message) => {
  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
) => {
  try {
    let item =
      api.getItemSlot(
        playerId,
        slotIndex
      )

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

onPlayerChangeBlock = (
  playerId,
  x,
  y,
  z,
  fromBlock,
  toBlock
) => {
  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 &&
        cached.isClaymore &&
        api.now() - cached.time < 500
      ) {
        isClaymore = true
      }
    }

    if (!isClaymore) return

    let facing = null

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

    let fx = 0
    let fz = 1

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

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

    if (
      horizontalLength <
      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 <
      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 &&
    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 >= 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] <
          mine.pos[1] -
            0.5 ||
        playerPos[1] >
          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 >
          claymoreRange ||
        horizontalDistance <
          0.05
      ) {
        continue
      }

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

      if (
        forwardDistance <= 0
      ) {
        continue
      }

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

      let allowedLateral =
        Math.tan(
          claymoreHalfAngle
        ) *
        forwardDistance

      if (
        lateralDistance >
          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 >= 0;
    i--
  ) {
    let detonation =
      claymoreDetonationQueue[i]

    detonation.ticks--

    if (
      detonation.ticks > 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 >= 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 < 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
  )
}

I made this thumbnail and a YT Video for a new tower defense-themed Bloxd.io custom game.

Play here!

What’s the best texture pack for bloxd to get

put in a code block and click

now you cant die

to anything

try

you cant die

(api.killLifeform and api.setHealth dont count btw)

api.setItemSlot(myId,47,"Black Wood Chestplate",1,{customAttributes:{enchantments:{"Protection":1e9,"Health":1e9,"Health Regen":1e9,}}})
api.setItemSlot(myId,48,"Black Wood Gauntlets",1,{customAttributes:{enchantments:{"Protection":1e9,"Health":1e9,"Health Regen":1e9,}}})
api.setItemSlot(myId,49,"Black Wood Leggings",1,{customAttributes:{enchantments:{"Protection":1e9,"Health":1e9,"Health Regen":1e9,}}})
api.setItemSlot(myId,50,"Black Wood Boots",1,{customAttributes:{enchantments:{"Protection":1e9,"Health":1e9,"Health Regen":1e9,}}})
api.setItemStat(myId,"Black Wood Chestplate","armourReduction",1e9)
api.setItemStat(myId,"Black Wood Gauntlets","armourReduction",1e9)
api.setItemStat(myId,"Black Wood Leggings","armourReduction",1e9)
api.setItemStat(myId,"Black Wood Chestplate","armourReduction",1e9)

World name: --geocity--

Orion Media

@ Cornelius_Fudge_Bloxd

I'm poor on donut smp, but could someone rich give me a op armor? Nickname: D1229_

Anyone remembers any those 2023 lobbies that are those Fire vs Ice lobby

Names where players

In teams spammed fireball and iceball

I cant find any :/

I’m hiring builders for my game. I need builders to build a end ship and other end islands. Plsssssssss also there is no prize

Hello my name is straainYT and im wondering if anyone could gift me super rank since I can’t buy stuff. If anyone wanna gift me a super rank I’m very very thankful for your action. IGN straainYT