How can I break a part into X amount of small pieces?

[Vibe90K (Z_Duck)]

SmallPart.Position = Part.Position

i forgot to do that

[yoolurs]

Thats going to put every part in the middle. I’m trying to make them all fill the pane of glass pretty much.

[Vibe90K (Z_Duck)]

But you would have to use negate and union, And it will affect the games performance

[yoolurs]

You dont have to union it. You can create parts and position them.

[XObbyCreatorX (IIIIIIIIIIII)]

Made this but I haven’t tried it. Let me know if you have any errors:

local function createPieces(part) -------- part is the window
    if part ~= nil then
        local size = part.Size
        local position = part.Position
        local pieces = (size.X+size.Y)/2
        for i = 1, pieces do
            local piece = Instance.new("Part", workspace)
            piece.Name = part.Name.." piece"
            piece.Size = Vector3.new(size.X/pieces, size.Y/pieces, size.Z)
            piece.Position = Vector3.new(math.random(-posiion.X/1.25, position.X/1.25), math.random(-position.Y/1.25,position.Y/1.25), position.Z)
            piece.Color = part.Color
            piece.Transparency = part.Transparency
            piece:ApplyImpulse(part.CFrame.LookVector * 50) ---- delete if you dont want the pieces to fling slightly
        end
        part:Destroy()
    end
end

createPieces()

[yoolurs]

https://gyazo.com/6a0fbde0d9796a2249c7c9d99c1ff370

Here is the result.
I would also sometimes get this error if I hit one of the panes of glass that was angled differently.

invalid argument #2 to 'random' (interval is empty) 

[XObbyCreatorX (IIIIIIIIIIII)]

Fixed it. Put this in the part you want to break:

local function createPieces(part) -------- part is the window

    if part ~= nil then

        local size = part.Size

        local position = part.Position

        local pieces = (size.X+size.Y)/2

        for i = 1, pieces do

            local piece = Instance.new("Part", workspace)

            piece.Name = part.Name.." piece"

            piece.Size = Vector3.new((size.X/pieces)+math.random(0.25,1), (size.Y/pieces)+math.random(0.25,1), size.Z)
    
            piece.CFrame = part.CFrame * CFrame.new(math.random(-size.X, size.X)/1.5, math.random(-size.Y,size.Y)/1.5, 0)

            piece.Color = part.Color

            piece.Transparency = part.Transparency

            piece.Anchored = true

            piece:ApplyImpulse(part.CFrame.LookVector * 50)---- delete if you dont want the pieces to fling slightly
        end

        part:Destroy()

    end
end

createPieces(script.Parent)

[Inpultion (Nash)]

You forgot to parent the piece variable to something.

[XObbyCreatorX (IIIIIIIIIIII)]

local piece = Instance.new(“Part”, workspace)

[Inpultion (Nash)]

Oh my bad (I never really use the second argument haha), also you shouldn’t use the second argument, it has performance amplifications.

Here’s the post by the staff (If you’re interested):

PSA: Don't use Instance.new() with parent argument

I’ve discovered a pretty bad performance issue in one of top games that has to do with Instance.new and wanted to write about this, since this is not obvious unless you know the system inside out. Tthere are several ways to create a ROBLOX object in Lua: local obj = Instance.new(‘type’); fill obj fields local obj = Instance.new(‘type’, parent); fill obj fields local obj = util.Create(‘type’, { field1 = value1, … }) If you care at all about performance, please only use the first option - I wi…

[XObbyCreatorX (IIIIIIIIIIII)]

Oh ok. I’ve used it for many years as a line saver lol. Thanks for the info!

[nicemike40]

It’s not exactly what you want, but I found these posts for breaking parts into triangles instead of blocks:

Part fracturing system V3

As we all know, destruction is a nice thing. Everyone loves a bit of destruction here and there. To make things better for our world, I introduce you to do this part fracturing system that is free to use! What is this system? This system is an easy to set-up module that allows you to make any blocks destructible!

Here are some examples!

Launching a ball at glass Ball code local Ball = script.Parent local SSS = game:GetService("ServerScriptService") local Module = requ…

FragmentSmasher - Window/other object obliterator Module

-Introduction- Hello everyone! I noticed that there are posts about the destruction of windows, but no open sourced code or modules I could find on the subject. So, I created FragmentSmasher, a simple module with one function for the destruction of windows and other things. The module contains one useful function,BreakSurface(), for breaking apart a square/rectangular shaped part. It works by taking the original part, and replacing it with a multitude of triangles of the same total size. -Exa…

For blocks, the easiest option would be to pick a line to divide the part along a single axis, once. Then do the same for each of the two halves. Repeat until you have the number you’d like. Would be okay for most visual purposes and be easy to implement.

[nicemike40]

This is a promising approach for a slightly more random layout: geometry - Has anyone ever attempted to find all splits of a rectangle into smaller rectangles? - Mathematics Stack Exchange

[yoolurs]

o wow woke up to a lot of responses lol. I’m gonna try some of this stuff out. I’ll update you on how it goes.

Greatly appreciate the help.

[voozy_v]

I can think of 2 approaches to this.

The first one would basically be manually splitting up the windows and walls, and when they get broken, unanchor each piece and use bodyforces to make them fly out.

The second method would be actually scripting it to be shattered into customizable amounts of pieces. The first problem of this would how to actually do it; It’d definitely require a lot of math and thinking. The second problem with this is the shape of the pieces. If you had more than just cubes, say wedges, then it’d make things even more complicated.

[yoolurs]

This almost works.
The only issue is that the pieces dont actually fill up the window.

[yoolurs]

the manual method isn’t the best for me. I’m going to have destructible buildings in my game so I dont think it would be too performance friendly if every single part had X amount of little parts in it.

[yoolurs]

this is EXTREMELY promising.
I tried to use part fracturing system v3 but it requires parts to be positioned a certain way so that wont work for my game.

I tried FragmentSmasher and this is the very promising result I received.
https://gyazo.com/571cd25bc520efcbbdc59883f59d614e

As you can see though there is ONE small issue.
The fragments are always positioned in the same direction. If I can fix that. This would be perfect.
I’m assuming it has something to do with this part of code in the script.

local function CreateQuadrants()
        local Quadrants = {}

        local Region =
            Region3.new(
            Vector3.new(CenterPos.X, CenterPos.Y, CenterPos.Z),
            Pane.Position + Vector3.new(Pane.Size.X / 2, Pane.Size.Y / 2, 0)
        )

        local QuadrantA = Instance.new("Part")
        QuadrantA.Anchored = true
        QuadrantA.CFrame = Region.CFrame
        QuadrantA.Size = Vector3.new(math.abs(Region.Size.X), math.abs(Region.Size.Y), math.abs(Pane.Size.Z))
		QuadrantA.Parent = workspace

        QuadrantA.Transparency = Pane.Transparency
        QuadrantA.Reflectance = Pane.Reflectance
		QuadrantA.Color = Pane.Color
		QuadrantA.Material = Pane.Material
        table.insert(Quadrants, QuadrantA)

        local Region =
            Region3.new(
            Pane.Position + Vector3.new(Pane.Size.X / -2, Pane.Size.Y / -2, 0),
            Vector3.new(CenterPos.X, CenterPos.Y, CenterPos.Z)
        )

        local QuadrantB = Instance.new("Part")
        QuadrantB.Anchored = true
        QuadrantB.CFrame = Region.CFrame
        QuadrantB.Size = Vector3.new(math.abs(Region.Size.X), math.abs(Region.Size.Y), math.abs(Pane.Size.Z))
        QuadrantB.Parent = workspace

        QuadrantB.Transparency = Pane.Transparency
        QuadrantB.Reflectance = Pane.Reflectance
        QuadrantB.Color = Pane.Color
		QuadrantB.Material = Pane.Material
        table.insert(Quadrants, QuadrantB)

        local Region =
            Region3.new(
            Vector3.new(CenterPos.X, CenterPos.Y, CenterPos.Z),
            Pane.Position + Vector3.new(Pane.Size.X / 2, Pane.Size.Y / -2, 0)
        )

        local QuadrantC = Instance.new("Part")
        QuadrantC.Anchored = true
        QuadrantC.CFrame = Region.CFrame
        QuadrantC.Size = Vector3.new(math.abs(Region.Size.X), math.abs(Region.Size.Y), math.abs(Pane.Size.Z))
        QuadrantC.Parent = workspace

        QuadrantC.Transparency = Pane.Transparency
        QuadrantC.Reflectance = Pane.Reflectance
		QuadrantC.Color = Pane.Color
		QuadrantC.Material = Pane.Material

        table.insert(Quadrants, QuadrantC)

        local Region =
            Region3.new(
            Vector3.new(CenterPos.X, CenterPos.Y, CenterPos.Z),
            Pane.Position + Vector3.new(Pane.Size.X / -2, Pane.Size.Y / 2, 0)
        )

        local QuadrantD = Instance.new("Part")
        QuadrantD.Anchored = true
        QuadrantD.CFrame = Region.CFrame
        QuadrantD.Size = Vector3.new(math.abs(Region.Size.X), math.abs(Region.Size.Y), math.abs(Pane.Size.Z))
        QuadrantD.Parent = workspace

        QuadrantD.Transparency = Pane.Transparency
        QuadrantD.Reflectance = Pane.Reflectance
		QuadrantD.Color = Pane.Color
		QuadrantD.Material = Pane.Material

        table.insert(Quadrants, QuadrantD)

        Pane:Destroy()

        return Quadrants
    end

CenterPos is the origin of the break. (Where the crack starts)
Pane is the part being destroyed.

[yoolurs]

I’ve customized the script a bit to fit some things I want but still having trouble making it fit the entire part.
It has something to do with this part of the region3

 Pane.Position + Vector3.new(Pane.Size.X / 2, Pane.Size.Y / 2, 0)

That causes the issue where its always angled the same. Not sure how to fix it.

[yoolurs]

I will mark you as a solution. In FragmentSmasher some kind person actually left some code to adjust the position to fix the problem.