A resource-pack library for Minecraft: Java Edition

<h2>Hello World</h2>
Let's create a simple and empty resource-pack using <code>creative-api</code>
and <code>creative-serializer-minecraft</code>
<pre><code class="hljs language-java">ResourcePack resourcePack = ResourcePack.resourcePack();

// Here we specify the resource-pack format (12) and description (Hello world!)
resourcePack.packMeta(12, "Hello world!");

// Then we write the resource-pack to a folder
MinecraftResourcePackWriter.minecraft()
 .writeToDirectory(new File("folder"), resourcePack);
</code></pre>
The code above writes the resource-pack to a folder named 'folder', its content
will be the following:
<pre><code class="hljs language-lua">folder/
 |------- pack.mcmeta
</code></pre>
Where <code>pack.mcmeta</code> file has the following content (but minimized):
<pre><code class="hljs language-json">{
 "pack": {
 "pack_format": 12,
 "description": "Hello world!"
 }
}
</code></pre>

Hello World

Examples

<h2>Fonts</h2>
Minecraft supports adding and modifying fonts. We can do a lot of
customization using this, such as:
<ul>
<li>Adding emojis to the Minecraft chat (And our plugin <a href="https://github.com/unnamed/creative-glyphs">creative-glyphs</a>
is an example)</li>
<li>Creating custom inventories</li>
<li>And more...!</li>
</ul>
<h3>Font Providers</h3>
Font providers are the base components of a complete font, a font
may have multiple font providers. Font providers can be: bitmap, legacy
unicode, true type, space, etc.
<h3>BitMap Font Provider</h3>
This type of font provider requires a bitmap (PNG) texture
(see <a href="/docs/creative/textures">Textures</a>), ascent (vertical offset for
the glyphs) and characters to use for this font
<pre><code class="hljs language-java">Texture texture = ...;

FontProvider provider = FontProvider.bitMap()
 .file(texture.key())
 .ascent(7)
 .characters(
 "abcdef",
 "012345",
 "6789ñá"
 )
 .build();
</code></pre>
TODO: add the other font providers
<h3>Putting all together</h3>
To finally create a <code>Font</code>, we just merge all the font
providers and assign a key
<pre><code class="hljs language-java">Font font = Font.font(
 Key.key("namespace", "my_font"),
 fontProvider1,
 fontProvider2,
 ...
);
</code></pre>
<h3>Using a font</h3>
Using Adventure, you could use:
<pre><code class="hljs language-java">Font font = MyFonts.MY_SPECIAL_FONT;

player.sendMessage(
 text()
 .content("Hello world")
 .font(font.key())
);
</code></pre>

Fonts

<h2>Getting Started</h2>
Welcome to the <code>creative</code> documentation
<code>creative</code> is a resource-pack library for vanilla Minecraft: Java
Edition, it is not dependent on the server implementation (It doesn't
matter if you use Spigot, Paper, Waterfall, BungeeCord, Velocity, etc.)
See this example of the <code>creative</code> API:
<pre><code class="hljs language-java">ResourcePack resourcePack = ResourcePack.resourcePack();
 
// Required to have a valid resource pack
resourcePack.packMeta(9, "Description!");

// adding the resource pack icon
resourcePack.icon(Writable.file(new File("my-icon.png")));

// adding a texture
resourcePack.texture(texture);

// adding a non special file
resourcePack.unknownFile("credits.txt", Writable.stringUtf8("Unnamed Team"));

// now we have a resource pack ready to be exported/written
// as a ZIP file or as a file tree (you need the 'creative-serializer-minecraft'
// dependency for this class)
MinecraftResourcePackWriter.minecraft().writeToZipFile(
 new File("my-resource-pack.zip"),
 resourcePack
);
</code></pre>
<h3>Features</h3>
<ul>
<li>Create, verify and serve resource-packs programmatically</li>
<li>Create the most compact resource-packs, everything is reduced if it is possible</li>
<li><code>creative</code> uses &#x26; supports <a href="https://github.com/KyoriPowered/adventure">Kyori's adventure</a></li>
<li>...More things are possible, you just have to discover them</li>
</ul>
See <a href="https://github.com/unnamed/hephaestus-engine">hephaestus-engine</a>, this
is an example of what can be done with creative
If you prefer to learn with examples you can see the <a href="/docs/creative/examples/hello-world">Examples section</a>

Getting Started

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.7.3")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.7.3")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.7.3")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.7.3&#x3C;/version>
&#x3C;/dependency>
</code></pre>

Installation

<h2>Language</h2>
Using a resource-pack, you can add or modify language translations.
A creative language representation is very simple, it is just a
keyed map of translations, e.g.
<pre><code class="hljs language-java">Language language = Language.language(
 Key.key("minecraft", "en_US"),
 Map.of(
 // translation key // translation
 "gui.yes", "Yes please",
 "gui.no", "No!",
 "gui.proceed", "Do it!"
 )
);
</code></pre>
Then you can add the language using <code>ResourcePack#language(Language)</code>

Language

<h2>Merging</h2>
Developers can merge two resource-packs together using the
<code>ResourcePack#merge(ResourcePack, MergeStrategy)</code> method.
<pre><code class="hljs language-java">// get our resource packs
ResourcePack base = ...;
ResourcePack other = ...;

// merge
base.merge(other, MergeStrategy.override());

// now base contains all the resources from other
</code></pre>
There are three built-in merge strategies:
<ul>
<li><code>override()</code>: overrides the resources of the base resource-pack with the resources
of the second one if there are duplicates.</li>
<li><code>mergeAndFailOnError()</code>: merges the resources of the base resource-pack with the
resources of the second one, resulting in a <code>MergeException</code> if there are duplicates that
can't be merged.</li>
<li><code>mergeAndKeepFirstOnError()</code>: merges the resources of the
base resource-pack with the resources of the second one,
keeping only the resources of the first resource-pack if there
are duplicates that can't be merged.</li>
</ul>

Merging

<h2>Models</h2>
Minecraft supports adding and modifying item and block models. Models determine the
shape and textures of items and blocks.
Blocks use a block state configuration to determine which model is used for each variant.
Meanwhile, each item has a single model, which either loads a block's model, contains data
for its own custom model, or uses the default "flat" or "entity" model.
In this page we will first learn about the parts of a model, and at the end we will
see how to create the model.
<h3>Element</h3>
Minecraft Models are composed only by cubes, and each cube is an <code>Element</code>. An Element has
a from and to position, a rotation and an optional texture for each of the 6 faces.
We build an Element like this:
<pre><code class="hljs language-java">Element element = Element.element()
 .from(0, 0, 0)
 .to(16, 16, 16)
 .addFace(CubeFace.UP, ElementFace.face()
 .texture("#0") // use the texture with id '0'
 .uv(TextureUV.uv(0, 0, 1, 1)) // use the full texture
 .build())
 // add more faces, if you do not add one, it won't be visible
 .build();
</code></pre>
<ul>
<li>Note that <code>16</code> units is the size of a Minecraft block, but this may depend on where the
model is displayed.</li>
</ul>
<h3>Textures</h3>
A Model can have multiple textures to be used by the elements. Textures must be specified
and assigned an id to be then referenced by the elements.
<pre><code class="hljs language-java">ModelTextures textures = ModelTextures.builder()
 .layers(
 // without .png extension
 ModelTexture.ofKey(Key.key("key/to/my/texture"))
 )
 .build();
</code></pre>
In this example, we are adding a single texture with the key <code>key/to/my/texture.png</code>,
which will be referenced by the elements using the id <code>0</code> (because it's the first texture,
the layers list is ordered).
<h3>Displays</h3>
The displays are used to specify how the model is displayed in different contexts. For
example, we can specify a different scale for the model when it's displayed in an entity's
head, or when it's displayed in a player's hand.
<pre><code class="hljs language-java">// (API subject to change in next major version)
Map&#x3C;ItemTransform.Type, ItemTransform> displays = new HashMap&#x3C;>();

// this will scale the model to 0.5 when it's displayed in an entity's head
displays.put(ItemTransform.Type.HEAD, ItemTransform.transform(
 Vector3Float.ZERO, // rotation: no rotation
 Vector3Float.ZERO, // translation: no translation
 new Vector3Float(0.5, 0.5, 0.5)
));
</code></pre>
Note that there are some limits regarding the translation and scale of a model. For
translation, all the values must be between <code>-80</code> and <code>80</code>. For scale, all the value
must be between <code>0</code> and <code>4</code>. Everything inclusive.
<h3>Overrides</h3>
Overrides are used to change the model of an item model depending on its state. For
example, we can change the model of a bow depending on how much it's pulled. Check the
<code>ItemPredicate</code> class for a full list of item override predicates.
<pre><code class="hljs language-java">// this will change the model when the item has a custom model data of '2'
ItemOverride override = ItemOverride.of(
 Key.key("key/to/the/model"),
 ItemPredicate.customModelData(2)
);
</code></pre>
We can have as many overrides as we want.
<h3>Creating a Model</h3>
Finally, we can create a model using the elements and textures we created before:
<pre><code class="hljs language-java">Model model = Model.model()
 .key(Key.key("custom/my_model"))
 .addElement(element) // the element we created before
 .addOverride(override) // the override we created before
 .displays(displays) // the displays we created before
 .textures(textures) // the textures we created before
 .build();

// There are some extra options like:
// .parent(Key.key("parent/model")) // to inherit from another model
// .ambientOcclusion(false) // to disable ambient occlusion
// .guiLight(ModelGuiLight.FRONT) // to change the gui light
</code></pre>
And then we can add it to the resource-pack using <code>ResourcePack#model(Model)</code>
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
Model model = ...;
resourcePack.model(model);
</code></pre>

Models

<h2>Putting it all together</h2>
Now we can build the resource-pack!
<pre><code class="hljs language-java">ResourcePack resourcePack = ResourcePack.create();

// Required to have a valid resource pack
resourcePack.packMeta(9, "Description!");

// adding the resource pack icon
resourcePack.icon(Writable.file(...)); // Use any type of Writable
 
// adding a font
resourcePack.font(font);

// adding a texture
resourcePack.texture(texture);

// adding a non special file
resourcePack.unknownFile("credits.txt", Writable.stringUtf8("Unnamed Team"));

// now we have a resource pack ready to be exported/written
// as a ZIP file or as a file tree (you need the 'creative-serializer-minecraft'
// dependency for this class)
MinecraftResourcePackWriter.minecraft().writeToZipFile(
 new File("my-resource-pack.zip"),
 resourcePack
);
</code></pre>

Putting it all together

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.7.3")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

Minecraft Serializers

<h2>Serializers</h2>
Serializers (Resource Pack Reader &#x26; Writer) are a way to convert
creative's <code>ResourcePack</code> to another format.
Currently, there is only one supported format for resource-packs: the
vanilla Minecraft one, which represents all the resources as files in
a file tree (Like ZIP or a folder).
If you need more information on usage for the Minecraft serializers,
<a href="/docs/creative/serialization/minecraft">skip to the next page</a>
<h3>API</h3>
The <code>creative-api</code> provides very general and abstract interfaces which
are responsible for reading and writing resource-packs to "somewhere".
<ul>
<li><code>ResourcePackReader</code>: Reads a <code>ResourcePack</code> object from a generic <code>T</code> object</li>
<li><code>ResourcePackWriter</code>: Writes a <code>ResourcePack</code> object to a generic <code>T</code> object</li>
</ul>
Also note that the only serializable type for the <code>creative-api</code> is the
<code>ResourcePack</code> type, any other elements are only considered parts of the
resource pack.
If you want to serialize specific elements from the resource pack, you will
need to use implementation-specific methods (more on that in next pages)

Serializers

Serialization

<h2>Creative Server</h2>
Welcome to the <code>creative-server</code> documentation, creative-server is a fast,
lightweight and specialized HTTP(s) server for Minecraft: Java Edition
resource-packs.
<h3>Features</h3>
The server parses the information that the vanilla Minecraft client sends when
it requests a resource-pack, so we can:
<ul>
<li>Return a different resource-pack depending on the player (this implies:
language, version, client name, etc.)</li>
<li>Ignore or block non-minecraft clients (like browsers)</li>
</ul>

Creative Server

<h2>Download Request</h2>
From our Minecraft server we must ask the player to download our
resource-pack, this is platform-dependent, but it commonly takes
the resource-pack server address and the resource-pack SHA-1 hash
(which can be taken from <code>BuiltResourcePack#hash()</code>)
<pre><code class="hljs language-java">BuiltResourcePack pack = ...;

String hash = pack.hash();

// The resource-pack path, can be empty, but due to a bug
// on the Minecraft client, the hashes are not correctly
// checked, and it will fail to update
String path = hash + ".zip";

// just an example! replace this by your server's
// public address for production
// HTTP is required if you did not configure HTTPS
String url = "http://127.0.0.1:7270/" + path;
</code></pre>
<h3>Paper</h3>
On <a href="https://papermc.io/">Paper</a> we can use the <code>Player#setResourcePack</code>
method:
<pre><code class="hljs language-java">player.setResourcePack(url, hash /*, prompt, force */);
</code></pre>
<h3>Minestom</h3>
On <a href="https://minestom.net/">Minestom</a> we can use the <code>Player#setResourcePack</code>
method:
<pre><code class="hljs language-java">// forced(...) or optional(...)
player.setResourcePack(ResourcePack.forced(url, hash /*, prompt */));
</code></pre>

Download Request

<h2>Handling Requests</h2>
As we said in <a href="/docs/creative/server/start-stop">Start and Stop</a>, when constructing a resource-pack
server, we can set either a <code>handler</code> or a <code>pack</code>, see how this works:
When setting a resource-pack to the server, it creates a default handler that will
always return it no matter the resource-pack request information
We can replace this behavior by specifying a custom resource-pack request handler
<pre><code class="hljs language-java">ResourcePackServer server = ResourcePackServer.server()
 .address("127.0.0.1", 7270)
 .handler(handler) // &#x3C;-- Here, see below
 // ...
 .build();
</code></pre>
<h3>Handler</h3>
A handler is a <code>ResourcePackRequestHandler</code> implementation, it receives a
(nullable) <code>ResourcePackDownloadRequest</code> which contains the player uuid, username,
client version, and pack format. It also receives an <code>HttpExchange</code> used to set the
response information
The received <code>ResourcePackDownloadRequest</code> is null when the server couldn't
parse the received information from the request. <code>null</code> indicates that
the request was not made from a vanilla Minecraft client.
Please also note that the information may be spoofed, and may not be
actually sent by the client.
Example:
<pre><code class="hljs language-java">BuiltResourcePack pack8 = MinecraftResourcePackWriter.minecraft().build(this::createPack8);
BuiltResorucePack pack9 = MinecraftResourcePackWriter.minecraft().build(this::createPack9);

ResourcePackRequestHandler handler = (request, exchange) -> {
 // available methods:
 // - request.uuid()
 // - request.username()
 // - request.clientVersion()
 // - request.clientVersionId()
 // - request.packFormat()
 
 int expectedPackFormat;
 if (request == null) {
 // no information provided, fall back to 9
 expectedPackFormat = 9;
 } else {
 expectedPackFormat = request.packFormat();
 }
 
 BuiltResourcePack pack;
 
 if (expectedPackFormat == 9) {
 pack = pack9;
 } else if (expectedPackFormat == 8) {
 pack = pack8;
 } else {
 // no pack with this format :(
 byte[] response = "No pack for u\n".getBytes(StandardCharsets.UTF_8);
 exchange.getResponseHeaders().set("Content-Type", "text/plain");
 exchange.sendResponseHeaders(400, response.length);
 try (OutputStream responseStream = exchange.getResponseBody()) {
 responseStream.write(response);
 }
 return;
 }

 // write our resource pack
 byte[] data = pack.bytes();
 exchange.getResponseHeaders().set("Content-Type", "application/zip");
 exchange.sendResponseHeaders(200, data.length);
 try (OutputStream responseStream = exchange.getResponseBody()) {
 responseStream.write(data);
 }
};
</code></pre>
<h3>Executor</h3>
By default, the requests handlers will be executed in a single thread, the same
thread that receives the requests. This means that if a request takes a long time
to process, the next request will have to wait until the previous one finishes.
To avoid this, we can set a multithreaded executor to the server, so the requests
will be processed in different threads, allowing multiple requests to be processed
at the same time:
<pre><code class="hljs language-java">ResourcePackServer server = ResourcePackServer.server()
 .address("127.0.0.1", 7270)
 .handler(...)
 .executor(Executors.newFixedThreadPool(8)) // &#x3C;-- will use 8 threads
 .build();
</code></pre>

Handling Requests

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
Note that <code>creative-server</code> is available in the Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.7.3")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.7.3&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Start and Stop</h2>
Before everything, we must build a resource-pack server, during this
phase we can set some settings like the server address, server port,
handler path, SSL/TLS for HTTPS, etc
Example:
<pre><code class="hljs language-java">ResourcePackServer server = ResourcePackServer.server()
 .address("127.0.0.1", 7270) // (required) address and port
 .pack(ResourcePack) // (required) pack to serve
 .executor(Executor) // (optional) request executor (IMPORTANT!)
 .secure(...) // (optional) SSL/TLS configuration
 .path("/get/") // (optional) handler path, default = "/"
 .build();
</code></pre>
Note:
<ul>
<li>This will not automatically start the server</li>
<li><code>pack(...)</code> can be replaced by <code>handler(...)</code>, see
<a href="/docs/creative/server/handle-request">Handling Requests</a></li>
<li>If you do not set the executor, the requests will be blocking. So a request
will have to finish before the next one can be processed. It is recommended
to set a multithreaded executor to avoid this, for example: <code>.executor(Executors.newFixedThreadPool(numberOfThreads))</code></li>
</ul>
<h3>Start</h3>
After we built the resource-pack server we can start it, so it starts
listening for requests
Note: This method is not blocking, so it is not necessary to invoke
it in a different thread, the internal HttpServer already starts it in a
background thread,
see <a href="https://docs.oracle.com/javase/8/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpServer.html#start--">HttpServer#start</a>
<pre><code class="hljs language-java">server.start(); // NOT BLOCKING!
</code></pre>
<h3>Stop</h3>
We stop the server using the <code>stop(int)</code> method, it asks for an integer value,
which specifies the maximum time in seconds to wait until requests have finished
Note: Waiting for the requests is a blocking operation if the maximum time
is greater than zero
<pre><code class="hljs language-java">server.stop(0); // BLOCKING IF NOT ZERO!
</code></pre>

Start and Stop

Server

<h2>Sounds</h2>
In Minecraft resource-packs, sounds have different levels of structure
<h3>1. <code>Sound</code></h3>
It is the smallest unit of the sound system, it just represents a sound (<code>.ogg</code>)
file
<pre><code class="hljs language-java">Sound sound = Sound.sound(
 // location of the sound file in the resource-pack
 // (assets/&#x3C;namespace>/sounds/&#x3C;name>.ogg)
 Key.key("creative:meow_1"),
 
 // the sound data, check the Writable API,
 // in this case, the sound data is taken from
 // a file called "the_sound.ogg"
 Writable.file(new File("the_sound.ogg"))
);
</code></pre>
Remember that sound files are independently written to the resource-pack, to
add a sound to a resource-pack, you use:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
resourcePack.sound(sound);
</code></pre>
As simple as that!
<h3>2. <code>SoundEntry</code></h3>
It is the second-smallest unit of the sound system, there are two types of sound entries:
2.1. <code>FILE</code>, which is just configuration for a single <code>Sound</code>, it contains options like
volume, pitch and attenuation distance
<pre><code class="hljs language-java">SoundEntry soundEntry = SoundEntry.soundEntry()
 .type(SoundEntry.Type.FILE) // &#x3C;-- Specify type to FILE
 .key(Key.key("creative:meow_1")) // &#x3C;-- set the key of a Sound
 .volume(1.0F)
 .pitch(1.0F)
 .weight(1)
 .stream(false)
 .attenuationDistance(16)
 .preload(false)
 .build();
</code></pre>
2.2. <code>EVENT</code>, which is configuration for a <code>SoundEvent</code> (see below), it allows the same
options as the FILE type
<pre><code class="hljs language-java">SoundEntry soundEntry = SoundEntry.soundEntry()
 .type(SoundEntry.Type.EVENT) // &#x3C;-- Specify type to EVENT
 .key(Key.key("creative:meow")) // &#x3C;-- set the key of a SoundEvent
 .volume(1.0F)
 .pitch(1.0F)
 .weight(1)
 .stream(false)
 .attenuationDistance(16)
 .preload(false)
 .build();
</code></pre>
<h3>3. <code>SoundEvent</code></h3>
The <code>SoundEvent</code> class represents a named sound, this is the one you will use
in-game. A sound event is just a named list of <code>SoundEntry</code>'s.
From the server, you can't play specific sound entries (<code>SoundEntry</code>) or sounds
(<code>Sound</code>), you play/fire sound events (<code>SoundEvent</code>)
When a sound event is played/fired, a <code>SoundEntry</code> is randomly selected (based
on their <code>weight</code> property) and played.
<pre><code class="hljs language-java">SoundEvent soundEvent = SoundEvent.soundEvent()
 .key(Key.key("creative:creative.cat.meow"))
 .sounds(
 soundEntry1,
 soundEntry2,
 soundEntry3,
 ...
 );
 .replace(false)
 .build();
</code></pre>
Now write the <code>SoundEvent</code> in the resource-pack:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
resourcePack.soundEvent(soundEvent);
</code></pre>
And that's it! We are ready to play sounds in the game
<h3>Playing a custom sound</h3>
In Paper, you can do the following:
<pre><code class="hljs language-java">SoundEvent soundEvent = ...;
player.playSound(Sound.sound(soundEvent, Sound.Source.AMBIENT, 1f, 1.1f));
</code></pre>
See <a href="https://docs.adventure.kyori.net/sound.html">Adventure documentation</a>

Sounds

<h2>Textures</h2>
A texture requires: a <code>Key</code> (identifier), and the actual
texture PNG data, which can be passed using the <code>Writable</code> API,
e.g.
<pre><code class="hljs language-java">Texture texture = Texture.texture()
 .key(Key.key("namespace", "my_texture.png"))
 .data(Writable.file(new File("exampleTexture.png")))
 .build();
</code></pre>
A texture is also meta-datable, this means you can add some
specific metadata sections to it, e.g. animating a texture
<pre><code class="hljs language-java">Texture texture = Texture.texture()
 .key(Key.key("namespace", "my_texture.png"))
 .data(Writable.file(new File("exampleTexture.png")))
 .meta(
 Metadata.builder()
 .add(AnimationMeta.builder().height(16).build())
 .build()
 )
 .build();
</code></pre>
Then you can add the texture using <code>ResourcePack#texture(Texture)</code>

Textures

<h2>Hello World</h2>
Let's create a simple and empty resource-pack using <code>creative-api</code>
and <code>creative-serializer-minecraft</code>
<pre><code class="hljs language-java">ResourcePack resourcePack = ResourcePack.create();

// Here we specify the resource-pack format (12) and description (Hello world!)
resourcePack.packMeta(12, "Hello world!");

// Then we write the resource-pack to a folder
MinecraftResourcePackWriter.minecraft()
 .writeToDirectory(new File("folder"), resourcePack);
</code></pre>
The code above writes the resource-pack to a folder named 'folder', its content
will be the following:
<pre><code class="hljs language-lua">folder/
 |------- pack.mcmeta
</code></pre>
Where <code>pack.mcmeta</code> file has the following content (but minimized):
<pre><code class="hljs language-json">{
 "pack": {
 "pack_format": 12,
 "description": "Hello world!"
 }
}
</code></pre>

<h2>Fonts</h2>
Minecraft supports adding and modifying fonts. We can do a lot of
customization using this, such as:
<ul>
<li>Adding emojis to the Minecraft chat (And our plugin <a href="https://github.com/unnamed/emojis">µŋemojis</a>
is an example)</li>
<li>Creating custom inventories</li>
<li>And more...!</li>
</ul>
<h3>Font Providers</h3>
Font providers are the base components of a complete font, a font
may complete multiple font providers. Font providers can be: a bitmap
font provider, legacy unicode font provider, true type font provider
<h3>BitMap Font Provider</h3>
This type of font provider requires a bitmap (PNG) texture
(see <a href="/docs/creative/textures">Textures</a>), ascent (vertical offset for
the glyphs) and characters to use for this font
<pre><code class="hljs language-java">Texture texture = ...;

FontProvider provider = FontProvider.bitMap()
 .file(texture.key())
 .ascent(7)
 .characters(
 "abcdef",
 "012345",
 "6789ñá"
 )
 .build();
</code></pre>
TODO: add the other font providers
<h3>Putting all together</h3>
To finally create a <code>Font</code>, we just merge all the font
providers and assign a key
<pre><code class="hljs language-java">Font font = Font.of(
 Key.key("namespace", "my_font"),
 fontProvider1,
 fontProvider2,
 ...
);
</code></pre>
<h3>Using a font</h3>
Using Adventure, you could use:
<pre><code class="hljs language-java">Font font = MyFonts.MY_SPECIAL_FONT;

player.sendMessage(
 text()
 .content("Hello world")
 .font(font.key())
);
</code></pre>

<h2>Getting Started</h2>
Welcome to the <code>creative</code> documentation
<code>creative</code> is a resource-pack library for vanilla Minecraft: Java
Edition, it is not dependent on the server implementation (It doesn't
matter if you use Spigot, Paper, Waterfall, BungeeCord, Velocity, etc.)
See this example of the <code>creative</code> API:
<pre><code class="hljs language-java">ResourcePack resourcePack = ResourcePack.create();
 
// Required to have a valid resource pack
resourcePack.packMeta(9, "Description!");

// adding the resource pack icon
resourcePack.icon(Writable.file(new File("my-icon.png")));

// adding a texture
resourcePack.texture(texture);

// adding a non special file
resourcePack.unknownFile("credits.txt", Writable.stringUtf8("Unnamed Team"));

// now we have a resource pack ready to be exported/written
// as a ZIP file or as a file tree (you need the 'creative-serializer-minecraft'
// dependency for this class)
MinecraftResourcePackWriter.minecraft().writeToZipFile(
 new File("my-resource-pack.zip"),
 resourcePack
);
</code></pre>
<h3>Features</h3>
<ul>
<li>Create, verify and serve resource-packs programmatically</li>
<li>Create the most compact resource-packs, everything is reduced if it is possible</li>
<li><code>creative</code> uses &#x26; supports <a href="https://github.com/KyoriPowered/adventure">Kyori's adventure</a></li>
<li>...More things are possible, you just have to discover them</li>
</ul>
See <a href="https://github.com/unnamed/hephaestus-engine">hephaestus-engine</a>, this
is an example of what can be done with creative
If you prefer to learn with examples you can see the <a href="/docs/creative/examples/hello-world">Examples section</a>

<h2>Installation</h2>
You can add <code>creative-api</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.0.0")
 
 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.0.0")
 
 // Resource Pack server
 implementation("team.unnamed:creative-server:1.0.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.0.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Language</h2>
Using a resource-pack, you can add or modify language translations.
A creative language representation is very simple, it is just a
keyed map of translations, e.g.
<pre><code class="hljs language-java">Language language = Language.of(
 Key.key("minecraft", "en_US"),
 Map.of(
 // translation key // translation
 "gui.yes", "Yes please",
 "gui.no", "No!",
 "gui.proceed", "Do it!"
 )
);
</code></pre>
Then you can add the language using <code>ResourcePack#language(Language)</code>

<h2>Creative Server</h2>
Welcome to the <code>creative-server</code> documentation, creative-server is a fast,
lightweight and specialized HTTP(s) server for Minecraft: Java Edition
resource-packs
<h3>Features</h3>
The server parses the information that the vanilla Minecraft client sends when
it requests a resource-pack, so we can:
<ul>
<li>Return a different resource-pack depending on the player (this implies:
language, version, client name, etc.)</li>
<li>Ignore or block non-minecraft clients (like browsers)</li>
</ul>

<h2>Handling Requests</h2>
As we said in <a href="/docs/creative/server/start-stop">Start and Stop</a>, when constructing a resource-pack
server, we can set either a <code>handler</code> or a <code>pack</code>, see how this works:
When setting a resource-pack to the server, it creates a default handler that will
always return it no matter the resource-pack request information
We can replace this behavior by specifying a custom resource-pack request handler
<pre><code class="hljs language-java">ResourcePackServer server = ResourcePackServer.builder()
 .address("127.0.0.1", 7270)
 .handler(handler) // &#x3C;-- Here, see below
 // ...
 .build();
</code></pre>
<h3>Handler</h3>
A handler is a <code>ResourcePackRequestHandler</code> implementation, it receives a
parsed <code>ResourcePackRequest</code> which contains the player uuid, username, client
version, and pack format. It also receives an <code>HttpExchange</code> used to set
the response information
Example:
<pre><code class="hljs language-java">BuiltResourcePack pack8 = MinecraftResourcePackWriter.minecraft().build(this::createPack8);
BuiltResorucePack pack9 = MinecraftResourcePackWriter.minecraft().build(this::createPack9);

ResourcePackRequestHandler handler = (request, exchange) -> {
 // available methods:
 // - request.uuid()
 // - request.username()
 // - request.clientVersion()
 // - request.clientVersionId()
 // - request.packFormat()
 
 int expectedPackFormat = request.packFormat();
 BuiltResourcePack pack;
 
 if (expectedPackFormat == 9) {
 pack = pack9;
 } else if (expectedPackFormat == 8) {
 pack = pack8;
 } else {
 // no pack with this format :(
 byte[] response = "No pack for u".getBytes(StandardCharsets.UTF_8);
 exchange.sendResponseHeaders(400, response.length);
 try (OutputStream responseStream = exchange.getResponseBody()) {
 responseStream.write(response);
 }
 return;
 }

 // write our resource pack
 byte[] data = pack.bytes();
 exchange.getResponseHeaders().set("Content-Type", "application/zip");
 exchange.sendResponseHeaders(200, data.length);
 try (OutputStream responseStream = exchange.getResponseBody()) {
 responseStream.write(data);
 }
};
</code></pre>
<h3>Invalid Requests</h3>
Invalid requests are those that do not have the information that the
vanilla Minecraft client sends, we can handle them by overriding the
<code>onInvalidRequest</code> method
In the example above we did not override the <code>onInvalidRequest</code> method,
so the behavior is defaulted (a 'Please use a Minecraft client' message
is shown)
<pre><code class="hljs language-java">ResourcePackRequestHandler handler = new ResourcePackRequestHandler() {
 
 @Override
 public void onRequest(ResourcePackRequest request, HttpExchange exchange) throws IOException {
 // handle valid request
 }
 
 @Override
 public void onInvalidRequest(HttpExchange exchange) throws IOException {
 // handle invalid request
 // we can return resource-packs here too!
 // we just do not have the 'request' information available
 }
 
};
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.0.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.0.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Start and Stop</h2>
Before everything, we must build a resource-pack server, during this
phase we can set some settings like the server address, server port,
handler path, SSL/TLS for HTTPS, etc.
Example:
<pre><code class="hljs language-java">ResourcePackServer server = ResourcePackServer.builder()
 .address("127.0.0.1", 7270) // (required) address and port
 .pack(ResourcePack) // (required) pack to serve
 .secure(...) // (optional) SSL/TLS configuration
 .path("/get/") // (optional) handler path, default = "/"
 .build();
</code></pre>
Note:
<ul>
<li>This will not automatically start the server</li>
<li><code>pack(...)</code> can be replaced by <code>handler(...)</code>, see
<a href="/docs/creative/server/handle-request">Handling Requests</a></li>
</ul>
<h3>Start</h3>
After we built the resource-pack server we can start it, so it starts
listening for requests
Note: This method is not blocking, so it is not necessary to invoke
it in a different thread, the internal HttpServer already starts it in a
background thread, see <a href="https://docs.oracle.com/javase/8/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpServer.html#start--">HttpServer#start</a>
<pre><code class="hljs language-java">server.start(); // NOT BLOCKING!
</code></pre>
<h3>Stop</h3>
We stop the server using the <code>stop(int)</code> method, it asks for an integer value,
which specifies the maximum time in seconds to wait until requests have finished
Note: Waiting for the requests is a blocking operation if the maximum time
is greater than zero
<pre><code class="hljs language-java">server.stop(0); // BLOCKING IF NOT ZERO!
</code></pre>

<h2>Sounds</h2>
In Minecraft resource-packs, sounds have different levels of structure
<h3>1. <code>Sound</code></h3>
It is the smallest unit of the sound system, it just represents a sound (<code>.ogg</code>)
file
<pre><code class="hljs language-java">Sound sound = Sound.of(
 // location of the sound file in the resource-pack
 // (assets/&#x3C;namespace>/sounds/&#x3C;name>.ogg)
 Key.key("creative:meow_1"),
 
 // the sound data, check the Writable API,
 // in this case, the sound data is taken from
 // a file called "the_sound.ogg"
 Writable.file(new File("the_sound.ogg"))
);
</code></pre>
Remember that sound files are independently written to the resource-pack, to
add a sound to a resource-pack, you use:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
resourcePack.sound(sound);
</code></pre>
As simple as that!
<h3>2. <code>SoundEntry</code></h3>
It is the second-smallest unit of the sound system, there are two types of sound entries:
2.1. <code>FILE</code>, which is just configuration for a single <code>Sound</code>, it contains options like
volume, pitch and attenuation distance
<pre><code class="hljs language-java">SoundEntry soundEntry = SoundEntry.builder()
 .type(SoundEntry.Type.FILE) // &#x3C;-- Specify type to FILE
 .key(Key.key("creative:meow_1")) // &#x3C;-- set the key of a Sound
 .volume(1.0F)
 .pitch(1.0F)
 .weight(1)
 .stream(false)
 .attenuationDistance(16)
 .preload(false)
 .build();
</code></pre>
2.2. <code>EVENT</code>, which is configuration for a <code>SoundEvent</code> (see below), it allows the same
options as the FILE type
<pre><code class="hljs language-java">SoundEntry soundEntry = SoundEntry.builder()
 .type(SoundEntry.Type.EVENT) // &#x3C;-- Specify type to EVENT
 .key(Key.key("creative:meow")) // &#x3C;-- set the key of a SoundEvent
 .volume(1.0F)
 .pitch(1.0F)
 .weight(1)
 .stream(false)
 .attenuationDistance(16)
 .preload(false)
 .build();
</code></pre>
<h3>3. <code>SoundEvent</code></h3>
The <code>SoundEvent</code> class represents a named sound, this is the one you will use
in-game. A sound event is just a named list of <code>SoundEntry</code>'s.
From the server, you can't play specific sound entries (<code>SoundEntry</code>) or sounds
(<code>Sound</code>), you play/fire sound events (<code>SoundEvent</code>)
When a sound event is played/fired, a <code>SoundEntry</code> is randomly selected (based
on their <code>weight</code> property) and played.
<pre><code class="hljs language-java">SoundEvent soundEvent = SoundEvent.builder()
 .key(Key.key("creative:creative.cat.meow"))
 .sounds(
 soundEntry1,
 soundEntry2,
 soundEntry3,
 ...
 );
 .replace(false)
 .build();
</code></pre>
Now write the <code>SoundEvent</code> in the resource-pack:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
resourcePack.soundEvent(soundEvent);
</code></pre>
And that's it! We are ready to play sounds in the game
<h3>Playing a custom sound</h3>
In Paper, you can do the following:
<pre><code class="hljs language-java">SoundEvent soundEvent = ...;
player.playSound(Sound.sound(soundEvent.key(), Sound.Source.AMBIENT, 1f, 1.1f));
</code></pre>
See <a href="https://docs.adventure.kyori.net/sound.html">Adventure documentation</a>

<h2>Textures</h2>
A texture requires: a <code>Key</code> (identifier), and the actual
texture PNG data, which can be passed using the <code>Writable</code> API,
e.g.
<pre><code class="hljs language-java">Texture texture = Texture.builder()
 .key(Key.key("namespace", "my_texture.png"))
 .data(Writable.file(new File("exampleTexture.png")))
 .build();
</code></pre>
A texture is also meta-datable, this means you can add some
specific metadata sections to it, e.g. animating a texture
<pre><code class="hljs language-java">Texture texture = Texture.builder()
 .key(Key.key("namespace", "my_texture.png"))
 .data(Writable.file(new File("exampleTexture.png")))
 .meta(
 Metadata.builder()
 .add(AnimationMeta.builder().height(16).build())
 .build()
 )
 .build();
</code></pre>
Then you can add the texture using <code>ResourcePack#texture(Texture)</code>

<h2>Installation</h2>
You can add <code>creative-api</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.1.0")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.1.0")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.1.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">
&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.1.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.1.0")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack=...;
 File output=new File("/path/to/resource-pack.zip");
 MinecraftResourcePackWriter.minecraft().writeToZipFile(output,resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack=...;
 BuiltResourcePack builtResourcePack=MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input=new File("/path/to/input/resource-pack.zip");
 ResourcePack resourcePack=MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font=FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(),"font.json"),
 Key.key("custom:fontkey")
 );
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language=...;
 try(OutputStream output=new FileOutputStream("es.json")){
 LanguageSerializer.INSTANCE.serialize(language,output);
 }
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.1.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.1.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Installation</h2>
You can add <code>creative-api</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.3.0")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.3.0")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.3.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.3.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.3.0")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Handling Requests</h2>
As we said in <a href="/docs/creative/server/start-stop">Start and Stop</a>, when constructing a resource-pack
server, we can set either a <code>handler</code> or a <code>pack</code>, see how this works:
When setting a resource-pack to the server, it creates a default handler that will
always return it no matter the resource-pack request information
We can replace this behavior by specifying a custom resource-pack request handler
<pre><code class="hljs language-java">ResourcePackServer server = ResourcePackServer.server()
 .address("127.0.0.1", 7270)
 .handler(handler) // &#x3C;-- Here, see below
 // ...
 .build();
</code></pre>
<h3>Handler</h3>
A handler is a <code>ResourcePackRequestHandler</code> implementation, it receives a
(nullable) <code>ResourcePackDownloadRequest</code> which contains the player uuid, username,
client version, and pack format. It also receives an <code>HttpExchange</code> used to set the
response information
The received <code>ResourcePackDownloadRequest</code> is null when the server couldn't
parse the received information from the request. <code>null</code> indicates that
the request was not made from a vanilla Minecraft client.
Please also note that the information may be spoofed, and may not be
actually sent by the client.
Example:
<pre><code class="hljs language-java">BuiltResourcePack pack8 = MinecraftResourcePackWriter.minecraft().build(this::createPack8);
BuiltResorucePack pack9 = MinecraftResourcePackWriter.minecraft().build(this::createPack9);

ResourcePackRequestHandler handler = (request, exchange) -> {
 // available methods:
 // - request.uuid()
 // - request.username()
 // - request.clientVersion()
 // - request.clientVersionId()
 // - request.packFormat()
 
 int expectedPackFormat;
 if (request == null) {
 // no information provided, fall back to 9
 expectedPackFormat = 9;
 } else {
 expectedPackFormat = request.packFormat();
 }
 
 BuiltResourcePack pack;
 
 if (expectedPackFormat == 9) {
 pack = pack9;
 } else if (expectedPackFormat == 8) {
 pack = pack8;
 } else {
 // no pack with this format :(
 byte[] response = "No pack for u\n".getBytes(StandardCharsets.UTF_8);
 exchange.getResponseHeaders().set("Content-Type", "text/plain");
 exchange.sendResponseHeaders(400, response.length);
 try (OutputStream responseStream = exchange.getResponseBody()) {
 responseStream.write(response);
 }
 return;
 }

 // write our resource pack
 byte[] data = pack.bytes();
 exchange.getResponseHeaders().set("Content-Type", "application/zip");
 exchange.sendResponseHeaders(200, data.length);
 try (OutputStream responseStream = exchange.getResponseBody()) {
 responseStream.write(data);
 }
};
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.3.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.3.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Start and Stop</h2>
Before everything, we must build a resource-pack server, during this
phase we can set some settings like the server address, server port,
handler path, SSL/TLS for HTTPS, etc
Example:
<pre><code class="hljs language-java">ResourcePackServer server = ResourcePackServer.server()
 .address("127.0.0.1", 7270) // (required) address and port
 .pack(ResourcePack) // (required) pack to serve
 .secure(...) // (optional) SSL/TLS configuration
 .path("/get/") // (optional) handler path, default = "/"
 .build();
</code></pre>
Note:
<ul>
<li>This will not automatically start the server</li>
<li><code>pack(...)</code> can be replaced by <code>handler(...)</code>, see
<a href="/docs/creative/server/handle-request">Handling Requests</a></li>
</ul>
<h3>Start</h3>
After we built the resource-pack server we can start it, so it starts
listening for requests
Note: This method is not blocking, so it is not necessary to invoke
it in a different thread, the internal HttpServer already starts it in a
background thread,
see <a href="https://docs.oracle.com/javase/8/docs/jre/api/net/httpserver/spec/com/sun/net/httpserver/HttpServer.html#start--">HttpServer#start</a>
<pre><code class="hljs language-java">server.start(); // NOT BLOCKING!
</code></pre>
<h3>Stop</h3>
We stop the server using the <code>stop(int)</code> method, it asks for an integer value,
which specifies the maximum time in seconds to wait until requests have finished
Note: Waiting for the requests is a blocking operation if the maximum time
is greater than zero
<pre><code class="hljs language-java">server.stop(0); // BLOCKING IF NOT ZERO!
</code></pre>

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.4.0")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.4.0")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.4.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.4.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.4.0")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">repositories {
 maven("https://repo.unnamed.team/repository/unnamed-public/")
}
</code></pre>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.4.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;repository>
 &#x3C;id>unnamed-public&#x3C;/id>
 &#x3C;url>https://repo.unnamed.team/repository/unnamed-public/&#x3C;/url>
&#x3C;/repository>
</code></pre>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.4.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.5.0")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.5.0")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.5.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.5.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.5.0")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
Note that <code>creative-server</code> is available in the Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.5.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.5.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.5.1")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.5.1")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.5.1")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.5.1&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.5.1")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
Note that <code>creative-server</code> is available in the Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.5.1")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.5.1&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.6.0")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.6.0")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.6.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.6.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.6.0")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
Note that <code>creative-server</code> is available in the Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.6.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.6.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.7.0")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.7.0")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.7.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.7.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.7.0")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
Note that <code>creative-server</code> is available in the Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.7.0")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.7.0&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.7.1")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.7.1")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.7.1")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.7.1&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.7.1")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
Note that <code>creative-server</code> is available in the Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.7.1")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.7.1&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Installation</h2>
You can add <code>creative</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files from <a href="https://github.com/unnamed/creative/releases">GitHub Releases</a>.
Note that <code>creative</code> and all of its submodules are available in the
Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-api:1.7.2")

 // Serializer for Minecraft format (ZIP / Folder)
 implementation("team.unnamed:creative-serializer-minecraft:1.7.2")

 // Resource Pack server
 implementation("team.unnamed:creative-server:1.7.2")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-api&#x3C;/artifactId>
 &#x3C;version>1.7.2&#x3C;/version>
&#x3C;/dependency>
</code></pre>

<h2>Minecraft Serializers</h2>
The Minecraft serializers represent resource-packs in a way the vanilla Minecraft
client can load them. That is, representing the resource-pack as a ZIP file or as
a folder, where every file inside it is a resource pack element.
The Minecraft serializers also let you convert <code>ResourcePack</code> object into a
<code>BuiltResourcePack</code>, which can be hosted using the
<a href="/docs/creative/serialization/server/creative-server">creative-server</a> subproject.
Note that if you want to use the Minecraft serializers, you will have to include
the <code>creative-serializer-minecraft</code> dependency.
<pre><code class="hljs language-gradle">dependencies {
 implementation("team.unnamed:creative-serializer-minecraft:1.7.2")
}
</code></pre>
<h3>Usage</h3>
Usage is simple and pretty similar to adventure's text serializers. In this
usage guide we are going to provide some examples to use Minecraft resource
pack serializers.
Writing the resource-pack as a ZIP file:
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
File output = new File("/path/to/resource-pack.zip");
MinecraftResourcePackWriter.minecraft().writeToZipFile(output, resourcePack);
</code></pre>
Compiling the resource-pack in memory (<code>BuiltResourcePack</code>)
<pre><code class="hljs language-java">ResourcePack resourcePack = ...;
BuiltResourcePack builtResourcePack = MinecraftResourcePackWriter.minecraft().build(resourcePack);
</code></pre>
Reading the resource-pack from a ZIP file:
<pre><code class="hljs language-java">File input = new File("/path/to/input/resource-pack.zip");
ResourcePack resourcePack = MinecraftResourcePackReader.minecraft().readFromZipFile(input);
</code></pre>
<h3>Unitary Serialization</h3>
(Experimental, may drastically change in next major releases)
The Minecraft serializer knows that the resource-pack elements can be serialized
separately and lets you do that using element-specific serializers, for example:
Deserializing a font from resources:
<pre><code class="hljs language-java">Font font = FontSerializer.INSTANCE.deserialize(
 Readable.resource(getClass().getClassLoader(), "font.json"),
 Key.key("custom:fontkey")
);
</code></pre>
Serializing a language to a file:
<pre><code class="hljs language-java">Language language = ...;
try (OutputStream output = new FileOutputStream("es.json")) {
 LanguageSerializer.INSTANCE.serialize(language, output);
}
</code></pre>

<h2>Installation</h2>
You can add <code>creative-server</code> to your project using <a href="https://gradle.org/">Gradle</a>
(recommended), <a href="https://maven.apache.org/">Maven</a> or manually downloading the
JAR files.
Note that <code>creative-server</code> is available in the Maven Central Repository.
<h3>Gradle</h3>
<pre><code class="hljs language-kotlin">dependencies {
 implementation("team.unnamed:creative-server:1.7.2")
}
</code></pre>
<h3>Maven</h3>
<pre><code class="hljs language-xml">&#x3C;dependency>
 &#x3C;groupId>team.unnamed&#x3C;/groupId>
 &#x3C;artifactId>creative-server&#x3C;/artifactId>
 &#x3C;version>1.7.2&#x3C;/version>
&#x3C;/dependency>
</code></pre>