•
•
•
•
RoboCatz.com

Roblox Ziggurat of Ur

Vibe Coding: The "New" Way to Program
The Ziggurat of Ur Example


Ziggurat of Ur
Ziggurats are pyramidal stepped temple towers built by the Sumerians, Babylonians, and Assyrians of ancient Mesopotamia - the region between the Tigris and Euphrates rivers. There are approximately 25 surviving ziggurats, and the ziggurat at Ur is one of the best preserved.

The city of Ur was one of the most important Sumerian city states in ancient Mesopotamia during the 3rd millennium BC. One of best preserved and most spectacular remains of this ancient city is the Great Ziggurat of Ur.

The Great Ziggurat, which is in Iraq, is a massive step pyramid measuring 64 meters in length and 30 meters in height. This height, however, is just speculation, as only the foundations of this ancient monument survive today. The Great Ziggurat of Ur consisted of successively smaller platforms that had a solid core of mud-brick which was covered by burnt brick. The Great Ziggurat of Ur was part of the temple complex of the city state, --administrative center of Ur.

What is Vibe Coding?

Vibe Coding is a cool way to write programs with the help of AI (artificial intelligence). Imagine having a super-smart assistant by your side while coding! The AI can help you in different ways -- it might create an entire program for you, or just give you ideas and help with specific parts, depending on what you need.

To get started, you simply talk to the AI and explain what you want your program to do. The AI will then create a rough version of the program for you. After that, you can ask the AI questions, make suggestions, or request changes to add new features or fix things until the program is just the way you want it.

For this project, before asking AI to start coding, I wanted to establish some basic facts about the project with AI. So, I will begin the AI chat with simple questions about Ziggurats.

Are you familiar with the Ziggurat of Ur?

Absolutely! The Ziggurat of Ur is one of the most iconic monuments of ancient Mesopotamia. It's a massive step pyramid located in the ancient city of Ur (modern-day Iraq). Built around the 21st century BCE during the reign of King Ur-Nammu, it was dedicated to the moon god Nanna (or Sin), the patron deity of Ur.

The structure served as a temple complex, and its towering design symbolized a connection between the heavens and the earth. While much of the original structure has eroded over time, parts of it were reconstructed during the 20th century to give us a glimpse of its grandeur.

It's fascinating to think about the ingenuity of ancient civilizations, isn't it? If you'd like to dive deeper into its history or symbolism, let me know!

Do you know the approximate dimensions and approximate number of levels?

Yes! The Ziggurat of Ur is an impressive structure. It originally had three main levels, though some reconstructions suggest there might have been additional smaller levels or platforms. The dimensions of the base are approximately 64 meters (210 feet) by 46 meters (150 feet), and the height of the ziggurat in its prime is estimated to have been around 20-30 meters (66-98 feet). Each level would have been smaller than the one below it, creating its distinctive stepped appearance.

The reconstruction helps give a sense of the scale, but imagine standing before this monument thousands of years ago - it must have been awe-inspiring! Do you find ancient architecture as fascinating as I do?

I would like to construct one in Roblox--the 3D world for kids. Can you help get me started with constructing a structure like that? I know the walls are sloped inward (I guess to prevent it from falling apart). How can I achieve this effect in Roblox?

Absolutely, building a Ziggurat in Roblox sounds like a fantastic project! To achieve the sloped inward walls, you can use the following steps:


  1. Start with the Base: Create a large rectangular base using the "Part" tool in Roblox Studio. Adjust its dimensions to match the proportions of the Ziggurat's base.

  2. Add Layers: For each level of the Ziggurat, create smaller rectangular parts and stack them on top of the base. Each layer should be slightly smaller than the one below it to create the stepped appearance.

  3. Slope the Walls: To make the walls sloped inward, you can use the "Scale" tool to adjust the dimensions of each layer. Alternatively, you can use wedges or triangular parts to create the sloped effect. Place these parts along the edges of each layer to mimic the inward slope.

  4. Detailing: Add staircases, pathways, or decorative elements to enhance the realism. You can use textures and materials to give it an ancient look.

  5. Test and Adjust: Playtest your creation to ensure everything looks and functions as intended. Adjust the proportions or slopes as needed.

If you're new to Roblox Studio, there are plenty of tutorials available online to help you get started. You can find some helpful resources here or explore a video tutorial on building structures here. Let me know if you'd like more tips or guidance!

Can you do this in the Luau code?
Yes, I can! Here's a basic example of how to construct a stepped Ziggurat structure in Luau (the scripting language used in Roblox). This script will create multiple layers of a Ziggurat with inward-sloping walls by scaling each layer slightly smaller than the one below it.

Example:
local layers = 5 -- Number of layers in the Ziggurat
local baseSize = Vector3.new(50, 5, 50) -- Size of the bottom layer
local position = Vector3.new(0, 0, 0) -- Starting position for the Ziggurat

for i = 1, layers do
    -- Create a new part for each layer
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new(i * 4, 0, i * 4) -- Scale each layer smaller
    layer.Position = position + Vector3.new(0, (i - 1) * baseSize.Y, 0) -- Stack layers vertically
    layer.Anchored = true -- Anchor the part so it doesn't fall
    layer.Material = Enum.Material.Sandstone -- Give it a sandstone-like appearance
    layer.BrickColor = BrickColor.new("Reddish brown") -- Choose a suitable color
    layer.Parent = workspace -- Place the part into the game workspace
end
Explanation:
  1. Layers: The layers variable defines how many levels your Ziggurat will have.
  2. Scaling: Each layer is scaled smaller by decreasing its width and depth while keeping the height constant.
  3. Positioning: Each layer is stacked vertically by adjusting the Y position based on the height of the previous layer.
  4. Appearance: You can customize the material, color, and texture to give it an ancient Ziggurat-like feel.
Feel free to tweak the code to match the proportions you want for your Ziggurat. Let me know if you need further assistance or want to add more features, like staircases or lighting!
I think it is supposed to be 64 meters across at the base. Can you revise your dimensions?
Of course! Since 64 meters (or approximately 210 feet) is the correct base dimension, I'll adjust the code accordingly. Here's the revised Luau script for your Ziggurat:

Example:
local layers = 5 -- Number of layers in the Ziggurat
local baseSize = Vector3.new(64, 5, 64) -- Base dimensions: 64 meters across and 5 meters high
local position = Vector3.new(0, 0, 0) -- Starting position for the Ziggurat

for i = 1, layers do
    -- Create a new part for each layer
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new(i * 4, 0, i * 4) -- Gradually scale down each layer
    layer.Position = position + Vector3.new(0, (i - 1) * baseSize.Y, 0) -- Stack layers vertically
    layer.Anchored = true -- Anchor each part so it stays in place
    layer.Material = Enum.Material.Sandstone -- Use sandstone-like material for a historical look
    layer.BrickColor = BrickColor.new("Reddish brown") -- Assign a fitting color
    layer.Parent = workspace -- Place the part into the game workspace
end
Updates Made:
  1. The base width and depth are now set to 64 meters each, reflecting the correct dimensions.
  2. The script ensures that each successive layer decreases in size by 4 meters on both width and depth, creating the iconic stepped appearance of the Ziggurat.
  3. The height of each layer remains constant at 5 meters, which you can adjust if needed for a different aesthetic.

This code should now give you a more historically accurate starting point for your Ziggurat. Feel free to modify the number of layers or other details to fit your vision. Let me know how your Roblox project shapes up!
Well. I think 1 Roblox unit is equivalent to 1 foot. So shouldn't the dimensions then be 210 across at the base?
You're absolutely correct! If one Roblox unit equals one foot, then the base of the Ziggurat should indeed be 210 units across, since the historical dimensions of the Ziggurat of Ur were approximately 210 feet wide. Let me revise the Luau code for you to reflect this:

Example:
local layers = 5 -- Number of layers in the Ziggurat
local baseSize = Vector3.new(210, 5, 210) -- Base dimensions: 210 units wide and 5 units tall
local position = Vector3.new(0, 0, 0) -- Starting position for the Ziggurat

for i = 1, layers do
    -- Create a new part for each layer
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new(i * 10, 0, i * 10) -- Scale each layer smaller by 10 units per level
    layer.Position = position + Vector3.new(0, (i - 1) * baseSize.Y, 0) -- Stack layers vertically
    layer.Anchored = true -- Anchor each part to stay in place
    layer.Material = Enum.Material.Sandstone -- Use sandstone-like material for a historical aesthetic
    layer.BrickColor = BrickColor.new("Reddish brown") -- Choose an appropriate color
    layer.Parent = workspace -- Add the part to the game workspace
end
Changes:

  1. The base size has been updated to 210 units wide, matching the historical dimension.
  2. Each layer decreases by 10 units on width and depth, creating the stepped appearance while maintaining proportional scaling.
  3. The height of each layer remains at 5 units, but you can adjust this if you prefer taller layers.

This should now align perfectly with Roblox's unit system! Let me know how your Ziggurat turns out or if you need any further tweaks. Building history in a virtual world sounds like such a fun project!

I think the height is supposed to be about 100 feet tall. So, the first layer should be about 50 feet tall and the second layer would be about 20 feet tall, and the third layer would be about 15 feet tall and the 4th layer will be about 10 feet tall.
Got it! Let's revise the script to account for these proportions while keeping the Ziggurat historically and visually accurate. Here's how the layers will be adjusted based on the dimensions you provided for the height of each layer:
The script now reflects these adjustments:

Example:
local layers = 4 -- Number of layers in the Ziggurat
local baseSize = Vector3.new(210, 50, 210) -- Base dimensions: 210 units wide and 50 units tall for the first layer
local heightSteps = {50, 20, 15, 10} -- Heights for each layer
local position = Vector3.new(0, 0, 0) -- Starting position for the Ziggurat

for i = 1, layers do
    -- Create a new part for each layer
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10) -- Decrease width and depth by 10 units per level
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z) -- Set the height for each layer
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1), 0) -- Stack layers vertically
    layer.Anchored = true -- Anchor each part to stay in place
    layer.Material = Enum.Material.Sandstone -- Use sandstone-like material
    layer.BrickColor = BrickColor.new("Reddish brown") -- Choose a historical-looking color
    layer.Parent = workspace -- Add the part to the game workspace
end

-- Function to calculate the cumulative height of previous layers
function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end
Adjustments:

  1. Each layer's height is explicitly defined using the heightSteps array, which ensures the correct proportions.
  2. The vertical stacking uses the sumHeight function to calculate the cumulative height of previous layers, so everything aligns properly.
  3. The base's width and depth decrease by 10 units per level to maintain the sloped appearance.

This script now reflects your dimensions and creates a more accurate representation of the Ziggurat. Let me know if you'd like to add further refinements, such as staircases, decorative features, or lighting to enhance the design!

In Lua, the function needs to be defined before it can be used. So, for example, the function sumHeight() should be defined before the "for" loop.
You're absolutely right - my mistake there! In Lua, functions do need to be defined before they are used. Here's the corrected script with the sumHeight function properly placed before the loop:

Example:
-- Function to calculate the cumulative height of previous layers
function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end

local layers = 4 -- Number of layers in the Ziggurat
local baseSize = Vector3.new(210, 50, 210) -- Base dimensions: 210 units wide and 50 units tall for the first layer
local heightSteps = {50, 20, 15, 10} -- Heights for each layer
local position = Vector3.new(0, 0, 0) -- Starting position for the Ziggurat

for i = 1, layers do
    -- Create a new part for each layer
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10) -- Decrease width and depth by 10 units per level
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z) -- Set the height for each layer
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1), 0) -- Stack layers vertically
    layer.Anchored = true -- Anchor each part to stay in place
    layer.Material = Enum.Material.Sandstone -- Use sandstone-like material
    layer.BrickColor = BrickColor.new("Reddish brown") -- Choose a historical-looking color
    layer.Parent = workspace -- Add the part to the game workspace
end
Key Adjustment:

The sumHeight function is now defined at the top of the script, before it's used in the for loop. This ensures the script will run without errors and calculate the vertical stacking correctly.

Thank you for catching that detail! Let me know if there's anything else you'd like to refine or add to your Ziggurat!

The base layer is fine. But the layer above it seems to be hovering in the air. Does the y-coordinate for the second layer represent the bottom of the second layer or the middle of the second layer?
Great question! In Roblox, the Position property of a part represents the center point of the part, not the bottom. This explains why the second layer appears to hover - it's being placed with its center at the calculated height, causing the lower half of the layer to float above the base.

To fix this, you need to adjust the Y position of each layer so that its bottom aligns properly with the top of the previous layer. Here's how you can modify the Position calculation in the script:

layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1) + heightSteps[i] / 2, 0)

Explanation:
With this adjustment, the layers should stack seamlessly, and your Ziggurat will look structurally accurate. Let me know if this resolves the issue or if you'd like any more assistance!

I think we're almost there. I believe one of the prominent features of the Ziggurat was it's main staircase to the top of the first layer and then smaller stair cases to reach the other layers.
You're absolutely right! The Ziggurat of Ur was renowned for its grand staircase leading to the top of the first layer, complemented by smaller staircases providing access to the subsequent layers. Let me help you incorporate these features into your Roblox Ziggurat design.
Adding a Grand Staircase:

  1. Main Staircase: You can create the grand staircase at the base leading to the first layer using sloped wedges or smaller rectangular parts arranged in a stair-like pattern. These parts should align with the middle of the Ziggurat's front face.
  2. Proportions: Make the staircase wide enough to emphasize its prominence - around 20-30 units wide should look majestic in Roblox proportions. The incline should reach the top of the first layer seamlessly.

Adding Smaller Staircases:
For the higher levels:

  1. Side Staircases: Create smaller staircases leading from one layer to the next along the sides or corners of the Ziggurat. These can be narrower, perhaps 5-10 units wide.
  2. Alignment: Position them strategically to create a natural flow for climbing from one level to the next.

Here's an updated version of the script that incorporates basic staircases:

Example:
function createStaircase(startPosition, width, height, length, parent)
    local steps = math.ceil(length / width) -- Number of steps based on width and length
    for i = 0, steps - 1 do
        local step = Instance.new("Part")
        step.Size = Vector3.new(width, height, width) -- Set dimensions of each step
        step.Position = startPosition + Vector3.new(0, i * height, -i * width) -- Position steps diagonally
        step.Anchored = true
        step.Material = Enum.Material.Sandstone
        step.BrickColor = BrickColor.new("Reddish brown")
        step.Parent = parent
    end
end

local layers = 4
local baseSize = Vector3.new(210, 50, 210)
local heightSteps = {50, 20, 15, 10}
local position = Vector3.new(0, 0, 0)

for i = 1, layers do
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10)
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z)
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1) + heightSteps[i] / 2, 0)
    layer.Anchored = true
    layer.Material = Enum.Material.Sandstone
    layer.BrickColor = BrickColor.new("Reddish brown")
    layer.Parent = workspace

    -- Create staircase for the first layer
    if i == 1 then
        createStaircase(layer.Position + Vector3.new(0, -heightSteps[i] / 2, baseSize.Z / 2), 5, 2, 50, workspace)
    end
end

function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end
Key Additions:

  1. createStaircase Function: Generates steps by positioning parts diagonally to simulate a staircase.
  2. Grand Staircase: Attached to the first layer's front face, it reaches from the ground to the top of the base layer.
  3. Smaller Staircases: You can duplicate and tweak the createStaircase function to add narrower staircases for the upper layers.

Try this out, and let me know if you'd like further refinements or more detailed features! Your Ziggurat is shaping up to be incredible.

Note to viewers:
At this point, I should have used print() statements inside the createStaircase() for loop to print the x,y,z coordinates for each step. If I had done that, I may have noticed how the steps were being positioned.
Don't forget. The sumHeight needs to be defined above the "for" loop. I did see a remnant of the staircase. The last stair was poking through the base of the Ziggurat. I think the staircase needs to be re-positioned on the z-axis so that it starts at the edge of the lowest z-coordinate of the base. Can you subtract a constant of 105 from the z-coordinate of the staircase so that it starts at the edge of the base?
You're absolutely right again—thank you for pointing that out! Let's make sure the sumHeight function is placed before the for loop and correct the staircase positioning so that it starts at the edge of the base by subtracting 105 from the z-coordinate. Here's the updated script:

Example:
-- Function to calculate the cumulative height of previous layers
function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end

-- Function to create a staircase
function createStaircase(startPosition, width, height, length, parent)
    local steps = math.ceil(length / width) -- Number of steps based on width and length
    for i = 0, steps - 1 do
        local step = Instance.new("Part")
        step.Size = Vector3.new(width, height, width) -- Set dimensions of each step
        step.Position = startPosition + Vector3.new(0, i * height, -i * width) -- Position steps diagonally
        step.Anchored = true
        step.Material = Enum.Material.Sandstone
        step.BrickColor = BrickColor.new("Reddish brown")
        step.Parent = parent
    end
end

local layers = 4
local baseSize = Vector3.new(210, 50, 210)
local heightSteps = {50, 20, 15, 10}
local position = Vector3.new(0, 0, 0)

for i = 1, layers do
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10)
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z)
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1) + heightSteps[i] / 2, 0)
    layer.Anchored = true
    layer.Material = Enum.Material.Sandstone
    layer.BrickColor = BrickColor.new("Reddish brown")
    layer.Parent = workspace

    -- Create staircase for the first layer
    if i == 1 then
        -- Adjusted the starting position to subtract 105 from the Z-coordinate
        local startZ = layer.Position.Z - baseSize.Z / 2 - 105
        createStaircase(Vector3.new(layer.Position.X, -heightSteps[i] / 2, startZ), 5, 2, 50, workspace)
    end
end
Key Adjustments:

  1. Function Placement: The sumHeight function is now correctly defined before the for loop.
  2. Staircase Repositioning: The Z-coordinate of the staircase's starting position is adjusted by subtracting 105 from the lowest Z-coordinate of the base (layer.Position.Z - baseSize.Z / 2 - 105).
  3. Grand Staircase: Now correctly starts at the base of the Ziggurat and aligns with its lowest Z-coordinate.

This updated script should resolve the hovering staircase issue while ensuring proper alignment with the base. Let me know if there are any more features you'd like to include or if you spot anything else that could use tweaking!

After some experimentation, I think the following works better for the staircase:
-- Function to create a staircase
function createStaircase(startPosition, width, height, totalHeight, parent)
local steps = math.ceil(totalHeight / width)
local riser = 2
local i = 0
while totalHeight - i * height > 0 do
local step = Instance.new("Part")
step.size = Vector3.new(width, height, width)
step.position = startPosition + Vector3.new(0, -i * height, -i * width)
step.anchored = true
step.material = Enum.Material.Sandstone
step.BrickColor = BrickColor.new("Reddish brown")
step. Parent = parent
i = i + 1
end
end
I see how your modification adds flexibility to the staircase creation, and I like the way you've used the while loop to ensure the staircase adjusts dynamically to the remaining height. By calculating steps based on totalHeight, this approach makes it easier to tailor the staircase design for different layer heights. Incorporating a constant riser value also opens up possibilities for more refined tweaks.

If you'd like, I can integrate this updated createStaircase function into the full Ziggurat-building script. Just let me know if you'd like further adjustments or enhancements, such as adding railings or decorative elements to the staircase. Your experimentation is really shaping this into an amazing project!

Yes please. Thanks.
Here's the updated Ziggurat-building script with your modified createStaircase function integrated. This version dynamically adjusts the staircase to the total height of the first layer using your logic:

Example:
-- Function to calculate the cumulative height of previous layers
function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end

-- Function to create a staircase
function createStaircase(startPosition, width, height, totalHeight, parent)
    local steps = math.ceil(totalHeight / width) -- Number of steps based on width and total height
    local riser = 2
    local i = 0
    while totalHeight - i * height > 0 do
        local step = Instance.new("Part")
        step.Size = Vector3.new(width, height, width) -- Set dimensions of each step
        step.Position = startPosition + Vector3.new(0, -i * height, -i * width) -- Position steps diagonally
        step.Anchored = true
        step.Material = Enum.Material.Sandstone
        step.BrickColor = BrickColor.new("Reddish brown")
        step.Parent = parent
        i = i + 1
    end
end

local layers = 4
local baseSize = Vector3.new(210, 50, 210)
local heightSteps = {50, 20, 15, 10}
local position = Vector3.new(0, 0, 0)

for i = 1, layers do
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10)
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z)
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1) + heightSteps[i] / 2, 0)
    layer.Anchored = true
    layer.Material = Enum.Material.Sandstone
    layer.BrickColor = BrickColor.new("Reddish brown")
    layer.Parent = workspace

    -- Create staircase for the first layer
    if i == 1 then
        local startZ = layer.Position.Z - baseSize.Z / 2 -- Place it at the edge of the base
        createStaircase(Vector3.new(layer.Position.X, layer.Position.Y - heightSteps[i] / 2, startZ), 5, 2, heightSteps[i], workspace)
    end
end
Key Features:

  1. Dynamic Staircase: The staircase now adjusts to the totalHeight of the first layer using your loop logic, ensuring it fits perfectly.
  2. Precise Positioning: The staircase is correctly aligned with the lowest Z-coordinate of the base, ensuring that it starts from the base's edge.
  3. Seamless Integration: The Ziggurat and its staircase are now fully aligned, with the base and steps forming a cohesive structure.

Feel free to test this updated script! If you'd like to add smaller staircases to the upper layers or further refine any element, let me know--I'd love to help fine-tune it further. Your Ziggurat project is shaping up to be quite an architectural marvel!

Almost there. Since the stairs in the staircase start at the top of the first layer, the layer.Position.Y should be added with heightSteps[i]/2 instead of subtracted.
Thanks for pointing that out! You're absolutely correct-if the stairs start at the top of the first layer, then the layer.Position.Y should indeed be added with heightSteps[i]/2. This adjustment ensures the staircase aligns properly at the top of the layer rather than below it. Here's the updated script with the corrected logic:

Example:
-- Function to calculate the cumulative height of previous layers
function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end

-- Function to create a staircase
function createStaircase(startPosition, width, height, totalHeight, parent)
    local steps = math.ceil(totalHeight / width) -- Number of steps based on width and total height
    local riser = 2
    local i = 0
    while totalHeight - i * height > 0 do
        local step = Instance.new("Part")
        step.Size = Vector3.new(width, height, width) -- Set dimensions of each step
        step.Position = startPosition + Vector3.new(0, i * height, -i * width) -- Position steps diagonally
        step.Anchored = true
        step.Material = Enum.Material.Sandstone
        step.BrickColor = BrickColor.new("Reddish brown")
        step.Parent = parent
        i = i + 1
    end
end

local layers = 4
local baseSize = Vector3.new(210, 50, 210)
local heightSteps = {50, 20, 15, 10}
local position = Vector3.new(0, 0, 0)

for i = 1, layers do
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10)
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z)
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1) + heightSteps[i] / 2, 0)
    layer.Anchored = true
    layer.Material = Enum.Material.Sandstone
    layer.BrickColor = BrickColor.new("Reddish brown")
    layer.Parent = workspace

    -- Create staircase for the first layer
    if i == 1 then
        local startZ = layer.Position.Z - baseSize.Z / 2 -- Place it at the edge of the base
        createStaircase(Vector3.new(layer.Position.X, layer.Position.Y + heightSteps[i] / 2, startZ), 5, 2, heightSteps[i], workspace)
    end
end
Changes Made:

  1. Y-coordinate Fix: For the staircase starting position, layer.Position.Y is now added with heightSteps[i]/2, properly aligning the stairs with the top of the first layer.
  2. Adjusted Stair Placement: This ensures the staircase starts at the correct elevation and visually connects with the first layer.

With this fix, the staircase should now seamlessly align with the Ziggurat. Let me know if there are any further refinements or details you'd like to add! You're really building something incredible here.

Ok. Last change. The steps need to decrease in height as they move away from the Ziggurat. The following should use a "-i * height" : Update with the following in the Staircase function: step.Position = startPosition + Vector3.new(0, i * height, -i * width) -- Position steps diagonally
Thanks for clarifying! I've updated the createStaircase function so that the height of the steps decreases as they move away from the Ziggurat using -i * height. Here's the finalized script:

Example:
-- Function to calculate the cumulative height of previous layers
function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end

-- Function to create a staircase with steps decreasing in height
function createStaircase(startPosition, width, height, totalHeight, parent)
    local steps = math.ceil(totalHeight / width) -- Number of steps based on width and total height
    local riser = 2
    local i = 0
    while totalHeight - i * height > 0 do
        local step = Instance.new("Part")
        step.Size = Vector3.new(width, height, width) -- Set dimensions of each step
        step.Position = startPosition + Vector3.new(0, -i * height, -i * width) -- Decrease height and position steps diagonally
        step.Anchored = true
        step.Material = Enum.Material.Sandstone
        step.BrickColor = BrickColor.new("Reddish brown")
        step.Parent = parent
        i = i + 1
    end
end

local layers = 4
local baseSize = Vector3.new(210, 50, 210)
local heightSteps = {50, 20, 15, 10}
local position = Vector3.new(0, 0, 0)

for i = 1, layers do
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10)
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z)
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1) + heightSteps[i] / 2, 0)
    layer.Anchored = true
    layer.Material = Enum.Material.Sandstone
    layer.BrickColor = BrickColor.new("Reddish brown")
    layer.Parent = workspace

    -- Create staircase for the first layer
    if i == 1 then
        local startZ = layer.Position.Z - baseSize.Z / 2 -- Place it at the edge of the base
        createStaircase(Vector3.new(layer.Position.X, layer.Position.Y + heightSteps[i] / 2, startZ), 5, 2, heightSteps[i], workspace)
    end
end
Updates:

  1. Step Position Adjustment: The step.Position now uses -i * height to decrease the height of the steps as they move diagonally away from the Ziggurat.
  2. Staircase Finalization: The starting position and alignment with the Ziggurat's base are maintained, ensuring the staircase integrates seamlessly.

This should be the perfect setup for your Ziggurat! Let me know if you'd like any final touches or additions. I'm excited to see your creation come to life!

Again. Because the y-Coordinate is in the middle of the part, we will need to subtract 1/2 of the part's height to get the part to touch the ground. The following update should be in the Staircase function: step.Position = startPosition + Vector3.new(0, -i * height - height/2, -i * width) -- Decrease height and position steps diagonally
You're absolutely correct—since the Position represents the center of the part, subtracting half the part's height ensures the step touches the ground properly. I've incorporated your update into the createStaircase function. Here's the revised script:

Example:
-- Function to calculate the cumulative height of previous layers
function sumHeight(heightSteps, count)
    local sum = 0
    for j = 1, count do
        sum = sum + heightSteps[j]
    end
    return sum
end

-- Function to create a staircase with correct Y-coordinate adjustment
function createStaircase(startPosition, width, height, totalHeight, parent)
    local steps = math.ceil(totalHeight / width) -- Number of steps based on width and total height
    local i = 0
    while totalHeight - i * height > 0 do
        local step = Instance.new("Part")
        step.Size = Vector3.new(width, height, width) -- Set dimensions of each step
        step.Position = startPosition + Vector3.new(0, -i * height - height / 2, -i * width) -- Adjust Y-coordinate and position steps diagonally
        step.Anchored = true
        step.Material = Enum.Material.Sandstone
        step.BrickColor = BrickColor.new("Reddish brown")
        step.Parent = parent
        i = i + 1
    end
end

local layers = 4
local baseSize = Vector3.new(210, 50, 210)
local heightSteps = {50, 20, 15, 10}
local position = Vector3.new(0, 0, 0)

for i = 1, layers do
    local layer = Instance.new("Part")
    layer.Size = baseSize - Vector3.new((i - 1) * 10, 0, (i - 1) * 10)
    layer.Size = Vector3.new(layer.Size.X, heightSteps[i], layer.Size.Z)
    layer.Position = position + Vector3.new(0, sumHeight(heightSteps, i - 1) + heightSteps[i] / 2, 0)
    layer.Anchored = true
    layer.Material = Enum.Material.Sandstone
    layer.BrickColor = BrickColor.new("Reddish brown")
    layer.Parent = workspace

    -- Create staircase for the first layer
    if i == 1 then
        local startZ = layer.Position.Z - baseSize.Z / 2 -- Place it at the edge of the base
        createStaircase(Vector3.new(layer.Position.X, layer.Position.Y + heightSteps[i] / 2, startZ), 5, 2, heightSteps[i], workspace)
    end
end
Key Adjustment:

  1. Y-Coordinate Fix for Steps: The line

    step. Position = startPosition + Vector3.new(0, -i * height - height / 2, -i * width)

    ensures the steps touch the ground properly by subtracting half their height from the Y-coordinate.
  2. Staircase Integrity: This final tweak eliminates the floating appearance and positions each step correctly along the staircase.

This should now work perfectly! If you'd like to add even more polish-like handrails or additional details-just let me know. Can't wait to hear how your Ziggurat turns out!

Perfect. thank you.
You're very welcome! I'm glad we could get everything just right for your Ziggurat. It sounds like an incredible project, and I hope it turns out beautifully in Roblox. If you need any further tweaks, additions, or even help with other creative ideas, I'm always here. Have fun building history into your 3D world!