Fog
πŸ“Ž 1 file 8,691 chars
πŸ“„
pasted-code-1790459134966.txt
txt 456 lines
β–Ά
Create a complete Minecraft plugin/system that allows players to use AI to generate, manage, edit, copy, paste, undo, delete, and teleport to structures directly inside a Minecraft world.

The main goal is to make an easy-to-use AI building system where a player can type a command such as:

`/aibuild    `

Example:

`/aibuild 100 64 200 medieval castle with towers, walls, a gate, and a courtyard`

The AI should understand the natural-language prompt and generate the requested structure at the specified coordinates.

━━━━━━━━━━━━━━━━━━━━━━
CORE AI BUILDING
━━━━━━━━━━━━━━━━━━━━━━

Add:

`/aibuild    `

The AI should:

* Understand natural-language building requests.
* Generate an actual Minecraft structure.
* Place the correct blocks in the world.
* Respect the requested style, size, materials, shape, and purpose.
* Automatically determine appropriate dimensions when the player doesn't specify them.
* Avoid generating structures outside the selected build area.
* Avoid destroying existing builds unless explicitly instructed.
* Generate buildings with detail rather than simple boxes.
* Add appropriate decorations, roofs, windows, doors, paths, interiors, lighting, etc. when requested.
* Support large structures while breaking the generation into safe stages so the server doesn't freeze.

Examples:

`/aibuild 0 70 0 futuristic skyscraper`

`/aibuild 100 64 100 medieval village`

`/aibuild 200 70 300 giant wizard tower with a magical interior`

`/aibuild 500 64 500 Japanese temple surrounded by a garden`

`/aibuild 0 100 0 floating island with a castle`

━━━━━━━━━━━━━━━━━━━━━━
BUILD NAMES
━━━━━━━━━━━━━━━━━━━━━━

Every generated build should automatically receive a unique name.

Allow:

`/aibuild     `

Example:

`/aibuild 100 64 100 Castle "large medieval stone castle"`

The build should then be registered as:

Castle

Players should be able to manage builds by name.

━━━━━━━━━━━━━━━━━━━━━━
BUILD MANAGEMENT
━━━━━━━━━━━━━━━━━━━━━━

Add:

`/aibuild list`

Shows all builds the player has created.

`/aibuild info `

Shows:

* Build name
* Creator
* Creation date
* Coordinates
* Dimensions
* Number of blocks
* Current status
* Materials used
* Build history/version
* Location

Add:

`/del `

Example:

`/del Castle`

This should completely remove that registered build and restore the blocks that existed before the build was created whenever possible.

Deletion must require confirmation for large or important builds:

`/del Castle`

Then:

`Are you sure? Use /del confirm Castle`

Also add:

`/aibuild delete `

━━━━━━━━━━━━━━━━━━━━━━
UNDO / REDO
━━━━━━━━━━━━━━━━━━━━━━

Every AI-generated build must be reversible.

Add:

`/aibuild undo`

Undo the most recent AI build/edit.

`/aibuild redo`

Redo the last undone action.

Also support:

`/aibuild undo `

Restore the area to the state it was in before that build was created.

The plugin should save the original blocks before modifying an area so builds can be safely undone.

For large builds, use efficient storage so the server doesn't run out of memory.

━━━━━━━━━━━━━━━━━━━━━━
COPY / PASTE
━━━━━━━━━━━━━━━━━━━━━━

Allow players to copy AI-generated structures.

`/aibuild copy `

Copies the structure into the player's clipboard.

`/aibuild paste`

Pastes the copied structure at the player's current location.

Also allow:

`/aibuild paste   `

Allow rotation:

`/aibuild rotate 90`

`/aibuild rotate 180`

`/aibuild rotate 270`

Allow flipping:

`/aibuild flip x`

`/aibuild flip z`

Copied structures should preserve:

* Blocks
* Block states
* Doors
* Trapdoors
* Signs
* Chests where possible
* Decorations
* Orientation
* Containers where appropriate

━━━━━━━━━━━━━━━━━━━━━━
EDIT EXISTING BUILDS WITH AI
━━━━━━━━━━━━━━━━━━━━━━

This is extremely important.

Allow:

`/aiedit  `

Example:

`/aiedit Castle add two towers to the front`

`/aiedit Castle make the walls taller`

`/aiedit Castle add an underground dungeon`

`/aiedit Castle replace the stone with dark stone`

`/aiedit Castle make the roof red`

`/aiedit Castle add more detail to the interior`

The AI should modify the existing structure instead of creating a completely separate structure.

Before editing, automatically create a version/backup.

━━━━━━━━━━━━━━━━━━━━━━
BUILD VERSIONS
━━━━━━━━━━━━━━━━━━━━━━

Every AI edit should create a version.

Example:

Castle

* Version 1: Original
* Version 2: Added towers
* Version 3: Added dungeon
* Version 4: Changed roof

Commands:

`/aibuild versions `

`/aibuild rollback  `

Example:

`/aibuild rollback Castle 2`

This restores Castle to version 2.

━━━━━━━━━━━━━━━━━━━━━━
TELEPORT SYSTEM
━━━━━━━━━━━━━━━━━━━━━━

Create a build menu where players can see every build.

Command:

`/aibuild menu`

The menu should be a polished Minecraft GUI.

Each build should appear as an item.

For example:

🏰 Castle
πŸ‘€ Creator: Player
πŸ“ Location: 100, 64, 200
πŸ“¦ Blocks: 15,423
πŸ• Created: Today

Clicking a build should open options:

[Teleport]
[Info]
[Edit]
[Copy]
[Delete]
[Versions]
[Set Favorite]

Teleport command:

`/aibuild tp `

The player should teleport to a safe location near the structure.

━━━━━━━━━━━━━━━━━━━━━━
BUILD BROWSER
━━━━━━━━━━━━━━━━━━━━━━

The GUI should support:

* Search
* Sorting
* Pagination
* Favorites
* Recently created
* Recently edited
* My builds
* Public builds
* Large builds
* Small builds

Example:

`/aibuild menu`

Could display:

╔════════════════════════════╗
β•‘       AI BUILD MANAGER     β•‘
╠════════════════════════════╣
β•‘ 🏰 Castle                  β•‘
β•‘ 🏯 Japanese Temple         β•‘
β•‘ 🏠 Starter House           β•‘
β•‘ πŸ—Ό Wizard Tower             β•‘
β•‘ 🌳 Fantasy Village         β•‘
β•šβ•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•β•

━━━━━━━━━━━━━━━━━━━━━━
BUILD SELECTION / BOUNDARIES
━━━━━━━━━━━━━━━━━━━━━━

Allow players to specify a build region.

Example:

`/aibuild select`

Let players select two corners using a wand/tool.

Then:

`/aibuild `

The AI must build inside the selected region.

Also allow:

`/aibuild resize `

and:

`/aibuild expand  20`

This is useful for controlling how large AI-generated structures can become.

━━━━━━━━━━━━━━━━━━━━━━
AI BUILD PREVIEW
━━━━━━━━━━━━━━━━━━━━━━

Before actually placing a large build, allow:

`/aibuild preview `

The AI generates a plan/preview first.

Show:

Name:
Medieval Castle

Size:
75 Γ— 50 Γ— 65

Estimated blocks:
~18,000

Materials:
Stone
Cobblestone
Spruce
Dark Oak

Then allow:

[Build]
[Cancel]

For large structures, always provide a confirmation before placing thousands of blocks.

━━━━━━━━━━━━━━━━━━━━━━
BUILD PROTECTION
━━━━━━━━━━━━━━━━━━━━━━

Every registered build should have a protected region.

Players should be able to configure:

* Who can edit it
* Who can delete it
* Who can teleport to it
* Whether other players can modify it

Commands:

`/aibuild trust  `

`/aibuild untrust  `

`/aibuild public `

`/aibuild private `

━━━━━━━━━━━━━━━━━━━━━━
AI BUILD QUEUE
━━━━━━━━━━━━━━━━━━━━━━

Large AI builds should use a queue.

Example:

`Build queued...`

`Position: #2`

`Estimated blocks: 25,000`

`Generating... 34%`

`Placing blocks... 71%`

`Build complete!`

Do NOT freeze the Minecraft server while generating or placing large structures.

Use asynchronous processing wherever possible, while ensuring actual Bukkit/Spigot/Paper world modifications are performed safely on the main server thread when required.

━━━━━━━━━━━━━━━━━━━━━━
PROGRESS DISPLAY
━━━━━━━━━━━━━━━━━━━━━━

Show progress in chat and optionally a boss bar.

Example:

`AI Building: Medieval Castle`

`β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‘β–‘β–‘β–‘ 76%`

Also show:

* Current operation
* Blocks placed
* Estimated remaining time
* AI generation status

━━━━━━━━━━━━━━━━━━━━━━
MATERIAL SYSTEM
━━━━━━━━━━━━━━━━━━━━━━

Allow prompts to specify materials.

Examples:

`/aibuild 0 64 0 stone castle using dark oak roofs`

`/aibuild 0 64 0 futuristic house using quartz and cyan glass`

The AI should select appropriate Minecraft blocks while respecting the user's requested materials.

━━━━━━━━━━━━━━━━━━━━━━
NATURAL LANGUAGE COMMANDS
━━━━━━━━━━━━━━━━━━━━━━

Make the
Kodari AI
KodariSep 26 at 9:49 pm 2
AIBuildManager
A comprehensive Minecraft plugin that generates structures from natural-language prompts via AI. Players use /aibuild with coordinates and a description to create detailed builds with automatic naming, versioning, and undo/redo support. Features include copy/paste with rotation and flipping, AI editing of existing builds, teleportation, a searchable GUI menu with favorites and pagination, build protection with trust systems, region selection, preview confirmation, and an asynchronous queue with progress bars to prevent server lag. All builds are reversible and safely stored.
  1. Create a Paper plugin skeleton with configurable AI access and persistent build metadata.

  2. Add asynchronous AI planning and tick-batched, guarded block placement.

  3. Implement build listing/info, editing, undo/redo, copy/paste, teleport, versions, trust, and deletion commands, plus a basic build menu.

Created a Paper 1.21.4 plugin project with AI-generated structures, gzip-persisted build data, batched block placement, edit versions, undo/redo, rollback, copy/paste with rotation and flipping, teleporting, a basic build menu, trust/public settings, and protection against player breaking/placing and explosion damage in registered regions.

To enable generation, set ai.api-key and the compatible chat-completions ai.endpoint in config.yml. Main commands include /aibuild <x> <y> <z> [Name] <prompt>, /aiedit <build> <prompt>, /aibuild list|info|menu|undo|redo|copy|paste, and /del <build>.

This implements the core workflow, but not every item in the specification: region selection, preview/confirmation, browser search and filters, and full sign/container data preservation are not included. The attached specification also ends mid-sentence at β€œMake the”.

Fog

make it so that you build it not something like chatgpt which requires money for the api make it a ENTIRELY free plug in

Kodari AI
KodariSep 27 at 1:46 pm 2
  1. Replace the paid remote API call with an offline, deterministic structure generator.

  2. Keep generation asynchronous and preserve block states when editing or pasting.

  3. Remove API-key configuration and update command/startup messaging to explain no external AI service is needed.

Removed the paid API dependency. Structure generation and editing now run locally, asynchronously, with no API key, internet connection, or external AI service required. The offline generator recognizes common structure types, materials, and dimensions; it also supports a limited set of edits such as material replacement, roof changes, adding towers, and adding details.

This is a free procedural generator, not a local LLM: it interprets prompts using built-in templates and rules, so it won’t understand arbitrary requests as flexibly as ChatGPT. Updates also preserve block states when editing and copying builds.

Fog

use the images i have put as refernece for what they should look like

--- πŸ“Ž Attached 1 file(s):

File: pasted-code-1790784593917.txt

txt
Create this build as if you are a PROFESSIONAL Minecraft builder who specializes in extremely detailed survival builds and architectural builds.

IMPORTANT BUILDING RULES:

Do NOT create a basic Minecraft box.
Do NOT create large flat walls.
Do NOT create repetitive patterns.
Do NOT make the exterior detailed while leaving the interior empty.
Do NOT randomly place decorative blocks just to add detail.
Do NOT ignore any part of the requested design.
Do NOT simplify the build into a small version of the concept.

The finished build should look like something made by an experienced professional Minecraft builder, with intentional architecture, strong composition, believable construction, excellent depth, detailed interiors, realistic texturing, and many small details that reward looking closely.

━━━━━━━━━━━━━━━━━━━━━━
1. FOLLOW THE PROMPT
━━━━━━━━━━━━━━━━━━━━━━

Treat every instruction in this prompt as an actual construction requirement.

Before building, mentally organize the design into:
- Overall silhouette
- Foundation
- Main structural frame
- Individual sections and wings
- Floors
- Roofs
- Rooms
- Interior layout
- Windows
- Doors
- Exterior details
- Landscaping
- Lighting
- Texturing

Do not omit important requested features.

If there is enough space, expand important features instead of compressing them.

The structure should have logical proportions and enough room for its interior to function properly.

━━━━━━━━━━━━━━━━━━━━━━
2. ARCHITECTURAL DESIGN
━━━━━━━━━━━━━━━━━━━━━━

Create a strong silhouette that looks interesting from a distance.

Use:
- Different building heights
- Protruding sections
- Recessed sections
- Towers or extensions when appropriate
- Balconies
- Overhangs
- Arches
- Columns
- Buttresses
- Roof variations
- Dormers
- Covered entrances
- Side extensions
- Structural beams

Avoid making the entire structure one rectangle.

Create multiple connected architectural masses.

Some parts should extend outward while others should be recessed.

Use depth aggressively.

Walls should generally have several layers of depth rather than being a flat wall.

For example:

foundation β†’ wall β†’ structural beam β†’ window frame β†’ window β†’ roof overhang

rather than:

wall β†’ window β†’ roof

━━━━━━━━━━━━━━━━━━━━━━
3. DEPTH
━━━━━━━━━━━━━━━━━━━━━━

DEPTH IS EXTREMELY IMPORTANT.

Every major exterior wall should have architectural depth.

Use:
- Stairs
- Slabs
- Walls
- Fences
- Trapdoors
- Logs
- Pillars
- Beams
- Window frames
- Shutters
- Balconies
- Overhangs
- Recessed windows
- Protruding sections

Create shadows and highlights naturally through the geometry.

Windows should NOT simply be glass placed into a flat wall.

Build proper window frames around them.

Doors should have entrances, frames, porches, arches, or other architectural treatment.

Corners should have structural elements.

Roofs should have visible supporting structures.

━━━━━━━━━━━━━━━━━━━━━━
4. PROFESSIONAL TEXTURING
━━━━━━━━━━━━━━━━━━━━━━

Do not use one block for an entire material.

Use a controlled palette.

For stone, use combinations such as:
- Stone Bricks
- Cracked Stone Bricks
- Mossy Stone Bricks
- Cobblestone
- Mossy Cobblestone
- Polished Andesite
- Stone
- Stone Stairs
- Stone Slabs
- Stone Walls

For wood, combine:
- Dark Oak
- Spruce
- Stripped Logs
- Logs
- Planks
- Stairs
- Slabs
- Trapdoors
- Fences

Texturing must look intentional.

Do NOT randomly scatter blocks everywhere.

Use different materials according to architectural purpose.

Use more weathered materials near:
- Ground level
- Foundations
- Corners
- Water
- Exterior stone
- Older sections

Use cleaner materials on:
- Main walls
- Decorative structures
- Interior areas

Make the build feel naturally aged and constructed.

━━━━━━━━━━━━━━━━━━━━━━
5. INTERIOR DESIGN
━━━━━━━━━━━━━━━━━━━━━━

THE INTERIOR MUST BE FULLY BUILT.

Do not create an impressive exterior with an empty shell.

Create actual rooms with walls, ceilings, floors, furniture, lighting and decorations.

Plan the interior before placing the rooms.

Include appropriate rooms such as:

- Entrance hall
- Living room
- Kitchen
- Dining room
- Storage room
- Library
- Study
- Bedrooms
- Bathrooms when appropriate
- Armory
- Workshop
- Basement
- Secret room when appropriate
- Hallways
- Staircases
- Balconies

Every room should have a PURPOSE.

Rooms should not be giant empty spaces.

━━━━━━━━━━━━━━━━━━━━━━
6. ROOM DETAIL
━━━━━━━━━━━━━━━━━━━━━━

Every room should contain multiple layers of detail.

Use:
- Tables
- Chairs
- Shelves
- Bookshelves
- Cabinets
- Chests
- Barrels
- Beds
- Carpets
- Plants
- Paintings
- Banners
- Lanterns
- Candles
- Trapdoors
- Signs
- Item frames where appropriate
- Decorative blocks
- Functional Minecraft blocks disguised as furniture

Make furniture look intentional.

For example, don't simply put a chest in the middle of a room.

Create a storage cabinet using multiple blocks.

Don't simply put a crafting table against a wall.

Build a complete workstation around it.

Don't simply place a bed in an empty room.

Create a complete bedroom with side tables, decorations, lighting, storage and architectural details.

━━━━━━━━━━━━━━━━━━━━━━
7. CEILINGS AND FLOORS
━━━━━━━━━━━━━━━━━━━━━━

Do not ignore ceilings.

Create detailed ceilings using:
- Beams
- Slabs
- Stairs
- Logs
- Decorative supports
- Hanging lights

Create different floor patterns for different rooms.

Use materials that fit the room.

Important rooms should have more impressive flooring.

━━━━━━━━━━━━━━━━━━━━━━
8. STAIRCASES
━━━━━━━━━━━━━━━━━━━━━━

Create real staircases connecting the floors.

Do not use random blocks as stairs.

Make staircases visually integrated into the architecture.

Add:
- Railings
- Beams
- Lighting
- Landings
- Decorative supports

━━━━━━━━━━━━━━━━━━━━━━
9. LIGHTING
━━━━━━━━━━━━━━━━━━━━━━

Lighting should be both functional and decorative.

Use:
- Lanterns
- Soul Lanterns when appropriate
- Candles
- Campfires
- Hidden lighting

Hide some lighting inside ceilings, floors, walls and architectural elements.

Avoid placing torches randomly everywhere.

Lighting should contribute to the atmosphere.

━━━━━━━━━━━━━━━━━━━━━━
10. ROOF DESIGN
━━━━━━━━━━━━━━━━━━━━━━

Roofs should be one of the most detailed parts of the build.

Avoid a simple flat roof.

Use:
- Multiple roof sections
- Different heights
- Roof overhangs
- Dormers
- Gables
- Chimneys
- Roof supports
- Decorative beams
- Stairs
- Slabs

Make the roof follow the shape of the building.

Do not put one giant roof over the entire structure unless the architecture specifically requires it.

━━━━━━━━━━━━━━━━━━━━━━
11. EXTERIOR DETAILS
━━━━━━━━━━━━━━━━━━━━━━

Add small details that make the structure feel lived in.

Examples:

- Flower boxes
- Window shutters
- Hanging lanterns
- Wooden supports
- Chimneys
- Firewood
- Barrels
- Crates
- Benches
- Signs
- Banners
- Planters
- Stone piles
- Small pathways
- Fences
- Gates
- Outdoor workstations
- Wells
- Gardens
- Small sheds
- Animal areas when appropriate

These details should support the story and function of the building.

━━━━━━━━━━━━━━━━━━━━━━
12. LANDSCAPING
━━━━━━━━━━━━━━━━━━━━━━

Do not stop at the walls.

Integrate the building into its environment.

Create:
- Paths
- Grass variation
- Flowers
- Bushes
- Trees
- Rocks
- Gardens
- Small elevation changes
- Fences
- Water features
- Outdoor seating
- Decorative terrain

Avoid perfectly flat terrain around the building.

The landscaping should make the build look established rather than simply placed into the world.

━━━━━━━━━━━━━━━━━━━━━━
13. SCALE
━━━━━━━━━━━━━━━━━━━━━━

Use enough space to properly execute the design.

Do not make rooms too small just to save blocks.

Doors, windows, furniture, hallways and staircases should have believable proportions.

The exterior and interior must match.

If the exterior suggests a large building, the interior should actually contain a large and detailed layout.

━━━━━━━━━━━━━━━━━━━━━━
14. VISUAL HIERARCHY
━━━━━━━━━━━━━━━━━━━━━━

Create a clear focal point.

The main entrance should be visually important.

The largest architectural feature should be obvious.

Secondary sections should support the main structure.

Small details should enhance the design rather than overwhelm it.

The build should look good from:
- Far away
- Medium distance
- Close up
- Inside

━━━━━━━━━━━━━━━━━━━━━━
15. NATURAL IMPERFECTION
━━━━━━━━━━━━━━━━━━━━━━

Do not make everything perfectly symmetrical.

Use controlled asymmetry.

One wing can be slightly different from another.

Some windows can be different sizes.

Landscaping should not be mirrored.

However, keep the overall architecture balanced.

The build should feel designed, not randomly generated.

━━━━━━━━━━━━━━━━━━━━━━
16. BUILD QUALITY CHECK
━━━━━━━━━━━━━━━━━━━━━━

Before considering the build finished, inspect the entire structure.

Check:

1. Are the walls too flat?
2. Does the building have enough depth?
3. Are the corners detailed?
4. Are the roofs detailed?
5. Are the windows properly framed?
6. Are the rooms actually furnished?
7. Are there empty interior spaces?
8. Are the ceilings detailed?
9. Are the floors detailed?
10. Are the staircases functional?
11. Is the lighting sufficient?
12. Does the material palette make sense?
13. Is the texturing controlled?
14. Does the landscaping connect naturally to the building?
15. Does the structure look good from all sides?
16. Are there areas that look unfinished?
17. Are there large empty walls?
18. Are there unnecessary repetitive patterns?
19. Does the exterior match the interior?
20. Does the finished structure look like a professional Minecraft build?

If an area looks unfinished, improve it before finishing.

If a wall looks empty, add architectural depth rather than simply placing random decorations.

If a room is empty, furnish it.

If the build lacks depth, modify the structure itself rather than only adding decorations.

━━━━━━━━━━━━━━━━━━━━━━
FINAL GOAL
━━━━━━━━━━━━━━━━━━━━━━

The final result should look like a Minecraft build created by a professional builder for a showcase, cinematic video, or high-quality survival server.

Prioritize:

ARCHITECTURE
DEPTH
DETAIL
INTERIOR DESIGN
TEXTURING
ROOM LAYOUT
PROPORTIONS
MATERIAL VARIATION
LIGHTING
LANDSCAPING
FUNCTIONALITY
BELIEVABILITY
QUALITY

Do not rush the build.

Do not simplify the design unnecessarily.

Do not stop after creating the basic structure.

Build the entire concept from foundation to interior to landscaping and finish every area to a professional standard.
3 images attached
Kodari AI
KodariSep 30 at 4:17 pm 2

Plan:

  1. Add dedicated offline templates for the reference castle, modern mansion, and industrial/steampunk factory.

  2. Give them layered exteriors, multiple floors, furnished interiors, roofs, lighting, and landscaping within configured size/block limits.

  3. Route natural-language prompts and generated names to the new templates.

Added offline templates inspired by your references: a fortified castle, a modern mansion with a pool, and a steampunk/industrial factory. They include layered exteriors, roofs, interior furnishings, lighting, and surrounding details, and are selected from prompts such as β€œcastle,” β€œmodern mansion,” or β€œsteampunk factory.”

The plugin still can’t inspect image uploads directly; these builds use procedural templates rather than interpreting the images or arbitrary instructions like a paid AI service.

Fog

use the reference images as what the builds should look like when theyre done the builds made should look better and more detailed than the images

--- πŸ“Ž Attached 1 file(s):

File: pasted-code-1790785764177.txt

txt
PROFESSIONAL MINECRAFT BUILD QUALITY CONTROL β€” VERY IMPORTANT

The most important goal is NOT size. The most important goal is QUALITY.

Build this structure as if it were designed and constructed by an experienced professional Minecraft builder by hand.

DO NOT produce a simple procedural structure.
DO NOT make basic boxes.
DO NOT make flat walls.
DO NOT use random blocks everywhere.
DO NOT spam decorative blocks.
DO NOT create repetitive patterns.
DO NOT leave unfinished sections.
DO NOT create disconnected or nonsensical structures.
DO NOT place blocks that visually clash with the surrounding architecture.
DO NOT create floating blocks, broken geometry, accidental holes, exposed interiors, disconnected roofs, impossible staircases, or malformed walls.
DO NOT prioritize speed over quality.

The final structure must look intentionally designed.

━━━━━━━━━━━━━━━━━━━━
1. BUILD LIKE A REAL MINECRAFT BUILDER
━━━━━━━━━━━━━━━━━━━━

Think about the build as an actual architectural project.

Before placing large amounts of blocks, establish:

- Overall silhouette
- Building proportions
- Main architectural shapes
- Foundation
- Floor levels
- Structural supports
- Roof structure
- Window placement
- Door placement
- Interior layout
- Material palette
- Accent materials
- Texture distribution

The structure should have a clear architectural language.

Every major shape should have a reason for existing.

Avoid random towers, random windows, random balconies, and random decorations.

The structure must look designed rather than generated.

━━━━━━━━━━━━━━━━━━━━
2. BLOCK PALETTE β€” EXTREMELY IMPORTANT
━━━━━━━━━━━━━━━━━━━━

USE A CONTROLLED BLOCK PALETTE.

Do not randomly choose blocks.

Choose a primary palette, secondary palette, accent palette, and weathering palette BEFORE constructing the structure.

For a STEAMPUNK CASTLE, use something similar to:

PRIMARY:
- Stone Bricks
- Deepslate Bricks
- Deepslate Tiles
- Polished Andesite

SECONDARY:
- Cracked Stone Bricks
- Mossy Stone Bricks
- Cobblestone
- Tuff
- Polished Blackstone

STRUCTURAL:
- Spruce Logs
- Dark Oak Logs
- Stripped Spruce
- Dark Oak Planks

METAL:
- Copper
- Exposed Copper
- Weathered Copper
- Oxidized Copper
- Iron Blocks
- Iron Bars
- Chains

ACCENTS:
- Gold
- Redstone
- Amethyst
- Orange Stained Glass
- Yellow Stained Glass
- Lanterns

Do NOT use every block equally.

Use approximately:

60–70% primary materials
15–20% secondary materials
5–10% structural materials
5–10% accent/detail materials

The exact ratio may change depending on the architecture, but the palette must remain controlled.

━━━━━━━━━━━━━━━━━━━━
3. TEXTURING IS MORE IMPORTANT THAN DECORATION
━━━━━━━━━━━━━━━━━━━━

FOCUS HEAVILY ON TEXTURING.

Large surfaces must NEVER remain completely flat and uniform.

However, do NOT solve flatness by randomly scattering blocks.

Instead, use intentional texture zones.

Example:

Foundation:
Deepslate + Deepslate Bricks + occasional Cracked Deepslate

Main walls:
Stone Bricks + Polished Andesite + small amounts of Cracked Stone Bricks

Corners:
Large stone pillars

Around windows:
Polished Andesite / Stone Brick framing

Upper walls:
Stone Bricks + darker materials

Weathered sections:
Cracked Stone Bricks + Mossy Stone Bricks

Metal sections:
Copper + Exposed Copper + Weathered Copper

Texture should follow the architecture.

Do not randomly place moss blocks in the middle of pristine walls.

Do not randomly scatter cracked blocks.

Weathering should appear in believable areas:
- Foundations
- Corners
- Lower walls
- Exposed sections
- Around drainage
- Near machinery
- Old sections of the castle

━━━━━━━━━━━━━━━━━━━━
4. CREATE REAL DEPTH
━━━━━━━━━━━━━━━━━━━━

Flat walls are NOT acceptable.

Walls should have multiple layers.

Use:

- Pillars
- Recessed sections
- Protruding sections
- Arches
- Buttresses
- Cornices
- Ledges
- Window frames
- Balconies
- Overhangs
- Support beams
- Decorative brackets
- Stone trim
- Deep entrances

A wall should visually look more like:

        ROOF
    β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
    β”‚   BEAMS      β”‚
    β”‚ β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”  β”‚
    β”‚ β”‚ WINDOW  β”‚  β”‚
    β”‚ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜  β”‚
    β”‚   β”‚     β”‚    β”‚
    β”‚  PILLARS      β”‚
    β””β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”˜
         FOUNDATION

rather than a flat rectangle.

━━━━━━━━━━━━━━━━━━━━
5. DESIGN THE SILHOUETTE
━━━━━━━━━━━━━━━━━━━━

The build must look interesting from a distance.

Use:

- Different building heights
- Towers
- Chimneys
- Rooftops
- Turrets
- Bridges
- Mechanical structures
- Large central structures
- Smaller attached structures

Create a clear hierarchy.

There should be:

MAIN FEATURE
↓
SECONDARY FEATURES
↓
SMALL DETAILS

Do not make everything equally tall or equally large.

━━━━━━━━━━━━━━━━━━━━
6. ARCHITECTURAL REPETITION
━━━━━━━━━━━━━━━━━━━━

Repetition should be controlled.

If multiple towers exist, do NOT copy-paste them perfectly.

Use a common architectural language while giving each tower slight differences.

For example:

Tower A:
Clock mechanism

Tower B:
Steam engine

Tower C:
Guard tower

Tower D:
Wizard/engineer's laboratory

They should look related but not identical.

━━━━━━━━━━━━━━━━━━━━
7. FIX GEOMETRY AND GLITCHES
━━━━━━━━━━━━━━━━━━━━

CONSTANTLY CHECK FOR BUILD ERRORS.

Fix:

- Floating blocks
- Missing blocks
- Random holes
- Walls intersecting incorrectly
- Roofs clipping through walls
- Stairs facing the wrong direction
- Random blocks sticking out
- Broken symmetry where symmetry is intended
- Unintentional symmetry where asymmetry is intended
- Windows intersecting walls
- Doors opening into solid blocks
- Stairs leading into walls
- Floors missing beneath rooms
- Roofs with gaps
- Pipes ending randomly
- Pipes passing through walls incorrectly
- Bridges that don't connect
- Unsupported-looking structures
- Random decorative blocks
- Misaligned pillars
- Incorrect block orientation
- Unfinished corners
- Strange empty spaces
- Interior/exterior geometry conflicts

IF SOMETHING LOOKS BROKEN, FIX IT.

Do not simply continue building around the problem.

━━━━━━━━━━━━━━━━━━━━
8. STRUCTURAL LOGIC
━━━━━━━━━━━━━━━━━━━━

The castle must look like it could actually exist.

Large structures need structural support.

Use:

- Pillars
- Beams
- Buttresses
- Foundations
- Arches
- Support brackets
- Load-bearing walls
- Structural frames

Large balconies should have supports.

Large roofs should have beams.

Large towers should have foundations.

Bridges should connect logically.

Pipes should connect machinery.

Do not create impossible floating architecture.

━━━━━━━━━━━━━━━━━━━━
9. ROOF DESIGN
━━━━━━━━━━━━━━━━━━━━

DO NOT USE BASIC FLAT ROOFS.

Build layered roofs.

Use:

- Roof frames
- Multiple slopes
- Dormers
- Chimneys
- Copper panels
- Support beams
- Overhangs
- Gutters
- Pipes
- Mechanical vents

Roof edges should have thickness.

Do not create roofs that look like a single layer of stairs.

━━━━━━━━━━━━━━━━━━━━
10. WINDOWS AND DOORS
━━━━━━━━━━━━━━━━━━━━

Windows must be ARCHITECTURAL FEATURES.

Do not simply put glass into walls.

Use:

- Frames
- Recesses
- Arches
- Sills
- Pillars
- Decorative trim
- Stained glass
- Iron bars

Windows should have depth.

Doors should have:

- Frames
- Steps
- Overhangs
- Decorative supports
- Lighting
- Architectural trim

━━━━━━━━━━━━━━━━━━━━
11. STEAMPUNK MACHINERY
━━━━━━━━━━━━━━━━━━━━

Machinery must look FUNCTIONAL.

Do not randomly place gears everywhere.

Every major machine should have:

INPUT
↓
MACHINE
↓
OUTPUT

For example:

BOILER
↓
COPPER PIPE
↓
PRESSURE TANK
↓
GEAR SYSTEM
↓
ENGINE
↓
EXHAUST PIPE
↓
CHIMNEY

Make machinery connect physically.

Use:

- Copper pipes
- Chains
- Pistons
- Hoppers
- Redstone
- Iron blocks
- Gears
- Anvils
- Trapdoors
- Levers
- Buttons
- Furnaces
- Minecarts
- Copper blocks

Machinery should be integrated into the architecture rather than randomly placed on walls.

━━━━━━━━━━━━━━━━━━━━
12. INTERIORS MUST MATCH THE EXTERIOR
━━━━━━━━━━━━━━━━━━━━

Do NOT make an impressive exterior with empty interiors.

Every major room should be intentionally designed.

Rooms need:

- Walls
- Floors
- Ceilings
- Lighting
- Furniture
- Decorations
- Storage
- Functional areas

The interior architecture should match the exterior architecture.

If there is a giant exterior window, there should actually be a room behind it.

If there is a tower, determine what the tower is used for.

━━━━━━━━━━━━━━━━━━━━
13. INTERIOR DETAIL
━━━━━━━━━━━━━━━━━━━━

Use layered interiors.

Instead of:

EMPTY ROOM + TABLE

Create:

ROOM
β†’ FLOOR PATTERN
β†’ WALL DETAILS
β†’ PILLARS
β†’ CEILING BEAMS
β†’ LIGHTING
β†’ FURNITURE
β†’ STORAGE
β†’ DECORATION
β†’ FUNCTIONAL DETAILS

Large rooms should have multiple visual focal points.

━━━━━━━━━━━━━━━━━━━━
14. COLOR CONTROL
━━━━━━━━━━━━━━━━━━━━

Do not create visual noise.

The castle should have a consistent identity.

For this steampunk castle:

DARK STONE
+
AGED COPPER
+
DARK WOOD
+
IRON
+
WARM LIGHTING

Use brighter colors only as accents.

Copper should gradually transition:

Copper
β†’ Exposed Copper
β†’ Weathered Copper
β†’ Oxidized Copper

This creates believable aging.

━━━━━━━━━━━━━━━━━━━━
15. DETAIL DENSITY
━━━━━━━━━━━━━━━━━━━━

Use different detail densities.

MAIN FOCAL AREAS:
Very high detail

SECONDARY AREAS:
Moderate detail

BACKGROUND AREAS:
Lower detail

Do NOT put maximum detail everywhere.

This makes important architecture stand out.

━━━━━━━━━━━━━━━━━━━━
16. NATURAL IMPERFECTION
━━━━━━━━━━━━━━━━━━━━

The build should NOT look perfectly symmetrical everywhere.

Professional Minecraft builds use controlled asymmetry.

Use:

- Slightly different tower shapes
- Different roof heights
- Different machinery
- Uneven weathering
- Different window arrangements
- Small architectural variations

But maintain overall visual balance.

━━━━━━━━━━━━━━━━━━━━
17. BUILD IN LAYERS
━━━━━━━━━━━━━━━━━━━━

Construct the structure in this order:

1. TERRAIN
2. FOUNDATION
3. MAIN SILHOUETTE
4. STRUCTURAL FRAME
5. WALLS
6. TOWERS
7. ROOFS
8. WINDOWS
9. ARCHITECTURAL DEPTH
10. TEXTURING
11. MACHINERY
12. INTERIORS
13. LIGHTING
14. SMALL DETAILS
15. LANDSCAPING
16. FINAL QUALITY CONTROL

Do not immediately cover everything with decorations.

━━━━━━━━━━━━━━━━━━━━
18. FINAL PROFESSIONAL REVIEW
━━━━━━━━━━━━━━━━━━━━

Before finishing, inspect the entire build.

Look at it from:

- Very far away
- Medium distance
- Ground level
- Inside
- Above
- Behind
- From every side

Ask:

"Does this actually look like a professional Minecraft build?"

If NO, improve it.

Specifically search for:

- Flat walls
- Bad texturing
- Random blocks
- Repetitive architecture
- Empty rooms
- Broken geometry
- Floating blocks
- Unconnected machinery
- Ugly roofs
- Bad proportions
- Missing supports
- Awkward transitions
- Empty spaces
- Clashing materials
- Glitches
- Procedural-looking patterns

FIX THESE BEFORE CONSIDERING THE BUILD COMPLETE.

QUALITY > SIZE.

DETAIL > REPETITION.

DESIGN > RANDOMNESS.

ARCHITECTURE > BLOCK SPAM.

TEXTURING > EMPTY FLAT WALLS.

FUNCTIONALITY > RANDOM DECORATION.

THE FINAL RESULT MUST LOOK LIKE A REAL MINECRAFT BUILD CREATED BY A SKILLED HUMAN BUILDER, NOT AN AI-GENERATED STRUCTURE.
3 images attached
Kodari AI
KodariSep 30 at 4:40 pm 2

Plan:

  1. Inspect how the current build templates create and place structures.

  2. Improve the matching templates to reflect the three references’ distinct shapes, palettes, and detail.

  3. Preserve the existing build limits and ensure prompt selection still reaches the right design.

Added three reference-inspired build styles:

  • Medieval castle: reinforced curtain walls, a roofed gatehouse, framed keep windows, interior stairs, and courtyard barracks and gardens.

  • Dark fantasy / gothic castle: deepslate and blackstone construction, red stained-glass windows, varied spired towers, a multi-floor furnished keep, and a dramatic entrance.

  • Pink fantasy / cherry-blossom house: connected wings, peaked pink roofs, towers, framed windows, furnished rooms, a covered porch, and cherry trees and flower beds.

Prompts like β€œcastle,” β€œdark fantasy castle,” and β€œpink fantasy house” select the matching design. The builder is still procedural and doesn’t analyze uploaded images directly; these templates use their visual styles as references.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
manifest.kod
settings.gradle
Code
17 2,234
src/main/java/com/kodari/aibuilder/AIBuilderPlugin.java
package com.kodari.aibuilder;

import com.kodari.aibuilder.command.BuildCommand;
import com.kodari.aibuilder.listener.BuildProtectionListener;
import com.kodari.aibuilder.menu.BuildMenu;
import com.kodari.aibuilder.service.AIService;
import com.kodari.aibuilder.service.BuildManager;
import org.bukkit.command.PluginCommand;
import org.bukkit.plugin.java.JavaPlugin;

public final class AIBuilderPlugin extends JavaPlugin {
    private AIService aiService;
    private BuildManager buildManager;
    private BuildMenu buildMenu;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        aiService = new AIService(this);
        buildManager = new BuildManager(this);
        buildMenu = new BuildMenu(this, buildManager);
        getServer().getPluginManager().registerEvents(buildMenu, this);
        getServer().getPluginManager().registerEvents(new BuildProtectionListener(buildManager), this);
        BuildCommand command = new BuildCommand(this);
        register("aibuild", command);
        register("aiedit", command);
        register("del", command);
        getLogger().info("KodariAIBuilder enabled. Offline structure generation is ready; no API key or internet connection is required.");
    }

    private void register(String name, BuildCommand executor) {
        PluginCommand command = getCommand(name);
        if (command != null) {
            command.setExecutor(executor);
            command.setTabCompleter(executor);
        }
    }

    public AIService getAIService() {
        return aiService;
    }

    public BuildManager getBuildManager() {
        return buildManager;
    }

    public BuildMenu getBuildMenu() {
        return buildMenu;
    }
}