Skip to content

Latest commit

 

History

History
166 lines (122 loc) · 6.64 KB

README.md

File metadata and controls

166 lines (122 loc) · 6.64 KB

Maven metadata URL Static Badge

wakatime Discord Static Badge

DockyardMC is an open-source, fast and lightweight Minecraft server protocol implementation that's written from scratch in Kotlin without any code from Mojang. It is focused on making developing and prototyping easy, simple and intuitive while having full control over every aspect of the server.

This project currently under development, missing parts some users might rely on

Quick Start

You can read how to setup and use dockyard here

Features

  • Modern, simple to use API which makes developing and prototyping easy and fast
  • Lightweight and without all the overhead the vanilla server has
  • Ability to take full control over every aspect of the server
  • Fully multithreaded worlds

API Examples

Events

Events.on<PlayerJoinEvent> { event ->
    if(banList.contains(event.player.uuid)) {
        event.player.kick("<red>You are banned!")
        event.cancel()
        return@on
    }
  
    broadcastMessage("<lime>→ <yellow>${event.player} has joined the server.")
}

Modifying events (including PacketReceived and PacketSent)

Events.on<PacketReceivedEvent> { event ->
    if(event.packet is ServerboundPlayerChatMessagePacket) {
      event.packet.message = "ha get overwritten >:3"
    }
}

Commands API

You can create commands quickly and easily with the DockyardMC command API

Commands.add("/explode") {
    addArgument("player", PlayerArgument())
    withPermission("player.admin")
    withDescription("explodes a player")
    execute { context ->
        val executingPlayer = context.getPlayerOrThrow()
        val player = getArgument<Player>("player")
    
        player.spawnParticle(player.location, Particles.EXPLOSION_EMITTER, Vector3f(1f), amount = 5)
        player.playSound(Sounds.ENTITY_GENERIC_EXPLODE, volume = 2f, pitch = randomFloat(0.6f, 1.3f))
    
        player.sendMessage("<yellow>You got <rainbow><b>totally exploded <yellow>by <red>$executingPlayer")
        executingPlayer.sendMessage("<yellow>You <rainbow><b>totally exploded <yellow>player <red>$player")
    }
}

Built-in Bossbar and Sidebar APIs

Sidebar API

val sidebar = Sidebar {
    setTitle("<yellow><bold>My Cool Server")
    setGlobalLine("")
    setPlayerLine { player -> "Welcome, <aqua>$player" }
    setPlayerLine { player -> "World: <yellow>${player.world.name}" }
    setPlayerLine { player -> "Ping: <pink>${player.ping}" }
    setGlobalLine("")
    setGlobalLine("<yellow>www.mycoolserver.uwu")
}

Events.on<PlayerJoinEvent> { event ->
    sidebar.viewers.add(event.player)
}

Changing any lines, title etc. will automatically send update to the viewers

Bossbar API

val bossbar = Bossbar("<yellow>The server has uptime is: <orange>$serverUptime<yellow>!", 1f, BossbarColor.YELLOW, BossbarNotches.SIX)

Events.on<PlayerJoinEvent> { event ->
    bossbar.addViewer(event.player)
}

Again, changing any properties of the bossbar will automatically send updates to the viewers

Entity Metadata Layers

Layering entity metadata per player allows for client-side changes to entities for purposes like client-side glowing and client-side invisibility.

Note that this behaviour is not just sending one packet, but its whole system that overlays the player specific metadata layer over the entity's actual metadata

Here are few examples:

// pre-made functions to set client-side glowing and invisibility
entity.setGlowingFor(player, true)
entity.setInvisibleFor(player, false)
// get the metadata layer of player or create new one if it doesn't exist
val playerMetadataLayer = warden.metadataLayers[player] ?: mutableMapOf<EntityMetadataType, EntityMetadata>()

// create new EntityMetadata with index and type pose
val pose = EntityMetadata(EntityMetadataType.POSE, EntityMetaValue.POSE, EntityPose.ROARING)

// add the pose to the list
playerMetadataLayer[EntityMetadataType.POSE] = pose
warden.metadataLayers[player] = playerMetadataLayer

// specified player will now see the warden roaring

Running

Dockyard is mainly designed as library that can be imported via maven. If you want to run dockyard you will need to embed it into your own kotlin app.

Contributing

Contributions are always welcome! Please always check branches to see if the feature you are contributing is not already existing feature that someone else is working on

(plus you get cool fancy orange contributor role on the discord!!!)

Related Libraries / Projects

  • Scroll - Minecraft component library made for DockyardMC
  • Chart - Minecraft NBT library made for DockyardMC
  • kotlin-bindables - Bindable system inspired by osu!framework
  • Pathetic - A powerful, optimized and easy-to-use Java A* Pathfinding Library for 3D environments.
  • Spark - A performance profiler for Minecraft clients, servers, and proxies
  • PrettyLog - Fancy logging library

Authors

Additional thanks to

If you want to support me and this project, consider buying me a coffee <3