dhl/net.crystopia.crystalshard.paper.dhl.packets.client

Package-level declarations

Functions

fun ClientPacketFactory.addEntity(entityId: Int, entityUUID: UUID, location: Location, entityType: EntityType, data: Int, yHeadRot: Double = 0.0, callback: (packet: ClientPacket<ClientboundAddEntityPacketData>) -> Unit): ClientPacket<ClientboundAddEntityPacketData>

addRecipeBook

fun ClientPacketFactory.addRecipeBook(recipes: MutableList<RecipeEntry>, replace: Boolean, callback: (packet: ClientPacket<ClientboundRecipeBookAddPacketData>) -> Unit): ClientPacket<ClientboundRecipeBookAddPacketData>

applyCooldown

fun ClientPacketFactory.applyCooldown(item: Material, duration: Int, callback: (packet: ClientPacket<ClientboundCooldownPacketData>) -> Unit): ClientPacket<ClientboundCooldownPacketData>

applyMobEffect

fun ClientPacketFactory.applyMobEffect(entityId: Int, effect: EffectInstance, blend: Boolean, callback: (packet: ClientPacket<ClientboundUpdateMobEffectPacketData>) -> Unit): ClientPacket<ClientboundUpdateMobEffectPacketData>

closeContainer

fun ClientPacketFactory.closeContainer(id: Int, callback: (packet: ClientPacket<ClientboundContainerClosePacketData>) -> Unit): ClientPacket<ClientboundContainerClosePacketData>

createAnimation

fun ClientPacketFactory.createAnimation(entity: Entity, animationId: Int, callback: (packet: ClientPacket<ClientboundAnimatePacketData>) -> Unit): ClientPacket<ClientboundAnimatePacketData>

createBlockDestroyStage

fun ClientPacketFactory.createBlockDestroyStage(entityId: Int, pos: BlockPos, progress: Int, callback: (packet: ClientPacket<ClientboundBlockDestructionPacketData>) -> Unit): ClientPacket<ClientboundBlockDestructionPacketData>

createBlockEntityData

fun ClientPacketFactory.createBlockEntityData(blockPos: BlockPos, type: BlockEntityType, nbt: String, callback: (packet: ClientPacket<ClientboundBlockEntityDataPacketData>) -> Unit): ClientPacket<ClientboundBlockEntityDataPacketData>

createBlockUpdate

fun ClientPacketFactory.createBlockUpdate(pos: BlockPos, state: Material, callback: (packet: ClientPacket<ClientboundBlockUpdatePacketData>) -> Unit): ClientPacket<ClientboundBlockUpdatePacketData>

createEquipment

fun ClientPacketFactory.createEquipment(entityId: Int, equipmentList: MutableList<Pair<EquipmentSlot, ItemStack>>, callback: (packet: ClientPacket<ClientboundSetEquipmentPacketData>) -> Unit): ClientPacket<ClientboundSetEquipmentPacketData>

createOpenSignEditor

fun ClientPacketFactory.createOpenSignEditor(blockPos: BlockPos, isFrontText: Boolean, callback: (packet: ClientPacket<ClientboundOpenSignEditorPacketData>) -> Unit): ClientPacket<ClientboundOpenSignEditorPacketData>

damageEvent

fun ClientPacketFactory.damageEvent(entity: Entity, damageSource: DamageSource, callback: (packet: ClientPacket<ClientboundDamageEventPacketData>) -> Unit): ClientPacket<ClientboundDamageEventPacketData>

initWorldBorder

fun ClientPacketFactory.initWorldBorder(border: WorldBorder, callback: (packet: ClientPacket<ClientboundBorderPacketData>) -> Unit): ClientPacket<ClientboundBorderPacketData>

moveEntity

fun ClientPacketFactory.moveEntity(mode: EntityMoveMode, entity: Entity, xa: Short, ya: Short, za: Short, yRot: Byte, xRot: Byte, onGround: Boolean, hasRot: Boolean, hasPos: Boolean, callback: (packet: ClientPacket<ClientboundMoveEntityPacketData>) -> Unit): ClientPacket<ClientboundMoveEntityPacketData>

moveMinecart

fun ClientPacketFactory.moveMinecart(entity: Entity, lerpSteps: MutableList<MinecartStep>, callback: (packet: ClientPacket<ClientboundMoveMinecartPacketData>) -> Unit): ClientPacket<ClientboundMoveMinecartPacketData>

moveVehicle

fun ClientPacketFactory.moveVehicle(entity: Entity, position: Vec3, yRot: Float, xRot: Float, callback: (packet: ClientPacket<ClientboundMoveVehiclePacketData>) -> Unit): ClientPacket<ClientboundMoveVehiclePacketData>

openScreen

fun ClientPacketFactory.openScreen(id: Int, title: Component, type: MenuType, callback: (packet: ClientPacket<ClientboundOpenScreenPacketData>) -> Unit): ClientPacket<ClientboundOpenScreenPacketData>

placeGhostRecipe

fun ClientPacketFactory.placeGhostRecipe(containerId: Int, recipe: RecipeEntry, callback: (packet: ClientPacket<ClientboundPlaceGhostRecipePacketData>) -> Unit): ClientPacket<ClientboundPlaceGhostRecipePacketData>

playerInfoRemove

fun ClientPacketFactory.playerInfoRemove(uuids: MutableList<UUID>, callback: (packet: ClientPacket<ClientboundPlayerInfoRemovePacketData>) -> Unit): ClientPacket<ClientboundPlayerInfoRemovePacketData>

playerInfoUpdate

fun ClientPacketFactory.playerInfoUpdate(serverPlayer: Player, actions: MutableList<InfoUpdateAction>, callback: (packet: ClientPacket<ClientboundPlayerInfoUpdatePacketData>) -> Unit): ClientPacket<ClientboundPlayerInfoUpdatePacketData>

recipeBookSettings

fun ClientPacketFactory.recipeBookSettings(recipeBookSettings: RecipeBookSettings, callback: (packet: ClientPacket<ClientboundRecipeBookSettingsPacketData>) -> Unit): ClientPacket<ClientboundRecipeBookSettingsPacketData>

recipePacket

fun ClientPacketFactory.recipePacket(state: RecipeState, recipeIdsToChange: MutableList<NamespacedKey>, recipeIdsToInit: MutableList<NamespacedKey>, recipeBookSettings: RecipeBookSettings, callback: (packet: ClientPacket<ClientboundRecipePacketData>) -> Unit): ClientPacket<ClientboundRecipePacketData>

removeEntities

fun ClientPacketFactory.removeEntities(entityIds: List<Int>, callback: (packet: ClientPacket<ClientboundRemoveEntitiesPacketData>) -> Unit): ClientPacket<ClientboundRemoveEntitiesPacketData>

removeMobEffect

fun ClientPacketFactory.removeMobEffect(entityId: Int, effect: EffectType, callback: (packet: ClientPacket<ClientboundRemoveMobEffectPacketData>) -> Unit): ClientPacket<ClientboundRemoveMobEffectPacketData>

removeRecipeBook

fun ClientPacketFactory.removeRecipeBook(ids: MutableList<Int>, callback: (packet: ClientPacket<ClientboundRecipeBookRemovePacketData>) -> Unit): ClientPacket<ClientboundRecipeBookRemovePacketData>

resetScoreInDisplayObject

fun ClientPacketFactory.resetScoreInDisplayObject(score: ScoreData<*>, callback: (packet: ClientPacket<ClientboundSetScorePacketData>) -> Unit): ClientPacket<ClientboundSetScorePacketData>

rotateHead

fun ClientPacketFactory.rotateHead(entity: Entity, yaw: Float, callback: (packet: ClientPacket<ClientboundRotateHeadPacketData>) -> Unit): ClientPacket<ClientboundRotateHeadPacketData>

runGameEvent

fun ClientPacketFactory.runGameEvent(type: GameEventType, action: Float, callback: (packet: ClientPacket<ClientboundGameEventPacketData>) -> Unit): ClientPacket<ClientboundGameEventPacketData>

selectAdvancementTab

fun ClientPacketFactory.selectAdvancementTab(tab: NamespacedKey, callback: (packet: ClientPacket<ClientboundSelectAdvancementsTabPacketData>) -> Unit): ClientPacket<ClientboundSelectAdvancementsTabPacketData>

sendEntityEvent

fun ClientPacketFactory.sendEntityEvent(entity: Entity, status: Byte, world: World, callback: (packet: ClientPacket<ClientboundEntityEventPacketData>) -> Unit): ClientPacket<ClientboundEntityEventPacketData>

See more infos about status. Entity_statuses

sendObjectiveUpdate

fun ClientPacketFactory.sendObjectiveUpdate(mode: ScoreBoardMode, displaySlot: DisplaySlot, displayData: DisplayData<*>, callback: (packet: ClientPacket<ClientboundSetDisplayObjectivePacketData>) -> Unit): ClientPacket<ClientboundSetDisplayObjectivePacketData>

sendPacket

fun ClientPacketFactory.sendPacket(packet: Packet<*>, players: MutableList<Player>)

sendPlayerCombatKill

fun ClientPacketFactory.sendPlayerCombatKill(entityId: Int, message: Component, callback: (packet: ClientPacket<ClientboundPlayerCombatKillPacketData>) -> Unit): ClientPacket<ClientboundPlayerCombatKillPacketData>

sendTeam

fun ClientPacketFactory.sendTeam(action: TeamAction, team: Team, callback: (packet: ClientPacket<ClientboundSetPlayerTeamPacketData>) -> Unit): ClientPacket<ClientboundSetPlayerTeamPacketData>

sendWaypoint

fun ClientPacketFactory.sendWaypoint(operation: WaypointOperation, waypoints: TrackedWaypoint<*>, callback: (packet: ClientPacket<ClientboundTrackedWaypointPacketData>) -> Unit): ClientPacket<ClientboundTrackedWaypointPacketData>

sendWorldEvent

fun ClientPacketFactory.sendWorldEvent(type: Int, pos: BlockPos, data: Int, globalEvent: Boolean, callback: (packet: ClientPacket<ClientboundLevelEventPacketData>) -> Unit): ClientPacket<ClientboundLevelEventPacketData>

setContainerContent

fun ClientPacketFactory.setContainerContent(id: Int, stateId: Int, items: MutableMap<Int, ItemStack>, carriedItem: ItemStack?, callback: (packet: ClientPacket<ClientboundContainerSetContentPacketData>) -> Unit): ClientPacket<ClientboundContainerSetContentPacketData>

setContainerData

fun ClientPacketFactory.setContainerData(id: Int, property: Short, value: Short, callback: (packet: ClientPacket<ClientboundContainerSetDataPacketData>) -> Unit): ClientPacket<ClientboundContainerSetDataPacketData>

setContainerSlot

fun ClientPacketFactory.setContainerSlot(id: Int, revision: Int, slot: Int, item: ItemStack, callback: (packet: ClientPacket<ClientboundContainerSetSlotPacketData>) -> Unit): ClientPacket<ClientboundContainerSetSlotPacketData>

setDefaultSpawnPosition

fun ClientPacketFactory.setDefaultSpawnPosition(world: World, pos: BlockPos, yaw: Float, pitch: Float, angle: Float?, callback: (packet: ClientPacket<ClientboundSetDefaultSpawnPositionPacketData>) -> Unit): ClientPacket<ClientboundSetDefaultSpawnPositionPacketData>

setDisplayObjective

fun ClientPacketFactory.setDisplayObjective(displaySlot: DisplaySlot, displayData: DisplayData<*>, callback: (packet: ClientPacket<ClientboundSetDisplayObjectivePacketData>) -> Unit): ClientPacket<ClientboundSetDisplayObjectivePacketData>

setEntityData

fun ClientPacketFactory.setEntityData(entity: Entity, entityData: MutableList<EntityMetadata<*>>, callback: (packet: ClientPacket<ClientboundSetEntityDataPacketData>) -> Unit): ClientPacket<ClientboundSetEntityDataPacketData>

setHealth

fun ClientPacketFactory.setHealth(health: Float, food: Int, saturation: Float, callback: (packet: ClientPacket<ClientboundSetHealthPacketData>) -> Unit): ClientPacket<ClientboundSetHealthPacketData>

setItemOnCursor

fun ClientPacketFactory.setItemOnCursor(item: ItemStack, slot: Int, callback: (packet: ClientPacket<ClientboundSetCarriedItemPacketData>) -> Unit): ClientPacket<ClientboundSetCarriedItemPacketData>

setMapItemData

fun ClientPacketFactory.setMapItemData(mapId: Int, scale: Byte, locked: Boolean, decorations: MutableList<MapDecoration>, colorPatch: MapPatch, callback: (packet: ClientPacket<ClientboundMapItemDataPacketData>) -> Unit): ClientPacket<ClientboundMapItemDataPacketData>

setMerchantOffer

fun ClientPacketFactory.setMerchantOffer(windowId: Int, merchantOffers: MerchantOffers, levelProgress: Int, experience: Int, leveled: Boolean, refreshable: Boolean, callback: (packet: ClientPacket<ClientboundMerchantOffersPacketData>) -> Unit): ClientPacket<ClientboundMerchantOffersPacketData>

setPassengers

fun ClientPacketFactory.setPassengers(entity: Entity, passengers: MutableList<Entity>, callback: (packet: ClientPacket<ClientboundSetPassengersPacketData>) -> Unit): ClientPacket<ClientboundSetPassengersPacketData>

setScoreInDisplayObject

fun ClientPacketFactory.setScoreInDisplayObject(score: ScoreData<*>, callback: (packet: ClientPacket<ClientboundSetScorePacketData>) -> Unit): ClientPacket<ClientboundSetScorePacketData>

setTabList

fun ClientPacketFactory.setTabList(footer: Component, header: Component, callback: (packet: ClientPacket<ClientboundTabListPacketData>) -> Unit): ClientPacket<ClientboundTabListPacketData>

setTime

fun ClientPacketFactory.setTime(gameTime: Long, dayTime: Long, tickDayTime: Boolean, callback: (packet: ClientPacket<ClientboundSetTimePacketData>) -> Unit): ClientPacket<ClientboundSetTimePacketData>

setWorldBorderCenter

fun ClientPacketFactory.setWorldBorderCenter(border: WorldBorder, callback: (packet: ClientPacket<ClientboundBorderPacketData>) -> Unit): ClientPacket<ClientboundBorderPacketData>

setWorldBorderLerpSize

fun ClientPacketFactory.setWorldBorderLerpSize(border: WorldBorder, callback: (packet: ClientPacket<ClientboundBorderPacketData>) -> Unit): ClientPacket<ClientboundBorderPacketData>

setWorldBorderSize

fun ClientPacketFactory.setWorldBorderSize(border: WorldBorder, callback: (packet: ClientPacket<ClientboundBorderPacketData>) -> Unit): ClientPacket<ClientboundBorderPacketData>

setWorldBorderWarningDelay

fun ClientPacketFactory.setWorldBorderWarningDelay(border: WorldBorder, callback: (packet: ClientPacket<ClientboundBorderPacketData>) -> Unit): ClientPacket<ClientboundBorderPacketData>

setWorldBorderWarningDistance

fun ClientPacketFactory.setWorldBorderWarningDistance(border: WorldBorder, callback: (packet: ClientPacket<ClientboundBorderPacketData>) -> Unit): ClientPacket<ClientboundBorderPacketData>

showDialog

fun ClientPacketFactory.showDialog(dialog: Dialog<*>, callback: (packet: ClientPacket<ClientboundShowDialogPacketData>) -> Unit): ClientPacket<ClientboundShowDialogPacketData>

spawnParticle

fun ClientPacketFactory.spawnParticle(particle: Particle<*, *>, callback: (packet: ClientPacket<ClientboundLevelParticlesPacketData>) -> Unit): ClientPacket<ClientboundLevelParticlesPacketData>

takeItem

fun ClientPacketFactory.takeItem(itemId: Int, player: Entity, amount: Int, callback: (packet: ClientPacket<ClientboundTakeItemEntityPacketData>) -> Unit): ClientPacket<ClientboundTakeItemEntityPacketData>

teleportEntity

fun ClientPacketFactory.teleportEntity(entity: Entity, location: Location, onGround: Boolean, callback: (packet: ClientPacket<ClientboundTeleportEntityPacketData>) -> Unit): ClientPacket<ClientboundTeleportEntityPacketData>

updateAdvancements

@ApiStatus.Experimental

fun ClientPacketFactory.updateAdvancements(reset: Boolean, added: MutableList<Advancement>, removed: MutableSet<NamespacedKey>, progress: MutableMap<NamespacedKey, AdvancementProgress>, showAdvancements: Boolean, callback: (packet: ClientPacket<ClientboundUpdateAdvancementsPacketData>) -> Unit): ClientPacket<ClientboundUpdateAdvancementsPacketData>

updateAttributes

fun ClientPacketFactory.updateAttributes(entity: Entity, attributes: MutableList<Attribute>, callback: (packet: ClientPacket<ClientboundUpdateAttributesPacketData>) -> Unit): ClientPacket<ClientboundUpdateAttributesPacketData>

See more infos about status. Entity_statuses

updateEntityPositionSync

fun ClientPacketFactory.updateEntityPositionSync(entity: Entity, values: PositionMoveRotation, onGround: Boolean, callback: (packet: ClientPacket<ClientboundEntityPositionSyncPacketData>) -> Unit): ClientPacket<ClientboundEntityPositionSyncPacketData>

updatePlayerLookAt

fun ClientPacketFactory.updatePlayerLookAt(entity: Entity, fromAnchor: LookAnchor, toAnchor: LookAnchor, x: Double, y: Double, z: Double, callback: (packet: ClientPacket<ClientboundPlayerLookAtPacketData>) -> Unit): ClientPacket<ClientboundPlayerLookAtPacketData>

updatePlayerPosition

fun ClientPacketFactory.updatePlayerPosition(change: PositionMoveRotation, teleportId: Int, relatives: MutableSet<RelativePosition>, callback: (packet: ClientPacket<ClientboundPlayerPositionPacketData>) -> Unit): ClientPacket<ClientboundPlayerPositionPacketData>

updatePlayerRotation

fun ClientPacketFactory.updatePlayerRotation(yRot: Float, relativeY: Boolean, xRot: Float, relativeX: Boolean, callback: (packet: ClientPacket<ClientboundPlayerRotationPacketData>) -> Unit): ClientPacket<ClientboundPlayerRotationPacketData>

updateTickingState

fun ClientPacketFactory.updateTickingState(tickRate: Float, isFrozen: Boolean, callback: (packet: ClientPacket<ClientboundTickingStatePacketData>) -> Unit): ClientPacket<ClientboundTickingStatePacketData>

updateTickingStep

fun ClientPacketFactory.updateTickingStep(tickSteps: Int, callback: (packet: ClientPacket<ClientboundTickingStepPacketData>) -> Unit): ClientPacket<ClientboundTickingStepPacketData>