updated getting started guide for 1.21.10 (#118)

bluffcon · Silabear · web-flow · commit 88b36fe33865 · 2025-12-19T15:55:37.000-05:00
* update for 1.21.10

* t

* a few changes

---------

Co-authored-by: Silabear &lt;56885288+Silabear@users.noreply.github.com&gt;
diff --git a/src/routes/guide/getting-started/+page.svx b/src/routes/guide/getting-started/+page.svx
@@ -6,7 +6,7 @@ description:
   step-by-step tutorial will help you understand the basics of datapack
   creation, even if you have little coding knowledge. Start enhancing your
   Minecraft experience today!
-version: 1.21.8
+version: 1.21.10
 ---
 
 <script lang="ts">
@@ -65,19 +65,25 @@ or more difficult to work with. https://vscode.dev/
 
 The first step when creating a datapack is to **make a new world** to test it
 in. Go ahead and do that now - make sure that your world has **cheats enabled**
-and it is set to **creative mode**. Once you've created the world, the next step
-is to find and open your world folder:
+and it is set to **creative mode**. In the world, you will need to run the `/datapack create` command - 
+it will create your datapack folder as well as the necessary metadata for you, which saves you a bunch of time.
+
+For example, to make a datapack with the ID `ExampleDatapack` and the
+description "This is an example datapack", you would run the following command:
+
+```
+/datapack create ExampleDatapack "This is an example datapack"
+```
+
+Once you've created your empty datapack, the next step is to find and open the
+world folder:
 
 1. Save and quit your world
 2. Go to your world in the Singleplayer menu and hit "Edit"
 3. Press "Open World Folder"
 
-The folder that opens contains all the data in your Minecraft world. You should
-see that there's lots of other subfolders in this folder. Find the one which is
-called `datapacks`, and open it. This folder is where the world's datapacks are
-stored. Create a folder - this will be the root folder of your datapack project.
-The name doesn't matter. I'm just going to call it `Example Datapack`. **Open
-this new folder**. Inside this folder is where all the data starts from.
+The folder that opens contains your Minecraft world's data. There will be loads of subfolders in
+this folder: find the one which is called `datapacks`, and open it. This folder is where the world's datapacks are stored. If you used `/datapack create`, you should see your datapack's folder here already. (If not, you'll have to create it yourself. This is explained in the "NOTE" box below)
 
 :::tip
 
@@ -88,15 +94,16 @@ datapack will be _so much easier_!
 
 :::
 
-The first file we want to create is the `pack.mcmeta` file. This file will tell
-Minecraft that the folder is a datapack, as well as holding the basic
-information of the pack. **Create `pack.mcmeta`, and put this inside it**:
+The datapack folder will contain `pack.mcmeta` and a folder called `data`.
+`pack.mcmeta` tells Minecraft that the folder is a datapack, 
+as well as containing the basic information about the pack, such 
+as what versions it works in. `/datapack create` made this file automatically, but you can open the file like normal and view it if you want:
 
-```json
+```json:pack.mcmeta
 {
   "pack": {
-    "description": "DATAPACK NAME HERE",
-    "pack_format": 81
+    "description": "This is an example datapack",
+    "pack_format": 88
   }
 }
 ```
@@ -106,8 +113,18 @@ If you're interested, here's what this file means:
 - `pack` is an object containing the metadata of the file.
   - `description` is the name of your datapack, usually along with a short
     description of what your pack does.
-  - `pack_format` tells Minecraft what versions this datapack works in. `81` is
-    the latest for 1.21.8
+  - `pack_format` tells Minecraft what versions this datapack works in. `88`
+    (or 88.0) is the latest for 1.21.10
+
+
+
+:::note
+
+If you're in a version earlier than 1.21.6, you may notice that `/datapack create` doesn't 
+exist. You will have to create your datapack folder (inside `datapacks`) yourself. Just make
+a folder, and then inside that folder, create `pack.mcmeta` (as shown above) and the `data` folder.
+
+:::
 
 ## Writing your first function
 
@@ -123,18 +140,18 @@ as an entity (or as the Server) and at a position
 Let's get started by writing one simple function. In traditional programming
 fashion, let's make a function which sends "Hello World" to chat.
 
-1. Create a folder in your datapack called `data`.
+1. Open your empty `data` folder.
 2. In the `data` folder, create a new folder. This folder is your
    **namespace** - it will contain all the data specific to your datapack.
    Usually this needs to have a **unique name** (one which other people would
    not have picked), but for this tutorial just call it `example`.
 3. In the `example` folder, create a folder called `function`. This folder will
-   contain all the **mcfunction** files.
+   contain all the **.mcfunction** files.
 
 You should now have a folder structure that looks something like this:
 
 ```
-/world/datapacks/Example Datapack/data/example/function
+/world/datapacks/ExampleDatapack/data/example/function
 ```
 
 :::warning
@@ -146,7 +163,7 @@ due to some pesky name changes Mojang introduced in a recent update.
 
 Once you're sure that's correct, you can start writing the actual function.
 
-In the `function` folder, create an empty file called `hello_world.mcfunction`.
+In the `function` folder, create an empty text file called `hello_world.mcfunction`.
 Open this file with any text editor (we recommend Visual Studio Code)
 
 Inside `hello_world.mcfunction`, put the following:
@@ -159,9 +176,15 @@ title @s title "Hello World!"
 give @s diamond
 ```
 
-It's that simple! Once you **save that file**, **rejoin your world** and then
-run `/reload`, you should be able to use the following command to run the
-function:
+:::info
+
+Commands in functions shouldn't have the default slash `/` symbol which in-world
+commands have! Having the `/` before a command will make the mcfunction invalid
+and fail when it tries to run
+
+:::
+
+It's that simple! Once you **save that file**, and then run `/reload` (or if that doesn't work, rejoin your world), you should be able to use the following command to run the function:
 
 ```mcfunction
 /function example:hello_world
@@ -211,7 +234,12 @@ Minecraft "run this command every tick" (every tick = 20 times per second)
 1. In the `data` folder, create the `minecraft` folder.
 2. In the `minecraft` folder, create a `tags` folder
 3. In the `tags` folder, create a `function` folder
-4. In the new `function` folder, create a new file: `tick.json`
+4. In the new `function` folder, create a new text file: `tick.json`
+
+The final path would look like this:
+```
+/world/datapacks/ExampleDatapack/data/minecraft/tags/function/tick.json
+```
 
 **`tick.json` is NOT a function**. In `tick.json`, we are going to put a **list
 of functions** which we want to run every tick. If you put any commands in
@@ -258,7 +286,7 @@ world. They all start with an `@` symbol. There are 6 base target selectors:
 
 | Target Selector | Description                                                                                                                                                                |
 | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `@e`            | **All Entities** - By itself, this selector will select every single entity which is currently loaded in the world                                                         |
+| `@e`            | **All Entities** - By itself, this selector will select every single entity which is currently loaded in the world.                                                         |
 | `@s`            | **This Entity** - This selector will select the entity which is currently running the command. For example, if I run a command as @s, then it will run the commands as me. |
 | `@a`            | **All Players** - This selects all currently online players. (All players are always loaded in the world).                                                                 |
 | `@r`            | **Random Player** - This selects one random player.                                                                                                                        |
@@ -282,7 +310,7 @@ basic ones which you might see quite often:
 | `[type=minecraft:arrow]` | **Entity Type** - This criteria will narrow down the selection to only include entities of a certain type. For good pack optimisation, you should use this often.                                                                                                |
 | `[distance=..5]`         | **Distance to entity** - This criteria will only include entities based on their distance to their distance to the current position. `..` can be used to represent a greater/less than symbol - for example, `..5` means less than 5 blocks away.                |
 | `[limit=2]`              | **Limit selection** - Using the `limit` criteria, you can make specify a max amount of entities to be selected. This is often used in conjunction with the `sort` criteria. For example, `@e[sort=nearest,limit=1]` would select the nearest entity of any type. |
-| `[nbt={key:value}]`      | **Entity Data** - This criteria will select entities if their NBT (entity data) matches a pattern.                                                                                                                                                               |
+| `[nbt={key:value}]`      | **Entity Data** - This criteria will select entities if their NBT (entity data) matches a pattern. (note: if you do this loads of times, it might start to be a bit laggy!) |
 
 ### How are we going to use them?
 
@@ -295,10 +323,10 @@ This target selector can be used in an `execute` command to run a command as the
 entity. Try putting this in your `loop.mcfunction`:
 
 ```mcfunction:loop.mcfunction
-execute as @e[type=arrow,nbt={inGround:1b}] at @s run say I'm an arrow, I'm in the ground!
+execute as @e[type=arrow,nbt={inGround:1b}] run say I'm an arrow, I'm in the ground!
 ```
 
-Reload your datapack and fire an arrow at at a block. You should see that your
+`/reload` your datapack and fire an arrow at at a block. You should see that your
 chat is spammed with messages, meaning that we successfully selected arrows in
 the ground, and executed a command as them!
 
@@ -308,33 +336,28 @@ Now we can move onto the fun part! We have a simple command which will run
 another command as any arrow in the ground. We only need to do two things with
 this command:
 
+- Get the arrow's position
 - Spawn an explosion at the position of the arrow
 - Kill the arrow so that it only explodes once
 
-To create an explosion in Minecraft, we can simply summon a TNT entity. When a
-TNT entity is summoned, it will explode instantly.
+To create an explosion in Minecraft, we can simply summon a TNT entity that has an instant fuse length - we can do this by summoning `tnt` with the data `{fuse:0}` at the position of the arrow. We can do this using the `execute at` command, which tells the game that the `summon` command should be ran at the position of the entity, instead of at the world spawn (because all commands are run at a position in the world). This way, when we summon an entity at `~ ~ ~`, the game knows that it's referring to the position of the arrow. *This sounds complicated, but in reality, its a really easy and intuitive system when you understand it :P*
 
 ```mcfunction
-execute as @e[type=arrow,nbt={inGround:1b}] at @s run summon tnt
+execute at @e[type=arrow,nbt={inGround:1b}] run summon tnt ~ ~ ~ {fuse:0}
 ```
 
 Then, we just need to copy this command and make it kill the arrow after the
 explosion has happened. This is as simple as it sounds - we can use `/kill` to
 remove the arrow. Your finished `loop.mcfunction` should look like this:
 
 ```mcfunction:loop.mcfunction
-execute as @e[type=arrow,nbt={inGround:1b}] at @s run summon tnt
+execute as @e[type=arrow,nbt={inGround:1b}] at @s run summon tnt ~ ~ ~ {fuse:0}
 kill @e[type=arrow,nbt={inGround:1b}]
 ```
 
-:::info
+:::note
 
-In reality, this method isn't the best one to use. Instead of having two
-commands for this, you can just execute a function as the arrow which will
-summon the TNT at @s's position, and then kill @s. By only using the @e selector
-once and then referring to @s, you remove extra stress from the computer. For
-now, it doesn't matter - this guide is designed to give you a better idea of the
-logic rather than the little details.
+In reality, this method might be a bit laggy if there are a lot of `arrow`s in the world. A better system would involve creating a function which referenced `@s` (the "current" entity) instead of `@e[...]`, and then runnning that function as all `arrow`s in the ground. This way, we only use `@e[...]` once, which is a lot more efficient. However, for the purposes of this tutorial, it doesn't matter at all.
 
 :::
 
