SerenityJS

https://www.serenityjs.net/docs
Admin
SerenityJS is a robust Minecraft Bedrock Edition server software built with Rust and TypeScript,...
Tokens:25,755
Snippets:71
Trust Score:4.8
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install SerenityJS using CLI

Source: https://www.serenityjs.net/docs/index

Installs SerenityJS and scaffolds a new NodeJS project with pre-installed packages. This method works on any machine that can run NodeJS.

```bash
#npm
npm createserenity
#yarn
yarn createserenity
#pnpm
pnpm createserenity
```

--------------------------------

### Start Serenity Server

Source: https://www.serenityjs.net/docs/index

Navigates to the `devapp` directory and starts the Serenity development server. This command is used to run the application locally for development purposes.

```bash
cd devapp
yarn dev
```

--------------------------------

### Initialize Project with Yarn

Source: https://www.serenityjs.net/docs/index

Initializes the project dependencies using Yarn. This command downloads and installs all necessary packages listed in the `package.json` file.

```bash
yarn install
```

--------------------------------

### Creating a Custom Block in SerenityJS

Source: https://www.serenityjs.net/docs/index

Guide on how to create custom blocks within the SerenityJS framework. This involves defining the block's properties and behavior.

```typescript
// Example of creating a custom block (conceptual)

import { Block, BlockIdentifier } from '@serenityjs/core';

class MyCustomBlock extends Block {
  constructor(id: BlockIdentifier) {
    super(id);
    // Initialize custom block properties and behaviors
  }

  // Add custom methods or override existing ones
}

// Usage:
// const customBlock = new MyCustomBlock(BlockIdentifier.Custom);

```

--------------------------------

### Registering a Command in SerenityJS

Source: https://www.serenityjs.net/docs/index

Instructions for registering new commands in the SerenityJS environment, allowing for custom in-game commands.

```typescript
// Example of registering a command (conceptual)

import { Command } from '@serenityjs/core';

Command.register('mycommand', (player, args) => {
  player.sendMessage('You executed mycommand!');
});

// Usage in-game:
// /mycommand

```

--------------------------------

### SerenityJS Plugins

Source: https://www.serenityjs.net/docs/index

Documentation for the SerenityJS plugins module, which allows for extending the framework's capabilities. It covers plugin management, priorities, event handling, and pipeline configurations.

```javascript
enum PluginPriority {
  FIRST,
  EARLY,
  NORMAL,
  LATE,
  LAST
}

enum PluginType {
  CORE,
  PLUGIN
}

class Pipeline {
  // ...
}

class Plugin {
  // ...
}

interface PluginAfterEvents {}
interface PluginBeforeEvents {}
interface PluginOnEvents {}
interface PluginOptions {}
interface PluginPackage {}
type PluginEvents = PluginAfterEvents | PluginBeforeEvents | PluginOnEvents;

const DefaultPipelineProperties = {};
```

--------------------------------

### SerenityJS Core API Documentation

Source: https://www.serenityjs.net/docs/index

API documentation for the SerenityJS core module, including enums and classes for game development.

```APIDOC
SerenityJS Core Enums:

BlockIdentifier:
  Represents a unique identifier for a block.

BlockMaterialSound:
  Defines the sound properties for block materials.

BlockToolType:
  Specifies the tool types required to interact with blocks.

CardinalDirection:
  Enumerates the cardinal directions (North, South, East, West).

EntityIdentifier:
  Unique identifier for entities within the game.

EntityInteractMethod:
  Defines methods for entity interaction.

FacingDirection:
  Represents directions an entity or block can face.

ItemCategory:
  Categorizes items within the game.

ItemGroup:
  Groups items for organization and display.

ItemIdentifier:
  Unique identifier for items.

ItemLockMode:
  Specifies modes for locking items.

ItemToolType:
  Defines tool types associated with items.

ItemTypeToolTier:
  Represents the tier of tool an item type belongs to.

ItemWearableTier:
  Defines the wearable tier of an item.

NetworkBound:
  Indicates network binding for data or events.

ServerEvent:
  Enumerates events that can occur on the server.

ServerState:
  Defines the possible states of the server.

TimeOfDay:
  Represents different times of the day.

TorchDirection:
  Specifies the direction a torch is placed.

WorldEvent:
  Enumerates events related to the game world.

SerenityJS Core Classes:

AbilityEnum:
  Represents an enumeration of abilities.

AbilityMap:
  A map for managing abilities.

ActionForm:
  Represents a form for user actions.

ActorFlagMap:
  A map for actor flags.

Astar:
  Implementation of the A* pathfinding algorithm.

AttributeMap:
  A map for managing attributes.

BinaryHeap:
  A binary heap data structure.

Block:
  Represents a block in the game world.

BlockButtonTrait:
  Trait for blocks that function as buttons.

BlockCardinalDirectionTrait:
  Trait for blocks with cardinal direction properties.

BlockCommandBlockTrait:
  Trait for command blocks.

BlockContainer:
  Represents a container block.

BlockCraftingTableTrait:
  Trait for crafting table blocks.

BlockDirectionTrait:
  Trait for blocks with directional properties.

BlockEnum:
  Represents an enumeration of blocks.

BlockFacingDirection:
  Represents a block's facing direction.

BlockInventoryTrait:
  Trait for blocks with inventory functionality.

BlockLevelStorage:
  Manages block data storage at the level.

BlockOpenBitTrait:
  Trait for blocks with an open bit property.

BlockPalette:
  Manages a palette of blocks.

BlockPermutation:
  Represents a permutation of a block's states.
```

--------------------------------

### SerenityJS Core Classes Overview

Source: https://www.serenityjs.net/docs/index

This section provides an overview of the classes available in the SerenityJS core module. It includes classes for managing game items, their properties, and related functionalities, as well as data persistence and loot generation.

```APIDOC
Form:
  Represents a form in the SerenityJS framework.

GamemodeEnum:
  An enumeration for game modes.

IntegerEnum:
  An enumeration for integer values.

InternalProvider:
  An internal data provider.

ItemDrop:
  Represents an item drop in the game.

ItemEnum:
  An enumeration for item types.

ItemPalette:
  Manages item palettes.

ItemStack:
  Represents a stack of items.
  - ItemStackBundleTrait: Trait for item stacks that are bundles.
  - ItemStackDamagedSignal: Signal for item stack damage events.
  - ItemStackDisplayTrait: Trait for displaying item stacks.
  - ItemStackDurabilityTrait: Trait for item stack durability.
  - ItemStackEnchantableTrait: Trait for enchantable item stacks.
  - ItemStackFoodTrait: Trait for food item stacks.
  - ItemStackKeepOnDieTrait: Trait for items that persist on death.
  - ItemStackLevelStorage: Storage for item stack levels.
  - ItemStackLiquidContainerTrait: Trait for liquid container item stacks.
  - ItemStackLockTrait: Trait for locked item stacks.
  - ItemStackShooterTrait: Trait for item stacks that can be used as shooters.
  - ItemStackSignTrait: Trait for item stacks with signs.
  - ItemStackSpawnEggTrait: Trait for spawn egg item stacks.
  - ItemStackTrait: Base trait for item stacks.
  - ItemStackWeaponTrait: Trait for weapon item stacks.
  - ItemStackWearableTrait: Trait for wearable item stacks.

ItemType:
  Represents the type of an item.
  - ItemTypeBlockPlacerComponent: Component for block placer functionality.
  - ItemTypeCanDestroyInCreativeComponent: Component for items that can be destroyed in creative mode.
  - ItemTypeComponent: Base component for item types.
  - ItemTypeComponentCollection: Collection of item type components.
  - ItemTypeCooldownComponent: Component for item cooldowns.
  - ItemTypeDamageComponent: Component for item damage.
  - ItemTypeDiggerComponent: Component for item digging functionality.
  - ItemTypeDisplayNameComponent: Component for item display names.
  - ItemTypeDurabilityComponent: Component for item durability.
  - ItemTypeFoodComponent: Component for food properties.
  - ItemTypeHandEquippedComponent: Component for hand-equipped items.
  - ItemTypeIconComponent: Component for item icons.
  - ItemTypeItemPropertiesComponent: Component for general item properties.
  - ItemTypeMaxStackComponent: Component for maximum stack size.
  - ItemTypeUseModifiersComponent: Component for item use modifiers.
  - ItemTypeWearableComponent: Component for wearable items.

JsonObjectEnum:
  An enumeration for JSON object types.

LevelDBProvider:
  A data provider using LevelDB for storage.

LootPool:
  Defines a pool of loot.

LootTable:
  Represents a loot table for generating drops.
```

--------------------------------

### SerenityJS Core Item Interfaces

Source: https://www.serenityjs.net/docs/index

Provides documentation for interfaces related to ItemStack properties, display options, usage scenarios, and component configurations for items.

```APIDOC
ItemStackDisplayTraitOptions:
  Description: Options for customizing the display of an ItemStack.
  Properties:
    - name: string (Optional) - Custom name for the item.
    - lore: string[] (Optional) - Lore lines for the item.
    - hideFlags: number (Optional) - Flags to hide certain item attributes.

ItemStackDroppedOptions:
  Description: Options for when an ItemStack is dropped.
  Properties:
    - chance: number (Optional) - The chance of dropping the item (0-1).
    - count: number (Optional) - The number of items to drop.

ItemStackOptions:
  Description: General options for an ItemStack.
  Properties:
    - type: string - The type identifier of the item.
    - count: number - The number of items in the stack.
    - nbt: object (Optional) - Custom NBT data for the item.

ItemStackUseOnBlockOptions:
  Description: Options for using an ItemStack on a block.
  Properties:
    - face: string - The face of the block the item is used on.
    - position: { x: number, y: number, z: number } - The position of the block.

ItemStackUseOnEntityOptions:
  Description: Options for using an ItemStack on an entity.
  Properties:
    - entity: object - The entity the item is used on.

ItemStackUseOptions:
  Description: General options for using an ItemStack.
  Properties:
    - hand: string - The hand used to hold the item.

ItemStackWearableTraitProperties:
  Description: Properties for an ItemStack's wearable trait.
  Properties:
    - slot: string - The equipment slot the item occupies.

ItemTypeBlockPlacerComponentOptions:
  Description: Options for an item that places blocks.
  Properties:
    - blockType: string - The type of block to place.

ItemTypeCooldownComponentOptions:
  Description: Options for an item's cooldown.
  Properties:
    - cooldown: number - The cooldown duration in ticks.

ItemTypeDiggerComponentOptions:
  Description: Options for an item that digs blocks.
  Properties:
    - speed: number - The digging speed modifier.
    - canHarvest: string[] - Array of block types the item can harvest.

ItemTypeDurabilityComponentOptions:
  Description: Options for an item's durability.
  Properties:
    - maxDurability: number - The maximum durability of the item.
    - damageChance: ItemTypeDurabilityDamageChance - Configuration for damage chance.

ItemTypeDurabilityDamageChance:
  Description: Configuration for when an item takes durability damage.
  Properties:
    - onUse: number (Optional) - Chance of damage when used.
    - onBreak: number (Optional) - Chance of damage when breaking a block.

ItemTypeFoodComponentOptions:
  Description: Options for an item that can be eaten.
  Properties:
    - nutrition: number - The nutrition value.
    - saturation: number - The saturation modifier.
    - eatTime: number - The time it takes to eat the item.

ItemTypeIconComponentOptions:
  Description: Options for an item's icon.
  Properties:
    - textureLocation: string - The texture path for the item's icon.

ItemTypeOptions:
  Description: General options for an ItemType.
  Properties:
    - id: string - The unique identifier for the item type.
    - name: string - The display name of the item type.
    - maxStackSize: number - The maximum stack size for the item.
    - components: object - An object containing various item components.

ItemTypeUseModifiersComponentOptions:
  Description: Options for modifiers when using an item.
  Properties:
    - speedModifier: number - Modifier for the use speed.

ItemTypeWearableComponentOptions:
  Description: Options for an item that can be worn.
  Properties:
    - slot: string - The equipment slot for the wearable item.

ItemWeaponComponent:
  Description: Represents an item that can be used as a weapon.
  Properties:
    - damage: number - The base damage dealt by the weapon.
    - speed: number - The attack speed of the weapon.

JSONLikeObject:
  Description: Represents an object that is similar to JSON.
  Properties:
    - [key: string]: any - Arbitrary key-value pairs.

```

--------------------------------

### SerenityJS Core API Reference

Source: https://www.serenityjs.net/docs/index

Comprehensive API documentation for the SerenityJS core module. This includes details on various classes such as BlockPermutationUpdateSignal, BlockPillarAxisTrait, BlockSignTrait, BlockStorage, BlockType, Command, ConsoleInterface, Container, and more. Each entry provides information on class methods, properties, and their usage within the SerenityJS framework.

```APIDOC
BlockPermutationUpdateSignal:
  Description: Represents a signal emitted when a block permutation is updated.
  Methods:
    connect(callback: (block: Block) => void, context?: any): void
      Connects a callback function to the signal.
      Parameters:
        callback: The function to call when the signal is emitted.
        context: Optional context for the callback.
    disconnect(callback: (block: Block) => void, context?: any): void
      Disconnects a callback function from the signal.
      Parameters:
        callback: The function to disconnect.
        context: Optional context for the callback.

BlockPillarAxisTrait:
  Description: Trait for blocks that have a pillar axis.
  Properties:
    axis: 'x' | 'y' | 'z'
      The axis of the pillar.

BlockSignTrait:
  Description: Trait for blocks that function as signs.
  Methods:
    getText(): string
      Gets the text displayed on the sign.
    setText(text: string): void
      Sets the text displayed on the sign.

BlockStorage:
  Description: Manages the storage and retrieval of block data.
  Methods:
    getBlock(x: number, y: number, z: number): Block | undefined
      Retrieves the block at the specified coordinates.
    setBlock(x: number, y: number, z: number, block: Block): void
      Sets the block at the specified coordinates.

BlockType:
  Description: Represents a type of block in the game.
  Properties:
    id: string
      The unique identifier for the block type.
    displayName: string
      The display name of the block type.
    components: { [key: string]: BlockTypeComponent }
      A collection of components associated with the block type.

Command:
  Description: Represents a game command.
  Methods:
    execute(args: string[]): void
      Executes the command with the given arguments.

ConsoleInterface:
  Description: Interface for interacting with the game console.
  Methods:
    log(message: string): void
      Logs a message to the console.
    error(message: string): void
      Logs an error message to the console.

Container:
  Description: Represents an inventory or storage container.
  Methods:
    addItem(item: Item, quantity: number): void
      Adds items to the container.
    removeItem(item: Item, quantity: number): void
      Removes items from the container.


```

--------------------------------

### SerenityJS Core Resource and Property Interfaces

Source: https://www.serenityjs.net/docs/index

This section details interfaces related to resource management and server properties within the SerenityJS core library. These include definitions for resource manifests, pack properties, and server configurations.

```typescript
interface ResourceManifest {}
interface ResourcePackEntry {}
interface ResourcePacksProperties {}
interface ResourcesProperties {}
interface RideableSeatOptions {}
interface SerenityProperties {}
interface ServerEvents {}
interface ServerProperties {}
```

--------------------------------

### SerenityJS Core Command and Recipe Interfaces

Source: https://www.serenityjs.net/docs/index

This section details interfaces related to commands and crafting recipes within the SerenityJS core library. It includes definitions for command overloads and crafting recipe ingredients.

```typescript
interface CommandOverload {}
interface CraftingRecipeIngredient {}
```

--------------------------------

### SerenityJS RakNet API Documentation

Source: https://www.serenityjs.net/docs/index

Comprehensive API documentation for the SerenityJS RakNet module, covering enums, classes, interfaces, variables, and functions. This documentation is generated using TypeDoc.

```APIDOC
Module: _serenityjs_raknet

Enums:
  Bitflags: Represents bitflags used in RakNet.
  Packet: Represents different types of RakNet packets.
  Priority: Represents packet priority levels.
  Reliability: Represents packet reliability types.
  Status: Represents the status of a RakNet connection or operation.

Classes:
  Ack: Represents an acknowledgment packet.
  Address: Represents a network address.
  BasePacket: Base class for all RakNet packets.
  ConnectedPing: Represents a connected ping packet.
  ConnectedPong: Represents a connected pong packet.
  Connection: Manages a RakNet connection.
  ConnectionRequest: Represents a connection request packet.
  ConnectionRequestAccepted: Represents a connection request accepted packet.
  Disconnect: Represents a disconnect packet.
  Frame: Represents a RakNet frame.
  FrameSet: Represents a set of RakNet frames.
  IncompatibleProtocolVersion: Represents an incompatible protocol version packet.
  Magic: Represents the RakNet magic number.
  MTU: Represents the Maximum Transmission Unit.
  Nack: Represents a negative acknowledgment packet.
  NewIncomingConnection: Represents a new incoming connection packet.
  Offline: Represents an offline message.
  OpenConnectionReply1: Represents the first reply to an open connection request.
  OpenConnectionReply2: Represents the second reply to an open connection request.
  OpenConnectionRequest1: Represents the first request to open a connection.
  OpenConnectionRequest2: Represents the second request to open a connection.
  Server: Manages a RakNet server.
  SystemAddress: Represents a system network address.
  UnconnectedPing: Represents an unconnected ping packet.
  UnconnectedPong: Represents an unconnected pong packet.

Interfaces:
  NetworkIdentifier: Identifies a network endpoint.
  PacketDataTypeOptions: Options for packet data types.
  PacketMetadata: Metadata associated with a RakNet packet.
  RaknetEvents: Defines events emitted by the RakNet module.
  RaknetServerProperties: Properties for configuring a RakNet server.

Variables:
  DGRAM_HEADER_SIZE: The header size for datagrams.
  DGRAM_MTU_OVERHEAD: Overhead for datagrams based on MTU.
  MAX_MTU_SIZE: The maximum allowed MTU size.
  MIN_MTU_SIZE: The minimum allowed MTU size.
  RAKNET_PROTOCOL: The RakNet protocol version.
  RAKNET_TICK_LEN: The length of a RakNet tick.
  RAKNET_TPS: Ticks per second for RakNet.
  UDP_HEADER_SIZE: The header size for UDP packets.

Functions:
  Proto: Serializes and deserializes data according to RakNet protocol.
  Serialize: Serializes data for RakNet transmission.
```

--------------------------------

### SerenityJS Protocol Variables and Functions

Source: https://www.serenityjs.net/docs/index

Provides access to constants and utility functions for the SerenityJS protocol, including Minecraft version information, packet IDs, and network constants.

```typescript
import { DefaultAbilityValues } from "@serenityjs/protocol";
import { MINECRAFT_TICK_SPEED } from "@serenityjs/protocol";
import { MINECRAFT_VERSION } from "@serenityjs/protocol";
import { PacketPool } from "@serenityjs/protocol";
import { Packets } from "@serenityjs/protocol";
import { PROTOCOL_VERSION } from "@serenityjs/protocol";
import { SHIELD_NETWORK_ID } from "@serenityjs/protocol";
import { getPacketId } from "@serenityjs/protocol";

// Example usage:
console.log(`Minecraft Version: ${MINECRAFT_VERSION}`);
const packetId = getPacketId(Packets.Login);
console.log(`Login Packet ID: ${packetId}`);

```

--------------------------------

### SerenityJS Core Type Definitions

Source: https://www.serenityjs.net/docs/index

This section provides API documentation for various type definitions within the SerenityJS core library. These types represent game elements, states, and configurations.

```APIDOC
BigDripleafTilt:
  Represents the tilt state of a big dripleaf.

BlockTypeDefinition:
  Defines the properties and behaviors of a block type.

BlockTypeMaterialInstancesComponentOptions:
  Options for configuring material instances for block types.

CauldronLiquid:
  Represents the type and level of liquid in a cauldron.

ChemistryTableType:
  Defines the type of chemistry table.

ChiselType:
  Represents the type of chisel.

CommandArguments:
  Defines the structure for command arguments.

CommandCallback:
  A callback function for handling commands.

CommandContext:
  Provides context for command execution.

CommandRegistryCallback:
  A callback function for registering commands.

CommandResponse:
  Defines the response structure for commands.

CoralColor:
  Represents the color of coral.

CrackedState:
  Indicates the cracked state of a block.

Damage:
  Represents damage applied to an entity.

DoublePlantType:
  Defines the type of double plant.

DripstoneThickness:
  Represents the thickness of dripstone.

FileMap:
  A mapping of file identifiers to file paths.

FlowerType:
  Defines the type of flower.

FormResult:
  Represents the result of a form submission.

GenericBlockState:
  A generic representation of a block's state.

JSONLikeArray:
  Represents an array-like structure that can contain JSON-like values.

JSONLikeValue:
  Represents a value that can be a primitive or a nested JSON-like structure.

LeverDirection:
  Defines the direction a lever is facing.

MinecraftblockFace:
  Represents a face of a Minecraft block.

MinecraftcardinalDirection:
  Represents a cardinal direction in Minecraft.

MinecraftfacingDirection:
  Represents a facing direction in Minecraft.

MinecraftverticalHalf:
  Represents the vertical half of a block.

MonsterEggStoneType:
  Defines the type of monster egg stone.

NewLeafType:
  Represents a new type of leaf.

NewLogType:
  Represents a new type of log.

Orientation:
  Defines the orientation of an object.

PillarAxis:
  Represents the axis of a pillar.

PortalAxis:
  Defines the axis of a portal.

PrismarineBlockType:
  Represents the type of prismarine block.

SandStoneType:
  Defines the type of sandstone.

SandType:
  Represents the type of sand.

SaplingType:
  Defines the type of sapling.

SeaGrassType:
  Represents the type of sea grass.

SpongeType:
  Defines the type of sponge.

StoneBrickType:
  Represents the type of stone brick.

StoneSlabType:
  Defines the type of stone slab.

StoneSlabType2:
  Defines a second set of stone slab types.

StoneSlabType3:
  Defines a third set of stone slab types.

StoneSlabType4:
  Defines a fourth set of stone slab types.

StructureBlockType:
  Represents the type of structure block.

StructureVoidType:
  Represents a structure void type.

TallGrassType:
  Defines the type of tall grass.

TorchFacingDirection:
  Represents the facing direction of a torch.

TurtleEggCount:
  Indicates the number of turtle eggs.

VaultState:
  Represents the state of a vault.

WallBlockType:
  Defines the type of wall block.
```

--------------------------------

### SerenityJS Protocol Packet Documentation

Source: https://www.serenityjs.net/docs/index

This section details various packets and data structures used in the SerenityJS protocol. It includes classes for handling level events, player movements, network configurations, and item/block data.

```APIDOC
LevelEventPacket:
  Represents an event occurring at the level.

LevelSoundEventPacket:
  Represents a sound event occurring at the level.

LoginPacket:
  Packet sent during the login process.

LoginTokens:
  Contains authentication tokens for login.

MapCreationBits:
  Bits related to map creation.

MapDecoration:
  Data for map decorations.

MapDecorationBits:
  Bits related to map decorations.

MapInfoRequestPacket:
  Packet requesting map information.

MapPixel:
  Represents a pixel on the map.

MapScale:
  Information about map scaling.

MapTextureUpdateBits:
  Bits for updating map textures.

MapTrackedItems:
  Items tracked on the map.

MaterialReducerDataEntry:
  An entry in the material reducer data.

Materials:
  Information about materials.

MobArmorEquipmentPacket:
  Packet detailing mob armor equipment.

MobEffectPacket:
  Packet detailing mob effects.

MobEquipmentPacket:
  Packet detailing mob equipment.

ModalFormCanceled:
  Indicates a modal form was canceled.

ModalFormData:
  Data for a modal form.

ModalFormRequestPacket:
  Packet requesting a modal form.

ModalFormResponsePacket:
  Packet containing a response to a modal form.

MotionPredictHintsPacket:
  Hints for motion prediction.

MoveActorAbsolutePacket:
  Packet for moving an actor to an absolute position.

MoveActorDeltaPacket:
  Packet for moving an actor by a delta.

MovementEffectPacket:
  Packet for movement effects.

MovePlayerPacket:
  Packet for player movement.

NbtLoop:
  Represents a loop in NBT data.

NetworkBlockTypeDefinition:
  Definition for a network block type.

NetworkChunkPublisherUpdatePacket:
  Packet updating network chunk publishers.

NetworkItemInstanceDescriptor:
  Descriptor for a network item instance.

NetworkItemStackDescriptor:
  Descriptor for a network item stack.

NetworkSettingsPacket:
  Packet containing network settings.

NetworkStackLatencyPacket:
  Packet for network stack latency.

NpcDialoguePacket:
  Packet for NPC dialogue.

NpcRequestPacket:
  Packet for NPC requests.

OnScreenTextureAnimationPacket:
  Packet for on-screen texture animation.

OpenSignPacket:
  Packet for opening a sign.

PacketViolationWarningPacket:
  Packet warning about packet violations.

PackLinks:
  Links related to packs.

Patterns:
  Information about patterns.

PlayerActionPacket:
  Packet detailing a player action.

PlayerAuthInputData:
  Data for player authentication input.

PlayerAuthInputPacket:
  Packet for player authentication input.

PlayerAuthInputTransaction:
  Transaction for player authentication input.
```

--------------------------------

### SerenityJS Core Item Interfaces

Source: https://www.serenityjs.net/docs/index

This section documents item interfaces available in the SerenityJS core library. Currently, only the BinaryItem interface is listed, which likely represents an item with binary data or properties.

```APIDOC
BinaryItem:
  Represents an item with binary data or properties.
```

--------------------------------

### SerenityJS Protocol Packet Definitions

Source: https://www.serenityjs.net/docs/index

This section provides API documentation for various packet structures within the SerenityJS protocol. These packets are used for network communication, managing game state, player actions, and resource synchronization.

```APIDOC
PlayerAuthItemStackRequest:
  Represents a request related to player authentication and item stacks.

PlayerBlockActionData:
  Data structure for player block actions.

PlayerBlockActions:
  Container for player block action data.

PlayerEnchantOptionsPacket:
  Packet for player enchantment options.

PlayerFogPacket:
  Packet for controlling player fog settings.

PlayerHotbarPacket:
  Packet related to the player's hotbar.

PlayerInputTick:
  Represents a tick of player input.

PlayerListPacket:
  Packet for managing the player list.

PlayerListRecord:
  A record entry in the player list.

PlayerSkinPacket:
  Packet for player skin data.

PlayerStartItemCooldownPacket:
  Packet to start an item cooldown for the player.

PlayerUpdateEntityOverridesPacket:
  Packet for updating entity overrides.

PlayerUpdateEntityOverridesValue:
  Value for entity override updates.

PlaySoundPacket:
  Packet for playing a sound.

PlayStatusPacket:
  Packet indicating the play status.

PostFixes:
  Defines post-fixes.

PotionMixDataEntry:
  An entry for potion mixing data.

PropertySyncData:
  Data for synchronizing properties.

RecipeIngredient:
  Represents an ingredient in a recipe.

RecipeUnlockingRequirement:
  Requirement for unlocking a recipe.

RemoveEntityPacket:
  Packet to remove an entity.

RemoveObjectivePacket:
  Packet to remove a scoreboard objective.

RequestChunkRadiusPacket:
  Packet to request a chunk radius.

RequestedResourcePack:
  Information about a requested resource pack.

RequestNetworkSettingsPacket:
  Packet to request network settings.

RequestPermissionsPacket:
  Packet to request permissions.

ResourceIdVersions:
  Versions for resource IDs.

ResourcePackChunkDataPacket:
  Packet containing resource pack chunk data.

ResourcePackChunkRequestPacket:
  Packet to request a resource pack chunk.

ResourcePackClientResponsePacket:
  Client response for resource packs.

ResourcePackDataInfoPacket:
  Packet with resource pack data information.

ResourcePackDescriptor:
  Descriptor for a resource pack.

ResourcePacksClientRequest:
  Client request for resource packs.

ResourcePacksInfoPacket:
  Packet containing resource pack information.

ResourcePackStackPacket:
  Packet defining the resource pack stack.

RespawnPacket:
  Packet for player respawn.

RiderJumpPacket:
  Packet for a rider jump action.

Rotation:
  Represents a rotation.

RotationByte:
  Represents a rotation using bytes.

ScoreboardIdentity:
  Identity for scoreboard entries.

ScoreEntry:
  An entry in the scoreboard.

ScriptDebugShape:
  Shape for script debugging.

ScriptMessagePacket:
  Packet for script messages.
```

--------------------------------

### SerenityJS Core Block Interfaces

Source: https://www.serenityjs.net/docs/index

This section provides documentation for various block interfaces available in the SerenityJS Core library. Each interface represents a specific type of block, detailing its properties and potential uses within a game development context.

```typescript
interface BubbleCoralBlockBlock {}
interface BubbleCoralFanBlock {}
interface BubbleCoralWallFanBlock {}
interface CactusBlock {}
interface CakeBlock {}
interface CalibratedSculkSensorBlock {}
interface CampfireBlock {}
interface CandleBlock {}
interface CandleCakeBlock {}
interface CarrotsBlock {}
interface CarvedPumpkinBlock {}
interface CauldronBlock {}
interface CaveVinesBlock {}
interface CaveVinesBodyWithBerriesBlock {}
interface CaveVinesHeadWithBerriesBlock {}
interface ChainBlock {}
interface ChainCommandBlockBlock {}
interface ChemistryTableBlock {}
interface CherryButtonBlock {}
interface CherryDoorBlock {}
interface CherryDoubleSlabBlock {}
interface CherryFenceGateBlock {}
interface CherryHangingSignBlock {}
interface CherryLeavesBlock {}
interface CherryLogBlock {}
interface CherryPressurePlateBlock {}
interface CherrySaplingBlock {}
interface CherrySlabBlock {}
interface CherryStairsBlock {}
interface CherryStandingSignBlock {}
interface CherryTrapdoorBlock {}
interface CherryWallSignBlock {}
interface CherryWoodBlock {}
interface ChestBlock {}
interface ChippedAnvilBlock {}
interface ChiseledBookshelfBlock {}
interface ChiseledQuartzBlockBlock {}
interface ChiseledRedSandstoneBlock {}
interface ChiseledSandstoneBlock {}
interface ChiseledStoneBricksBlock {}
interface ChorusFlowerBlock {}
interface CobbledDeepslateDoubleSlabBlock {}
interface CobbledDeepslateSlabBlock {}
interface CobbledDeepslateStairsBlock {}
```

--------------------------------

### SerenityJS Core Types and Variables

Source: https://www.serenityjs.net/docs/index

This section details core types and variables within the SerenityJS framework, including wall connection types, block traits, command definitions, and default properties for dimensions, items, resources, and world providers. It also covers entity and item stack traits, item type components, and operator commands.

```typescript
import { WallConnectionTypeEast, WallConnectionTypeNorth, WallConnectionTypeSouth, WallConnectionTypeWest } from '@serenityjs/core';
import { BlockTraits, CommonCommands, DefaultDimensionProperties, DefaultItemStackOptions, DefaultResourcesProperties, DefaultWorldProviderProperties, EntityTraits, Handlers, ItemStackTraits, ItemTypeComponents, OperatorCommands } from '@serenityjs/core';

// Example usage of WallConnectionTypeEast
let eastConnection: WallConnectionTypeEast;

// Example usage of BlockTraits
let blockData: typeof BlockTraits;

// Example usage of CommonCommands
let commands: typeof CommonCommands;

// Example usage of DefaultDimensionProperties
let dimensionProps: typeof DefaultDimensionProperties;

// Example usage of DefaultItemStackOptions
let itemStackOptions: typeof DefaultItemStackOptions;

// Example usage of DefaultResourcesProperties
let resourceProps: typeof DefaultResourcesProperties;

// Example usage of DefaultWorldProviderProperties
let worldProviderProps: typeof DefaultWorldProviderProperties;

// Example usage of EntityTraits
let entityData: typeof EntityTraits;

// Example usage of Handlers
let handlerRegistry: typeof Handlers;

// Example usage of ItemStackTraits
let itemStackData: typeof ItemStackTraits;

// Example usage of ItemTypeComponents
let itemComponents: typeof ItemTypeComponents;

// Example usage of OperatorCommands
let operatorCmds: typeof OperatorCommands;

// Example usage of Worker function
// import { Worker } from '@serenityjs/core';
// Worker(...);
```

--------------------------------

### SerenityJS Core Block Interfaces

Source: https://www.serenityjs.net/docs/index

Documentation for various block types and related interfaces in the SerenityJS core library, including functional blocks and decorative blocks.

```APIDOC
JigsawBlock:
  Description: Represents a Jigsaw block.

JungleButtonBlock:
  Description: Represents a Jungle Button block.

JungleDoorBlock:
  Description: Represents a Jungle Door block.

JungleDoubleSlabBlock:
  Description: Represents a Jungle Double Slab block.

JungleFenceGateBlock:
  Description: Represents a Jungle Fence Gate block.

JungleHangingSignBlock:
  Description: Represents a Jungle Hanging Sign block.

JungleLeavesBlock:
  Description: Represents Jungle Leaves block.

JungleLogBlock:
  Description: Represents a Jungle Log block.

JunglePressurePlateBlock:
  Description: Represents a Jungle Pressure Plate block.

JungleSaplingBlock:
  Description: Represents a Jungle Sapling block.

JungleSlabBlock:
  Description: Represents a Jungle Slab block.

JungleStairsBlock:
  Description: Represents a Jungle Stairs block.

JungleStandingSignBlock:
  Description: Represents a Jungle Standing Sign block.

JungleTrapdoorBlock:
  Description: Represents a Jungle Trapdoor block.

JungleWallSignBlock:
  Description: Represents a Jungle Wall Sign block.

JungleWoodBlock:
  Description: Represents a Jungle Wood block.

KelpBlock:
  Description: Represents a Kelp block.

LadderBlock:
  Description: Represents a Ladder block.

LanternBlock:
  Description: Represents a Lantern block.

LargeAmethystBudBlock:
  Description: Represents a Large Amethyst Bud block.

LargeFernBlock:
  Description: Represents a Large Fern block.

LavaBlock:
  Description: Represents a Lava block.

LecternBlock:
  Description: Represents a Lectern block.

LeverBlock:
  Description: Represents a Lever block.

```

--------------------------------

### SerenityJS Core Player and Sound Interfaces

Source: https://www.serenityjs.net/docs/index

Defines interfaces for player-related properties and options for playing sounds within the SerenityJS core library. These are essential for managing player state and audio feedback.

```typescript
interface PlayerCombatProperty {}
interface PlayerProperties {}
interface PlaySoundOptions {}
```

--------------------------------

### Serenity.js Core Player Classes

Source: https://www.serenityjs.net/docs/index

This section details various classes related to player management and interactions within Serenity.js. It includes classes for player abilities, signals, traits, and data storage.

```APIDOC
PlayerAbilityUpdateSignal:
  Represents a signal emitted when a player's abilities are updated.

PlayerBreakBlockSignal:
  Represents a signal emitted when a player breaks a block.

PlayerChatSignal:
  Represents a signal emitted when a player sends a chat message.

PlayerChunkRenderingTrait:
  A trait for managing player chunk rendering.

PlayerClosedContainerSignal:
  Represents a signal emitted when a player closes a container.

PlayerCombatTrait:
  A trait for managing player combat.

PlayerCommandExecutorTrait:
  A trait for executing player commands.

PlayerContainerInteractionSignal:
  Represents a signal emitted during player container interactions.

PlayerCraftingInputTrait:
  A trait for managing player crafting input.

PlayerCursorTrait:
  A trait for managing the player's cursor.

PlayerEntityRenderingTrait:
  A trait for managing player entity rendering.

PlayerGamemodeChangeSignal:
  Represents a signal emitted when a player's gamemode changes.

PlayerHungerTrait:
  A trait for managing player hunger.

PlayerInitializedSignal:
  Represents a signal emitted when a player is initialized.

PlayerInteractWithBlockSignal:
  Represents a signal emitted when a player interacts with a block.

PlayerInteractWithEntitySignal:
  Represents a signal emitted when a player interacts with an entity.

PlayerJoinSignal:
  Represents a signal emitted when a player joins the game.

PlayerLeaveSignal:
  Represents a signal emitted when a player leaves the game.

PlayerLevelStorage:
  Manages player level data.

PlayerListTrait:
  A trait for managing the player list.

PlayerOpenedContainerSignal:
  Represents a signal emitted when a player opens a container.

PlayerPlaceBlockSignal:
  Represents a signal emitted when a player places a block.

PlayerStartEmotingSignal:
  Represents a signal emitted when a player starts emoting.

PlayerStartUsingItemSignal:
  Represents a signal emitted when a player starts using an item.

PlayerStopEmotingSignal:
  Represents a signal emitted when a player stops emoting.

PlayerStopUsingItemSignal:
  Represents a signal emitted when a player stops using an item.

PlayerTrait:
  A base trait for player-related functionality.

PlayerUseItemOnBlockSignal:
  Represents a signal emitted when a player uses an item on a block.

PlayerUseItemOnEntitySignal:
  Represents a signal emitted when a player uses an item on an entity.

PlayerUseItemSignal:
  Represents a signal emitted when a player uses an item.
```

--------------------------------

### SerenityJS Core Block Interfaces

Source: https://www.serenityjs.net/docs/index

This section details various block interfaces available in the SerenityJS core library. These interfaces define the properties and methods for interacting with different block types in a Minecraft-like environment. They are organized by block material and specific variations.

```typescript
interface DarkOakDoorBlock {}
interface DarkOakDoubleSlabBlock {}
interface DarkOakFenceGateBlock {}
interface DarkOakHangingSignBlock {}
interface DarkOakLeavesBlock {}
interface DarkOakLogBlock {}
interface DarkOakPressurePlateBlock {}
interface DarkOakSaplingBlock {}
interface DarkOakSlabBlock {}
interface DarkOakStairsBlock {}
interface DarkoakStandingSignBlock {}
interface DarkOakTrapdoorBlock {}
interface DarkoakWallSignBlock {}
interface DarkOakWoodBlock {}
interface DarkPrismarineBlock {}
interface DarkPrismarineDoubleSlabBlock {}
interface DarkPrismarineSlabBlock {}
interface DarkPrismarineStairsBlock {}
interface DaylightDetectorBlock {}
interface DaylightDetectorInvertedBlock {}
interface DeadBrainCoralBlock {}
interface DeadBrainCoralBlockBlock {}
interface DeadBrainCoralFanBlock {}
interface DeadBrainCoralWallFanBlock {}
interface DeadBubbleCoralBlock {}
interface DeadBubbleCoralBlockBlock {}
interface DeadBubbleCoralFanBlock {}
interface DeadBubbleCoralWallFanBlock {}
interface DeadFireCoralBlock {}
interface DeadFireCoralBlockBlock {}
interface DeadFireCoralFanBlock {}
interface DeadFireCoralWallFanBlock {}
interface DeadHornCoralBlock {}
interface DeadHornCoralBlockBlock {}
interface DeadHornCoralFanBlock {}
interface DeadHornCoralWallFanBlock {}
interface DeadTubeCoralBlock {}
interface DeadTubeCoralBlockBlock {}
interface DeadTubeCoralFanBlock {}
interface DeadTubeCoralWallFanBlock {}
interface DecoratedPotBlock {}
interface DeepslateBlock {}
interface DeepslateBrickDoubleSlabBlock {}
```

--------------------------------

### Build TypeScript Project

Source: https://www.serenityjs.net/docs/index

Compiles the TypeScript code into JavaScript, making it executable. This step is necessary because the project is written in TypeScript.

```bash
yarn build
```

--------------------------------

### SerenityJS Core World and Event Interfaces

Source: https://www.serenityjs.net/docs/index

This section covers interfaces related to the game world and its events within the SerenityJS core library. It includes definitions for world properties, provider properties, and signals for world events.

```typescript
interface WorldEventSignals {}
interface WorldProperties {}
interface WorldProviderProperties {}
```

--------------------------------

### SerenityJS Protocol Packet Documentation

Source: https://www.serenityjs.net/docs/index

This section documents various packets and data structures defined within the SerenityJS protocol. It covers entities, attributes, commands, blocks, and more, providing details on their structure and purpose in game communication.

```APIDOC
AnimateEntityPacket:
  Represents an animation event for an entity.

AnimatePacket:
  Represents a general animation event.

Attribute:
  Represents an attribute of an entity or object.

AttributeModifier:
  Represents a modifier applied to an attribute.

AvailableActorIdentifiersPacket:
  Packet containing available actor identifiers.

AvailableCommandsPacket:
  Packet containing available commands.

AwardAchievementPacket:
  Packet for awarding achievements.

BehaviorPackInfo:
  Information about a behavior pack.

BiomeDefinitionListPacket:
  Packet containing biome definitions.

BlockAction:
  Represents an action performed on a block.

BlockActorDataPacket:
  Packet containing data for block actors.

BlockEventPacket:
  Packet for block events.

BlockPickRequestPacket:
  Packet for requesting block picking.

BlockPosition:
  Represents the position of a block.

BlockUpdate:
  Represents an update to a block.

BookActions:
  Actions related to books.

BookEditPacket:
  Packet for editing books.

BossEventAdd:
  Packet for adding a boss event.

BossEventPacket:
  General packet for boss events.

BossEventUpdate:
  Packet for updating boss events.

ByteArray:
  Represents a byte array.

CameraFadeDuration:
  Duration for camera fade effects.

CameraFadeInstruction:
  Instruction for camera fade.

CameraInstructions:
  A set of camera instructions.

CameraInstructionsPacket:
  Packet containing camera instructions.

CameraPreset:
  A predefined camera setting.

CameraPresetsPacket:
  Packet containing camera presets.

CameraSetEasing:
  Instruction for setting camera easing.

CameraSetInstruction:
  Instruction for setting camera.

CameraShakePacket:
  Packet for camera shake effects.

ChainedSubcommandValues:
  Values for chained subcommands.

ChangeDimensionPacket:
  Packet for changing dimensions.

ChunkCoords:
  Coordinates for a chunk.

ChunkRadiusUpdatePacket:
  Packet for updating chunk radius.

ClientboundCloseFormPacket:
  Packet to close a client form.

ClientBoundDebugRendererPacket:
  Packet for the client-side debug renderer.

ClientBoundMapItemDataPacket:
  Packet containing map item data.

ClientCacheStatusPacket:
  Packet indicating client cache status.

ClientPredictedVehicle:
  Represents a predicted vehicle state for the client.

ClientToServerHandshakePacket:
  Packet for client-to-server handshake.

Color:
  Represents an RGBA color.

CommandBlockActorRuntimeId:
  Runtime ID for a command block actor.

CommandBlockSettings:
  Settings for a command block.

CommandBlockUpdatePacket:
  Packet for updating command blocks.
```

--------------------------------

### SerenityJS Protocol Definitions

Source: https://www.serenityjs.net/docs/index

Documentation for SerenityJS's protocol module, which defines the data structures and enums used for Minecraft network communication. This includes various enums for abilities, events, damage causes, and more.

```javascript
enum AbilityIndex {}
enum AbilityLayerType {}
enum AbilitySetId {}
enum ActorDamageCause {}
enum ActorDataId {}
enum ActorDataType {}
enum ActorEvent {}
enum ActorFlag {}
enum ActorLinkType {}
enum AnimateId {}
enum AttributeName {}
enum BlockEventType {}
enum BlockFace {}
enum BookEditAction {}
enum BossEventColor {}
enum BossEventUpdateType {}
enum CameraAudioListener {}
enum ClientInputLocksFlag {}
enum CommandBlockMode {}
enum CommandParameterType {}
enum CommandPermissionLevel {}
enum ComplexInventoryTransaction {}
enum CompressionMethod {}
enum ContainerDataType {}
enum ContainerId {}
enum ContainerName {}
enum ContainerType {}
enum CraftingDataEntryType {}
enum CreativeItemCategory {}
enum CreativeItemGroup {}
enum DebuggerProtocolVersion {}
enum DeviceOS {}
```

--------------------------------

### SerenityJS Core Classes

Source: https://www.serenityjs.net/docs/index

This section lists key classes available in the SerenityJS core library. These classes are fundamental for various aspects of game development, such as world generation, entity management, and event handling.

```APIDOC
Serenity:
  Description: Represents the main SerenityJS game instance.

ShapedCraftingRecipe:
  Description: Defines a shaped crafting recipe in the game.

ShapelessCraftingRecipe:
  Description: Defines a shapeless crafting recipe in the game.

SoftEnum:
  Description: A base class for creating enumerated types with string values.

StringEnum:
  Description: An enumerated type where values are strings.

Structure:
  Description: Represents a game structure.

StructureOperation:
  Description: Defines an operation related to structures.

SubChunk:
  Description: Represents a sub-section of the game world's chunks.

SuperflatGenerator:
  Description: A generator for creating superflat worlds.

SuperflatWorker:
  Description: A worker process for superflat world generation.

TagEnum:
  Description: An enumerated type for defining tags.

TargetEnum:
  Description: An enumerated type for defining targets.

TerrainGenerator:
  Description: A generator for game terrain.

TerrainWorker:
  Description: A worker process for terrain generation.

TickSchedule:
  Description: Manages scheduled game ticks.

TimeOpertation:
  Description: Defines an operation related to time.

Trait:
  Description: Represents a trait or ability.

TraitActionEnum:
  Description: An enumerated type for trait actions.

ValidEnum:
  Description: An enumerated type for valid values.

VerticalHalfTrait:
  Description: A trait representing a vertical half.

VoidGenerator:
  Description: A generator for void worlds.

World:
  Description: Represents the game world.

WorldEnum:
  Description: An enumerated type for world-related values.

WorldInitializeSignal:
  Description: Signal emitted when the world is initialized.

WorldProvider:
  Description: Provides access to world data.

WorldTickSignal:
  Description: Signal emitted during a world tick.
```

--------------------------------

### SerenityJS Plugin Development

Source: https://www.serenityjs.net/docs/index

Plugins for SerenityJS can be written in TypeScript or JavaScript and have direct access to the same APIs used to build Serenity. Refer to the SerenityJS documentation for API usage.

```typescript
// Example of a SerenityJS plugin (conceptual)
import { Plugin } from '@serenityjs/core';

const MyPlugin: Plugin = {
  name: 'MyPlugin',
  version: '1.0.0',
  onLoad: (server) => {
    console.log('MyPlugin loaded!');
    // Access server API here
  },
  onUnload: () => {
    console.log('MyPlugin unloaded!');
  }
};

export default MyPlugin;
```

```javascript
// Example of a SerenityJS plugin (conceptual)
const MyPlugin = {
  name: 'MyPlugin',
  version: '1.0.0',
  onLoad: (server) => {
    console.log('MyPlugin loaded!');
    // Access server API here
  },
  onUnload: () => {
    console.log('MyPlugin unloaded!');
  }
};

module.exports = MyPlugin;
```
Tokens:
Raw