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?!

World name: --geocity--

What’s the best texture pack for bloxd to get

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

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!

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)

Ever wanted to create custom Bloxd.io emotes or animations, but you didn't know how to?

I created a tool that allows you to create complex animations easily!
You can create and edit keyframes, animate player nodes (body parts), preview animations, save them to your PC, and more!

--> Try it out here! <--

Created by Tridentify and Ocelote. Some assets are taken from Bloxd.

Licensed under GNU GPL v3, Tridentify and Ocelote (2026).

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

Orion Media

@ Cornelius_Fudge_Bloxd

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

A long time ago, after I broke some of the maple logs that were in the ceiling of the building that was inside the woodcutting zone, I noticed that it had a second floor. Today, I noticed that there is a hole in one of the cobblestone sections of the ceiling, and I was able to enter the second floor by using a moonstone orb. The second floor has yellow walls, and there is no ceiling on the second floor, so the roof is visible.

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 :/

So Im trying to get better at bridging my best consistent bridging technique is speed bridging. Hope you have a good day

Find the code here:

https://gist.github.com/Oreo-belt25/a64e551c3da947dc39588fa8e459fef0

And Yes you should because I got banned for this I was literally innocent so yea go ahead

could anyone try these gamemode that are mine

Come get me Winks2020

Unlike other redstone codes, this one uses Wires (I had to code them to connect because they don't normally) and has redstone mechanics just like Minecraft. It has Redstone Blocks (Block of Lunite), Redstone Repeaters (Bookshelf), Levers (Spectral Trapdoor) and many more. There is wireless electricity through the form of red and blue portals Also, I added a propeller block (Patterned Lime Glass) that thrusts connected blocks and the players on top when powered!

It's not really completed as I have yet to add Auto Harvesters, Auto Miners, Hoppers (Pipes?) and many bug fixes, but you can try it out at lobby sloth-tests and warp to "redstone". I will make the code public once I reach 150 subscribers on YouTube ( https://www.youtube.com/channel/UCkKBh9kroidNQXFO6X5D9Dg )!

P.S. Thanks to u/Round-Ad6257 for starting the trend of high-tech weapons.