dakingofbots

Spawner Civilization (SC)

Part 1 – Core Gameplay & Civilization System

1. Overview

Create a complete PaperMC 26.2 plugin named Spawner Civilization (SC).

This plugin introduces multiple playable Civilizations (Cyvs).

Players choose one Civilization when joining for the first time and progress by completing quests, visiting Temples, unlocking powers and eventually rebirthing into new Civilizations.

The plugin must support multiplayer and be fully configurable.

Do not generate custom worlds.

Instead, every Civilization is assigned to an existing Minecraft world through config.yml.

Example:

yaml
worlds:
  path: path

  bee: bee_world
  villager: villager_world
  blaze: blaze_world
  hell: hell_world

The plugin should simply load these worlds.

---

2. Civilization Worlds

Each Civilization exists inside its own world.

Required Civilizations:

* Barn * Iron Golem * Copper Golem * Mooshroom * Villager * Illager * Bee * Deep Dark * Lush * Fox * End (Endermen, Shulkers and Dragon) * Phantom * Blaze * Slime * Frog * Dolphin * Hell * Wither Skeleton * Zombies & Skeletons * Spiders & Cave Spiders * Witch, Bogged & Cat * Wolf * Husk & Parched * Nautilus, Drowned & Zombie Nautilus * Forgotten Civilization

Some Civilizations contain multiple playable mobs.

Each playable mob has its own:

* progression * Temple * abilities * buffs * debuffs

even when sharing the same world.

---

3. Starting the Game

The first time a player joins the server:

Open the Civilization Selection INVENTORY GUI immediately.

The player cannot close this INVENTORY GUI.

The player must choose one Base Civilization.

After choosing:

* save the Base Civilization * initialize player progression * teleport the player to the configured world spawn of that Civilization

This selection remains until the player rebirths.

---

4. Civilization Progression

Each player stores independent progression for every Civilization.

Progress includes:

* Civilization Level * Temple Completion * Reputation * Active Quest * Quest History * Unlock State * Temple Power * Rebirth Count

The Base Civilization can progress from Level 0–100.

Other unlocked Civilizations are initially limited to Level 10.

After obtaining Hell's Blessing, every Civilization may independently progress to Level 100.

---

5. Civilization Powers

Every playable mob has unique gameplay effects.

Effects may include:

* Attribute modifiers * Potion effects * Custom abilities * Passive abilities * Active abilities * Movement changes * Scale changes using Minecraft's Scale Attribute

Every playable mob must have advantages and disadvantages.

No two mobs should feel identical.

The AI should design balanced strengths and weaknesses.

---

6. Civilization Levels

Every playable mob has a Level Tree.

Base Civilization:

Levels 0–100.

Other Civilizations:

Levels 0–10.

Hell's Blessing removes this restriction.

The AI should generate balanced progression for every level.

Level rewards may include:

* passive bonuses * active abilities * attribute upgrades * new mechanics * unlocks

---

7. The Path

The Path is a configurable world connecting every Civilization.

Players cannot normally teleport to Civilizations.

Instead, travel happens through The Path.

The Path consists primarily of Calcite and Diorite suspended above the void.

The Path may:

* split * reconnect * branch * contain intersections

It should feel mysterious and disconnected from normal Minecraft worlds.

The Path contains:

* Entry Portals * Exit Portals * Shelters * Event locations * Domains * the Forgotten Civilization

No custom terrain generation is required.

Builders create everything manually.

---

8. Entry and Exit

Each Civilization contains one or more Entry Portals.

Entering an Entry Portal teleports the player to a random registered Entry Portal inside The Path.

Entry Portals have no effect while already inside The Path.

The Path contains Exit Portals.

Entering one teleports the player to a random unlocked Civilization.

---

9. Temples

Every playable mob has its own Temple.

Temples contain:

* Temple Door * Temple Key requirement * Power Shrine * Portable Portal Linking Point * Rebirth Shrine

The player's Base Civilization Rebirth Shrine does not function while that Civilization is the player's Base Civilization.

---

10. Temple Keys

Every Temple requires its corresponding Temple Key.

Each player may only possess one copy of each Temple Key.

Duplicate keys cannot be obtained.

Temple Keys are removed from the player's progression after Rebirth.

Temple Keys are primarily obtained from Loot Vaults.

The Loot Vault system guarantees every Temple Key through a configurable pity system.

Keys are intentionally distributed across different Civilizations.

The AI must ensure there are no impossible progression loops.

---

11. Civilization Powers

Completing a Temple grants that mob's Temple Power.

The player's Base Civilization receives the full version.

Secondary Civilizations grant significantly weaker versions.

Temple Powers remain active according to the progression rules defined later in this specification.

---

12. Rebirth

Every Temple contains a Rebirth Shrine.

Interacting with it allows the player to rebirth as that playable mob.

Rebirthing:

* changes the player's Base Civilization * resets Base Civilization progression * resets inventory * resets Loot Vault progress * removes Temple Keys * preserves unlocked Civilizations * preserves reputation * preserves completed quests where applicable * preserves player statistics * preserves achievements * preserves cosmetics

Some playable mobs require unlock conditions before they may be selected.

Examples include:

* Ender Dragon * Warden * Elder Guardian * Wither

The AI should design appropriate unlock requirements.

---

13. Domains

Players unlock a personal Domain after reaching Level 10 in any three Civilizations.

Each Domain is generated from an NBT structure.

Domains are placed inside The Path.

Requirements:

* at least 100 blocks away from every other Domain * do not generate if blocks already occupy the target area * generate only once * one Domain per player

Domains are themed after the player's current Base Civilization.

Players may teleport to their Domain using a command.

If the player rebirths into another Civilization:

The previous Domain becomes locked.

Returning to that Civilization through Rebirth unlocks it again.

Players may freely build inside unlocked Domains.

This is just part one. Some things might not make sense yet, so wait for the remaining parts to add the stuff that isnt talked about in its own part here.

Kodari AI
KodariJul 18 at 10:28 pm 1

I’ll create the Spawner Civilization (SC) plugin — a comprehensive PaperMC plugin with civilization selection, progression, temples, rebirth, domains, and the Path system.

SpawnerCivilization
A PaperMC civilization progression plugin where players choose a playable mob civilization, level up through unique ability trees, complete temples for powers, and rebirth into new civilizations. Features 25+ civilizations with unique abilities, the Path interconnect world, temple key progression, loot vaults with pity systems, and personal domains. Supports multiplayer with full config customization.

Let me plan the architecture:

  1. Core framework: Main plugin, config, data storage, inventory GUI system

  2. Civilization system: Civilization types, playable mobs, abilities, levels

  3. Player progression: Player data, levels, quests, temple completion

  4. World systems: World loading, Path management, portal linking

  5. Temple system: Temples, keys, shrines, rebirth

  6. Domain system: Personal domains, NBT structures

  7. Listeners & GUIs: Join handling, portal events, interaction handling

Let me start building

I’ll build the Spawner Civilization plugin from scratch. Let me create the complete project structure

The directory is empty. I’ll create all files directly using <create> tags. Let me build the complete Spawner Civilization plugin.

A comprehensive PaperMC civilization plugin where players choose a playable mob civilization, progress through levels 0-100, unlock unique abilities, complete temples, and rebirth into new civilizations. Features include a path network connecting civilization worlds, temple keys, loot vaults, personal domains, and a complete progression system with balanced strengths and weaknesses for each playable mob.

Let me start creating all files in dependency order

The filesystem is read-only for bash, but <create> tags should handle directory creation. Let me build everything now.

A complete PaperMC plugin introducing multiple playable Civilizations (Cyvs) where players choose a Civilization, progress through levels 0-100, complete Temples for powers, and rebirth into new Civilizations. Features include The Path connecting worlds, Temple Keys with pity system, personal Domains, custom abilities, and unique gameplay for each of 25+ playable mobs across 24 Civilization worlds.

Starting with build system and core files:

The <create> tag handles file creation. Let me build the entire plugin now.

A PaperMC 1.20+ plugin that introduces multiple playable Civilizations (Cyvs) with unique abilities, progression systems, temples, and rebirth mechanics. Players choose a Civilization on first join, progress through levels 0-100, complete temple challenges, unlock powers, and navigate The Path between worlds. Features include a Loot Vault pity system, personal Domains, and balanced Civilization powers with no two mobs feeling identical.&lt;/project_descriptionThe `
dakingofbots

Spawner Civilization (SC)

Part 2 – Progression, Quests & NPC System

---

14. Civilization Progression

Players progress by earning Civilization XP.

Vanilla Experience Levels must never affect Civilization progression.

Each Civilization stores its own XP and Level independently.

The player's Base Civilization can progress from Level 0–100.

All other unlocked Civilizations are initially limited to Level 10.

After obtaining Hell's Blessing, every unlocked Civilization may independently progress to Level 100.

The AI should generate balanced XP requirements and progression curves.

---

15. Quest Book

Every player receives a permanent Quest Book.

The Quest Book is the primary interface for progression.

Players who lose it may recover it using:

text
/questbook

The Quest Book should display:

* Base Civilization * Civilization Levels * Civilization XP * Active Quest * Quest Progress * Quest History * Reputation * Temple Completion * Temple Keys obtained * Portable Portal links * Domain status * Hell progression * Hell's Blessing * Titles * Statistics

The Quest Book itself should not permanently store any progression data.

It only displays information stored by the plugin.

---

16. Quest System

Every Civilization has its own complete quest line.

Generate at least 100 quests for every playable mob.

The quests should gradually become more difficult as Civilization Level increases.

Quest objectives may include:

* killing specific mobs * collecting items * mining blocks * farming * fishing * crafting * smelting * exploring locations * entering structures * opening Loot Vaults * defeating bosses * surviving events * interacting with NPCs * delivering items * using custom mechanics * completing multi-stage objectives

The AI may create additional quest types where appropriate.

Quest rewards may include:

* Civilization XP * Reputation * Money (optional) * Loot Vaults * Temple Keys * Custom Items * Relics * Cosmetics * Titles * Recipes

---

17. Quest Assignment

Each Civilization has its own pool of quests.

When a player enters a Civilization:

* teleport them to that world's spawn * randomly select one unfinished quest from that Civilization * assign it to the player

Completed quests should never be selected again unless configured.

Quest selection should remain random while avoiding excessive repetition.

---

18. NPC System

The plugin must implement its own NPC system.

Do not depend on Citizens or any external NPC plugin.

NPCs are spawned using custom spawn eggs and automatically saved by the plugin.

Every NPC should support:

* custom name * skin * profession * dialogue * quest interaction * merchant inventories * requirements * rewards * animations (where possible) * particles * sounds

NPCs should survive server restarts.

---

19. NPC Dialogue

Dialogue should support:

* multiple pages * branching conversations * conditional dialogue * PlaceholderAPI placeholders (optional) * MiniMessage formatting * clickable dialogue choices * configurable sounds

Dialogue should change depending on player progression.

---

20. NPC Requirements

Talking to an NPC may require:

* completing another quest * speaking to another NPC first * minimum Civilization Level * minimum Reputation * owning specific items * owning specific Relics * Temple completion * unlocking a Civilization * possessing Hell's Blessing * configurable permissions

The AI may generate additional requirement types.

---

21. NPC Rewards

NPCs may reward:

* Civilization XP * Reputation * Items * Loot Vaults * Temple Keys * Custom Recipes * Titles * Cosmetics * Currency * New dialogue * New quest chains

Some quests should end immediately after speaking to a specific NPC.

---

22. Civilization Storylines

Every Civilization must contain at least one NPC-driven story quest.

These story quests should introduce the Civilization and its lore.

They may unlock additional quest chains or rewards.

The AI should generate unique stories for every Civilization.

---

23. Reputation

Each Civilization stores its own independent Reputation value.

Reputation changes through:

* quests * NPC interactions * bosses * events * helping NPCs * optional configurable actions

Reputation may unlock:

* merchants * discounts * dialogue * titles * cosmetics * hidden quests * rare rewards

---

24. Merchants

Every Civilization should contain one or more merchants.

Merchants use the NPC system.

Trades should depend on:

* Reputation * Civilization Level * completed quests * unlocked Temple * configurable requirements

Merchants should sell Civilization-specific items whenever possible.

---

25. Builder Blocks

The plugin should provide builder blocks for map creation.

Builder blocks disappear immediately after being placed.

Instead of remaining as blocks, they register their location internally.

Examples include:

* NPC Spawn Marker * Merchant Spawn Marker * Boss Spawn Marker * Loot Vault * Entry Portal * Exit Portal * Temple Linking Point * Event Marker * Structure Marker * Domain Marker * Caravan Marker

Builders should never need to manually enter coordinates when a builder block can be be used.

---

26. NBT Structure System

The plugin must support loading NBT structures from configurable folders.

Example:

text
plugins/SpawnerCivilization/structures/

Suggested folders:

text
events/
domains/
caravans/
forgotten/
bosses/
dungeons/

Structures should automatically register when the plugin loads.

Administrators should be able to add new structures without recompiling the plugin.

---

27. Structure Placement

Structures spawn relative to Builder Blocks.

When spawning a structure:

  1. Select a valid Builder Block.
  2. Verify there is enough space.
  3. Ensure existing builds will not be overwritten.
  4. Spawn the NBT structure.
  5. Spawn any associated NPCs or entities.

If the selected location is invalid, another valid Builder Block should be chosen automatically.

---

28. Personal Domains

Players unlock a personal Domain after reaching Level 10 in any three Civilizations.

Domains are generated from configurable NBT structures.

Requirements:

* one Domain per player * generated inside The Path * minimum distance of 100 blocks from other Domains * generation fails if blocks already occupy the area * retry until a valid location is found

Domains are themed after the player's current Base Civilization.

Players may teleport to their Domain using a command.

If the player rebirths into another Base Civilization, the previous Domain becomes locked.

Rebirthing back into that Civilization unlocks the Domain again.

Players may freely build, store items and create farms inside unlocked Domains.

---

29. Multiplayer Requirements

All progression must be tracked independently for every player.

This includes:

* Civilization Levels * Civilization XP * Reputation * Active Quests * Quest History * Temple Completion * Temple Keys * Portable Portal links * Domains * Hell Progress * Hell's Blessing * Titles * Statistics

No player should ever affect another player's progression unless explicitly intended by a mechanic.

---

30. Quest Administration Commands

Include commands for testing and debugging quests.

Minimum commands:

text
/sc quest reset <player> <civilization>

Resets the specified Civilization's active quest and progress.

text
/sc quest resetall <player>

Resets every Civilization quest.

text
/sc quest complete <player>

Immediately completes the player's active quest.

text
/sc quest start <player> <quest_id>

Starts the specified quest.

text
/sc quest skip <player>

Skips the current quest and assigns another valid one.

text
/sc quest reload

Reloads all quest definitions without restarting the server.

The AI may implement additional quest administration commands if they improve testing or balancing.

This isnt the last part yet. Some things are still yet to make sense. Make sure you add what does make sense now that didn't in the first part.

Kodari AI
KodariJul 18 at 10:31 pm 1

Now I have the full picture from Parts 1 and 2. Let me build the complete Spawner Civilization plugin. I’ll start with the build system, then core, then all systems.

Now let me create the core source files. Starting with the main plugin class and core systems:

Now let me create the Civilization system - the core data structures:

[Generation stopped]

dakingofbots

Finish part 2

Kodari AI
KodariJul 18 at 10:36 pm 1

Let me build the entire plugin. I’ll create all files in a logical order, starting with build config, then core, then each system

Good, I have the existing files. Let me build the entire plugin systematically. Starting with the build config, then core, then each system.

Now let me update plugin.yml with more commands and create every source file. I’ll work through each system

Now I’ll create every source file. Starting with the main plugin class and core systems

[Generation stopped]

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
Code
39 3,210
src/main/java/com/spawnercivilization/SpawnerCivilization.java
package com.spawnercivilization;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.spawnercivilization.builder.BuilderBlockManager;
import com.spawnercivilization.civilization.CivilizationRegistry;
import com.spawnercivilization.command.CivilizationCommand;
import com.spawnercivilization.command.DomainCommand;
import com.spawnercivilization.command.QuestBookCommand;
import com.spawnercivilization.command.SpawnerCivCommand;
import com.spawnercivilization.config.ConfigManager;
import com.spawnercivilization.config.Messages;
import com.spawnercivilization.domain.DomainManager;
import com.spawnercivilization.listener.*;
import com.spawnercivilization.npc.NPCManager;
import com.spawnercivilization.player.PlayerDataManager;
import com.spawnercivilization.quest.QuestManager;
import com.spawnercivilization.structure.StructureManager;
import lombok.Getter;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;

@Getter
public final class SpawnerCivilization extends JavaPlugin {

    private static SpawnerCivilization instance;
    private ConfigManager configManager;
    private Messages messages;
    private PlayerDataManager playerDataManager;
    private CivilizationRegistry civilizationRegistry;
    private QuestManager questManager;
    private NPCManager npcManager;
    private BuilderBlockManager builderBlockManager;
    private StructureManager structureManager;
    private DomainManager domainManager;
    private Gson gson;

    @Override
    public void onEnable() {
        instance = this;

        this.gson = new GsonBuilder()
                .setPrettyPrinting()
                .enableComplexMapKeySerialization()
                .create();

        saveDefaultConfig();
        saveResource("messages.yml", false);

        this.configManager = new ConfigManager(this);
        this.messages = new Messages(this);
        this.civilizationRegistry = new CivilizationRegistry(this);
        this.playerDataManager = new PlayerDataManager(this);
        this.questManager = new QuestManager(this);
        this.npcManager = new NPCManager(this);
        this.builderBlockManager = new BuilderBlockManager(this);
        this.structureManager = new StructureManager(this);
        this.domainManager = new DomainManager(this);

        civilizationRegistry.load();
        questManager.loadQuests();
        builderBlockManager.registerBuilderBlocks();
        structureManager.loadStructures();
        npcManager.loadNPCs();
        playerDataManager.loadAll();

        registerCommands();
        registerListeners();

        getLogger().info("SpawnerCivilization v" + getDescription().getVersion() + " enabled!");
    }

    @Override
    public void onDisable() {
        if (npcManager != null) npcManager.saveNPCs();
        if (playerDataManager != null) playerDataManager.saveAll();
        if (builderBlockManager != null) builderBlockManager.cleanup();
        getLogger().info("SpawnerCivilization disabled.");
    }

    private void registerCommands() {
        getCommand("questbook").setExecutor(new QuestBookCommand(this));
        getCommand("sc").setExecutor(new SpawnerCivCommand(this));
        getCommand("domain").setExecutor(new DomainCommand(this));
        getCommand("civ").setExecutor(new CivilizationCommand(this));
    }

    private void registerListeners() {
        getServer().getPluginManager().registerEvents(new PlayerJoinListener(this), this);
        getServer().getPluginManager().registerEvents(new PlayerQuitListener(this), this);
        getServer().getPluginManager().registerEvents(new BlockPlaceListener(this), this);
        getServer().getPluginManager().registerEvents(new BlockBreakListener(this), this);
        getServer().getPluginManager().registerEvents(new InteractionListener(this), this);
        getServer().getPluginManager().registerEvents(new EntityListener(this), this);
        getServer().getPluginManager().registerEvents(new InventoryListener(this), this);
        getServer().getPluginManager().registerEvents(new PortalListener(this), this);
        getServer().getPluginManager().registerEvents(new QuestListener(this), this);
    }

    public static SpawnerCivilization getInstance() {
        return instance;
    }

    public File getDataFolder() {
        return super.getDataFolder();
    }
}