BergerHealer Wiki - User contributions [en]

Main Page/zh-cn

2025-10-12T10:10:30Z

RyanDo:

<languages />
'''欢迎'''来到维基百科！

== 快捷链接 ==
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

== BKCommonLib ==
该运行库共享各种插件所需的所有通用代码，将它们一起放在库中可以大大减少重复代码量。插件各个都别具一格、富有特色，每当 Spigot 缺少某些功能时，该功能就会被收录进 BKCommonLib 里，这就是为什么这个库会变得如此庞大的原因之一：Spigot 不提供（也不想提供）的功能实在太多了。

BKCommonLib 以每个插件为基础进行版本控制，因此当某个插件需要版本 2，并且安装了版本 1 时，会自动向服务器管理员发送通知，并且不启用这个插件。这可以防止因 BKCommonLib 版本过时而导致的各种问题。如果你想开发基于 BKCommonLib 的插件，请确保你是基于仍能提供你所需的功能的最早版本，这样你的插件才可以在较旧的 Spigot 版本上正常运行。

除了程序和服务以外，这个库还提供了各种反射和对用户友好的方法来访问 net.minecraft.server。如果你的插件需要使用内部组件，但不想冒险修改字段和方法名称，可以让内部组件依赖 BKCommonLib，这允许你自保持 CraftBukkit 版本之间的兼容性，并减少静默问题的产生。

[[Special:MyLanguage/BKCommonLib|点击前往 BKCommonLib 百科。]]

== TrainCarts ==
该插件会寻找矿车并尽可能将它们连接在一起。当两辆矿车''连接''在一起时，会组成一列车。

一旦矿车成功连接，就会产生效果。整体速度会与其中的每个矿车的状态进行共享，保持稳定的矿车间隙。矿车间隙是可配置的，且拉伸间隙的力度也是可配置的。

最终产物：一列火车！你可以移动它，把它做成过山车，也可以把它分成两半，看着列车相撞，你想怎么做都可以！q(≧▽≦q)~

[[Special:MyLanguage/TrainCarts|点击前往 TrainCarts 百科。]]

== TC-Coasters ==
TC 附属插件，为 TC 添加隐形轨道。该插件可以让矿车在任何地方移动或飞行，隐形轨道还能与其他类型的轨道连接。配合附件修改矿车的样式，比如飞机、巴士等，通过隐形轨道创建飞行航线和客运路线等。你能通过交互式编辑对隐形轨道进行高度的自定义，不需要任何外部工具和编程知识。

[[Special:MyLanguage/TC-Coasters|点击前往 TC-Coasters 百科。]]

== MyWorlds ==
该插件包含与世界相关的一切内容。

[[Special:MyLanguage/MyWorlds|点击前往 MyWorlds 百科。]]

== SignLink ==
为 TC 和告示牌之间搭建桥梁，可轻松在告示牌上显示文本。

[[Special:MyLanguage/SignLink|点击前往 SignLink 百科。]]

== Maplands ==
Maplands 是一个正在开发中的项目，旨在为 Minecraft 地图提供世界地图渲染。以等距视图显示世界，将地图链接在一起并创建一个大型的服务器世界总览，还有更多值得期待的功能正在开发中！

[[Special:MyLanguage/Maplands|点击前往 Maplands 百科。]]

==Light Cleaner==
该插件会在玩家附近或整个世界范围内轻量级的重新生成区块。

[[Special:MyLanguage/Light-Cleaner|点击前往 Light Cleaner 百科。]]

主页有百科管理员维护。如果你对此页面有任何建议，请通过 Discord 联系管理员！

Translations:Main Page/46/zh-cn

2025-10-12T10:10:21Z

RyanDo:

== 快捷链接 ==
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

Main Page/zh

2025-10-12T10:10:14Z

RyanDo:

<languages />
欢迎来到'''维基百科'''！

== 快捷链接 ==
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

== BKCommonLib ==
该工具库共享了各种插件所需的所有通用代码，将它们放在一个库中大大减少了重复代码的数量。特色工具种类繁多，每当Spigot中缺少某些功能时，它都会在BKCommonLib中添加。这就是它变得如此庞大的原因之一：Spigot中确实有很多东西（不打算）提供。

BKCommonLib以每个插件为基础进行版本管理，因此当某个插件需要版本2，而安装的是版本1时，会自动向服务器管理员发送通知，同时禁用这个插件。这可以避免因BKCommonLib版本过时而引发的常见问题。如果你正在开发基于BKCommonLib的插件，请确保你依赖的是最早仍能提供你所需要功能的版本。这可以确保你的插件在较老的Spigot构建中仍能正常工作。

除了程序和服务以外，该库还提供了各种反射和对用户友好的方法来访问net.minecraft.server。如果你的插件需要使用内部组件，但不想冒险修改字段和方法名称，可以让内部组件依赖BKCommonLib，这允许你自保持CraftBukkit版本之间的兼容性，并减少静默问题的产生。

除了工具和服务之外，这个库还提供了多种反射和用户友好的方式来访问net.minecraft.server。如果你的插件需要使用内部组件，但你又不想冒改变字段和方法名称的风险，你可以依赖BKCommonLib来为你提供这些功能。这样，你就能够在CraftBukkit版本之间自动保持兼容性，并减少了静默失败的隐患。

[[Special:MyLanguage/BKCommonLib|点击前往BKCommonLib百科。]]

== TrainCarts ==
该插件会寻找矿车并尽可能将它们连接在一起。当两辆矿车''连接''在一起时，会组成为一条列车。

一旦矿车成功连接，就会产生效果。整体速度会与其中的每个矿车的状态进行共享，保持稳定的矿车间隙。矿车间隙是可配置的，且拉伸间隙的力度也是可配置的。

最终产物：一列火车！你可以移动它，把它当作过山车，也可以把它分成两半，看看列车的相撞，你想怎么做都可以！q(≧▽≦q)~

[[Special:MyLanguage/TrainCarts|点击前往TrainCarts百科。]]

== TC-Coasters ==
TC的附属插件，为TC添加隐形轨道。现在你可以让列车在任意位置移动或飞行，在轨道上滚动并与其他类型的轨道连接。自定义轨道可以通过交互的方式进行编辑，无需外部工具或脚本知识。

[[Special:MyLanguage/TC-Coasters|点击前往TC-Coasters百科。]]

== MyWorlds ==
该插件包含与世界相关的一切内容。

[[Special:MyLanguage/MyWorlds|点击前往MyWorlds百科。]]

== SignLink ==
插件与告示牌之间的桥梁，可轻松在告示牌上显示文本。

[[Special:MyLanguage/SignLink|点击前往SignLink百科。]]

== Maplands ==
Maplands是一个正在开发中的项目，旨在为Minecraft地图提供世界地图渲染功能。以等距视图显示世界，将地图连接在一起并创建为一个大型的服务器世界总览，还有更多值得期待的功能正在开发中！

[[Special:MyLanguage/Maplands|点击前往Maplands百科。]]

== Light Cleaner ==
该插件会在玩家附近或整个世界范围内轻量级的重新生成区块。

[[Special:MyLanguage/Light-Cleaner|点击前往Light Cleaner百科。]]

主页由管理员进行维护。如果你对此页面有任何建议，请通过Discord联系管理员！

Translations:Main Page/46/zh

2025-10-12T10:10:07Z

RyanDo:

Main Page/de

2025-10-12T10:09:27Z

RyanDo:

<languages />
'''Willkommen''' im Wiki!

==Schnelle Navigation==
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

==BKCommonLib==
Diese Utility Bibliothek enthält all den in verschiedenen Plugins verwendeten selben Code, und das kombinieren in eine Bibliothek reduziert die anzahl an doppelten Code dramatisch. Die verwendeten Funktionen varieren und wann immer etwas in Spigot fehlt, wird es in BKCommonLib hinzugefügt. Dies ist eines der Gründe, warum es so gross ist: Weil es einfach eine menge dinge gibt, welche Spigot nicht anbieten (will).

BKCommonLib hat eine Versionierung auf einer per-Plugin basis, sodass wenn ein Plugin Version 2 benötigt, jedoch Version 1 installiert ist, der Serverbesitzer automatisch informiert und das Plugin nicht gestartet wird. Dies verhindert oftmals auftretende Probleme mit veralteten BKCommonLib Versionen. Wenn du ein Plugin entwickelst, welches BKCommonLib verwendet, solltest du sicherstellen, dass dein Plugin die jüngste Version, welches das von dir verwendete Feature anbietet, verlangt. Das stellt sicher, dass dein Plugin auch auf älteren Spigot-Builds funktional bleibt.

Anders als andere Utilities und Services, offeriert diese Bibliothek eine grosse anzahl and Reflektion und Benutzerfreundliche Wege um net.minecraft.server Code zu verwenden. Wenn dein Plugin die verwendung von Internem Code benötigt, du aber nicht riskieren willst, Feld und Methoden-Namen zu ändern, kannst du dich auf BKCommonLib verlassen, dir diese zu geben. Dies erlaubt es dir, automatisch zwischen CraftBukkit Versionen kompatibel zu bleiben und veringert leise Fehler-Fallen.

[[Special:MyLanguage/BKCommonLib|Klick Hier um zum BKCommonLib Wiki zu gelangen.]]

==TrainCarts==
Dieses Plugin schaut nach verwendbaren Loren und verlinkt diese sofern möglich. Wenn zwei Loren "verlinkt" sind, werden diese Loren als ein einzelner Zug fungieren.

Sobald Loren erfolgreich verlinkt wurden, wird ein Effekt abgespielt und Ihre Geschwindigkeit wird geteilt, mit einem individuelen Faktor für jede Lore, welche verwendet wird um eine Konstante Distanz zwischen den einzelnen Loren zu wahren. Dieser Abstand ist einstellbar, sowie die stärke in welcher dies geschieht.

End-Resultat: Ein Zug! Du kannst ihn bewegen, eine Achterbahn aus ihr machen, sie teilen, Züge beim kollidieren zuschauen, was auch immer du mit Zügen machen willst. :)

[[Special:MyLanguage/TrainCarts|Klick hier um zum TrainCarts Wiki zu gelangen.]]

==TC-Coasters ==
This add-on for Traincarts adds invisible rollercoaster track to Traincarts. You can now have trains move or fly anywhere, roll around the rails and connect with other types of track. The custom track can be interactively edited and require no external tools or scripting knowledge.

[[Special:MyLanguage/TC-Coasters|Klick hier um zum TC-Coasters Wiki zu gelangen.]]

==MyWorlds==
Dieses Plugin enthält alles über Welten.

[[Special:MyLanguage/MyWorlds|Klick hier um zum MyWorlds Wiki zu gelangen.]]

==SignLink==
Eine Brücke zwischen Plugins und Schildern zur einfachen Anzeige von Text auf Schildern.

[[Special:MyLanguage/SignLink|Klick hier um zum SignLink Wiki zu gelangen.]]

==Maplands==
Maplands ist ein WIP Project welches Welt-Karten-Rendering für Minecraft Karten gibt. Zeige die Welt in einer Isometrischen Sicht an, kombiniere mehrere Karten um eine grosse Karte deiner Welt zu erstellen und vieles mehr das du erwarten kannst!

[[Special:MyLanguage/Maplands|Klick hier um zum Maplands Wiki zu gelangen.]]

<div lang="en" dir="ltr" class="mw-content-ltr">
==Light Cleaner==
This plugin performs light regeneration of chunks near the player or the entire world.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
[[Special:MyLanguage/Light-Cleaner|Click here to go to the Light Cleaner wiki.]]
</div>

Die Homepage wird von den Wiki-Administratoren gepflegt. Wenn Sie Vorschläge für diese Seite haben, wenden Sie sich bitte an einen Administrator!

Translations:Main Page/46/de

2025-10-12T10:09:21Z

RyanDo:

==Schnelle Navigation==
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

Main Page/nl

2025-10-12T10:08:56Z

RyanDo:

<languages />
'''Welkom''' op de wiki!

==Snelle navigatie==
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

==BKCommonLib==
Deze bibliotheek deelt alle gemeenschappelijke codebehoeften voor verschillende plugins, en door ze in één bibliotheek te hebben, wordt de hoeveelheid gedupliceerde code aanzienlijk verminderd. De aanbevolen hulpprogramma's zijn gevarieerd en wanneer er iets ontbreekt in Spigot, wordt het toegevoegd in BKCommonLib. Dit is een van de redenen waarom het zo groot is geworden: er zijn gewoon veel dingen die Spigot niet (wil) bieden.

BKCommonLib heeft versiebeheer per plugin, dus wanneer een bepaalde plugin versie 2 nodig heeft en versie 1 is geïnstalleerd, wordt de servereigenaar automatisch op de hoogte gesteld en wordt de plugin niet ingeschakeld. Dit voorkomt de veel voorkomende ongelukken met verouderde BKCommonLib-versies. Als je een plugin ontwikkelt die BKCommonLib gebruikt, zorg er dan voor dat je afhankelijk bent van de vroegste versie die nog steeds de functies biedt die je nodig hebt. Dit zorgt ervoor dat je plugin functioneel blijft op oudere Spigot-builds.

Behalve hulpprogramma's en services, biedt deze bibliotheek een breed scala aan reflectie en gebruiksvriendelijke manieren om toegang te krijgen tot net.minecraft.server. Als uw plug-in het gebruik van internals vereist, maar u niet het risico wilt lopen om de namen van velden en methoden te wijzigen, kunt u erop vertrouwen dat BKCommonLib ze levert. Hierdoor blijft je automatisch compatibel tussen CraftBukkit-versies en verminder je de kans op stille storingen.

[[Special:MyLanguage/BKCommonLib|Klik hier om naar de BKCommonLib wiki te gaan.]]

==TrainCarts==
Deze plugin zoekt naar geschikte minecarts en koppelt deze indien mogelijk aan elkaar. Wanneer twee minecarts worden "gekoppeld", werken de minecarts als één bewegende trein.

Zodra de karren zijn gekoppeld, wordt een hoorbaar effect afgespeeld en wordt hun snelheid gedeeld in combinatie met een individuele factor voor elke minecarts, die wordt gebruikt om een constante opening tussen karren te behouden. Deze opening is instelbaar, de kracht waarbij dit gebeurt ook.

Eindresultaat: een trein! Je kunt het verplaatsen, er een achtbaan van maken, het in tweeën splitsen, treinen zien botsen, wat je maar wilt met treinen. :)

[[Special:MyLanguage/TrainCarts|Klik hier om naar de TrainCarts wiki te gaan.]]

==TC-Coasters ==
This add-on for Traincarts adds invisible rollercoaster track to Traincarts. You can now have trains move or fly anywhere, roll around the rails and connect with other types of track. The custom track can be interactively edited and require no external tools or scripting knowledge.

[[Special:MyLanguage/TC-Coasters|Klik hier om naar de TC-Coasters wiki te gaan.]]

==MyWorlds==
Deze plugin bevat alles met betrekking tot minecraft werelden.

[[Special:MyLanguage/MyWorlds|Klik hier om naar de MyWorlds wiki te gaan.]]

==SignLink==
Een brug tussen plugins en bordjes zodat je makkelijk tekst kan weergeven op bordjes.

[[Special:MyLanguage/SignLink|Klik hier om naar de SignLink wiki te gaan.]]

==Maplands==
Maplands is een work-in-progress-project dat de weergave van wereldkaarten naar Minecraft-kaarten levert. Geef de wereld weer in een isometrische weergave, koppel kaarten aan elkaar en creëer een enorm overzicht van je server, en er wordt nog veel meer verwacht!

[[Special:MyLanguage/Maplands|Klik hier om naar de Maplands wiki te gaan.]]

<div lang="en" dir="ltr" class="mw-content-ltr">
==Light Cleaner==
This plugin performs light regeneration of chunks near the player or the entire world.
</div>

<div lang="en" dir="ltr" class="mw-content-ltr">
[[Special:MyLanguage/Light-Cleaner|Click here to go to the Light Cleaner wiki.]]
</div>

De homepagina wordt onderhouden door de wiki-beheerders. Als je een suggestie hebt voor deze pagina, neem dan contact op met de beheerder!

Translations:Main Page/46/nl

2025-10-12T10:08:51Z

RyanDo:

==Snelle navigatie==
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

Main Page

2025-10-12T10:07:54Z

RyanDo:

<languages />
<translate>
'''Welcome''' to the wiki!

==Quick navigation== 
[[Special:MyLanguage/BKCommonLib|BKCommonLib]] • [[Special:MyLanguage/TrainCarts|TrainCarts]] • [[Special:MyLanguage/TC-Coasters|TC-Coasters]] • [[Special:MyLanguage/MyWorlds|MyWorlds]]
• [[Special:MyLanguage/SignLink|SignLink]] • [[Special:MyLanguage/Maplands|Maplands]] • [[Special:MyLanguage/Light-Cleaner|Light Cleaner]]

==BKCommonLib== 
This utility library shares all the common code needs for various plugins, and having them in one library heavily reduces the amount of duplicated code. The featured utilities are varied, and whenever something is missing in Spigot, it is added in BKCommonLib. This is one of the reasons why it has become this large: there are simply a lot of things Spigot doesn't (want to) offer.


BKCommonLib has versioning on a per-plugin basis, so when a certain plugin needs version 2, and version 1 is installed, the server owner is automatically notified and the plugin is not enabled. This prevents the common mishaps with outdated BKCommonLib versions. If you develop a plugin that uses BKCommonLib, make sure you depend on the earliest version that still offers the features you need. This makes sure your plugin remains functional on older Spigot builds.


Other than utilities and services, this library offers a wide variety of reflection and user-friendly ways of accessing net.minecraft.server. If your plugin requires the use of the internals, but you do not want to risk changing field and method names, you can depend on BKCommonLib to provide them for you. This allows you to remain compatible between CraftBukkit versions automatically, and reduces silent failure hazards.


[[Special:MyLanguage/BKCommonLib|Click here to go to the BKCommonLib wiki.]]

==TrainCarts== 
This plugin looks for suitable Minecarts and links them together if possible. When two Minecarts are being "linked", the Minecarts will act as one single moving train.


Once carts are successfully linked, an effect is played and their velocity is shared in combination with an individual factor for each Minecart, which is used to remain a steady gap between carts. This gap is adjustable, the force at which this happens as well.


End result: a train! You can move it, make a roller-coaster out of it, split it in half, watch trains collide, whatever you want to do with trains. :)


[[Special:MyLanguage/TrainCarts|Click here to go to the TrainCarts wiki.]]

==TC-Coasters == 
This add-on for Traincarts adds invisible rollercoaster track to Traincarts. You can now have trains move or fly anywhere, roll around the rails and connect with other types of track. The custom track can be interactively edited and require no external tools or scripting knowledge.


[[Special:MyLanguage/TC-Coasters|Click here to go to the TC-Coasters wiki.]]

==MyWorlds== 
This plugin features everything related to worlds.


[[Special:MyLanguage/MyWorlds|Click here to go to the MyWorlds wiki.]]

==SignLink== 
A bridge between plugins and signs to easily display text on signs.


[[Special:MyLanguage/SignLink|Click here to go to the SignLink wiki.]]

==Maplands== 
Maplands is a work-in-progress project delivering world map rendering to Minecraft maps. Display the world in an isometric view, link maps together and create a huge overview of your server, and much more is anticipated!


[[Special:MyLanguage/Maplands|Click here to go to the Maplands wiki.]]

==Light Cleaner== 
This plugin performs light regeneration of chunks near the player or the entire world.


[[Special:MyLanguage/Light-Cleaner|Click here to go to the Light Cleaner wiki.]]


The homepage is maintained by the wiki admins. If you have any suggestions for this page, please contact an admin! </translate>

TrainCarts/Attachments

2025-10-12T09:58:07Z

RyanDo:

<languages/>
<translate>


[[File:Attachment_editor_wooden_car.png|thumb|A customized minecart is being edited using the attachment editor]]
[[File:Rotating_attachments.gif|thumb|Two model attachments are animated, demonstrating the use of hierarchy]]

==Introduction== 
'''The Attachment Editor''' is an in-game interactive [[Special:MyLanguage/Map Display|Map Display]] with which individual carts of a train can be customized.
This menu is used to configure the appearance and behavior of carts, with a [[wikipedia:Tree structure|tree layout]]
showing the different attachments. Each attachment represents a part of the train, such as a moving entity or a seat designation.
Attachments added as a child to other attachments are positioned relative to the parent. This allows many attachments to be moved
and animated together as a whole.

==Basic usage== 

===Command=== 


To start using the attachment editor, players need to give themselves the map item:
</translate>
{{Command|train attachments|Give the player the attachment editor map item|train.command.editor}}
<translate>

===Editing=== 


To edit a single cart of a train, and make it visible in the editor, you need to select the cart first.


[[Special:MyLanguage/TrainCarts/Editing|» Editing]]

===Navigation=== 


Each attachment is displayed on a different row, with an indent to the right every time it is added to a new parent. To navigate between attachments, use the Up/Down (W/S) steering controls. For each attachment selected, different menus can be accessed by pressing Left/Right (A/D) and Jump (spacebar) afterwards. Once inside a menu, the sneak button (shift) can be used to exit it again. This behavior is the same for all other menus. To move around while still viewing the editor, it can be placed into the off-hand (''typically F'').


To add new attachments, duplicate them, change the position in the tree hierarchy, or to delete them, use the [[Special:MyLanguage/TrainCarts/Attachments/General|General menu]] denoted by three horizontal lines.

===Dropping items=== 


[[File:Attachments_Drop_Item_Small.gif|thumb|An item is dropped from the inventory, configuring the attachment|link=File:Attachments_Drop_Item.gif]]
Menus where an item is being configured can be set instantly by dropping an item from the player's inventory. With the menu open, simply open the inventory, pick the item to set, and click on the outside of the inventory to drop it. The drop will be cancelled and the item set in the menu.

===Numbers=== 


Number sliders are used to configure numeric values, such position coordinates. Pressing the Left/Right buttons once will increment/decrement a very small amount. Holding the buttons for a longer time causes the number to increment/decrement faster and faster the longer it is being held down.


By holding Spacebar a number field can be reset to its default, usually 0. By holding spacebar and then pressing left/right, a special action can be performed. Usually this means inverting the value (-5 -> 5) or changing an angle in 90 degree steps.

===Text=== 


Text is input using an anvil menu. After typing in the desired text, click on the emerald to proceed, or the barrier item to cancel the change.

===Setting using commands=== 
</translate>
{{Command|train menu set [value]|Set a numeric or text value for the currently selected menu|train.command.editor}}
<translate>

==Gotchas== 
* Make sure to use <code>/train save name</code> to save your train regularly! Only saved trains can be restored
* Make use of the [[Special:MyLanguage/TrainCarts/Train Spawn Chest|train storage chest]] to move your train around or to recombine the carts
* Change spacing between carts, and where wheels are positioned, in the [[Special:MyLanguage/TrainCarts/Attachments/Physical|Physical menu]]
* When animating, make sure your animation frames have a delta-T greater than 0. Otherwise animation speed will not function.
* The new Display Entities cannot be clicked by default:
** If you cannot click to edit a train, look at it and do <code>/train edit</code> to select it
** To allow players to click on the cart to enter a seat, make sure to add a '''Hitbox attachment'''.
* You can save a sub-tree of attachments in the [[Special:MyLanguage/TrainCarts/Attachments/Model#Model_Store|Model Store]] in the [[Special:MyLanguage/TrainCarts/Attachments/General|General menu]], and create it in multiple places using the [[Special:MyLanguage/TrainCarts/Attachments/Model|'''Model Attachment''']]. There is also a clipboard and import/export function.

==Menu== 
===Appearance===
The Appearance Menu contains a selector at the top where the attachment type is configured, with the remainder of the menu automatically filled with this type's configuration.


{| class="wikitable" style="margin:left"
|+Attachment Types
! Type !! Description
|-
| '''Empty''' || Displays nothing. Used as a marker attachment to easily position multiple other attachments, and as an anchor for animations
|-bgcolor="#dddddd"
| '''Hitbox''' || Creates an invisible box that can be clicked. Important for entering seats. Size is configured in the Position menu.
|-
| [[Special:MyLanguage/TrainCarts/Attachments/Entity|'''Entity''']] || Displays an Entity like a Minecart or Mob
|-bgcolor="#dddddd"
| [[Special:MyLanguage/TrainCarts/Attachments/Item|'''Item''']] || Displays an Item on an Armorstand or using a Display Entity
|-
| [[Special:MyLanguage/TrainCarts/Attachments/Block|'''Block''']] || Displays a Block using a Display Entity. Only available on Minecraft 1.20+.
|-bgcolor="#dddddd"
| [[Special:MyLanguage/TrainCarts/Attachments/Seat|'''Seat''']] || A seat where a single player or entity can sit
|-
| [[Special:MyLanguage/TrainCarts/Attachments/Model|'''Model''']] || Loads in a full attachment configuration from the model store
|-bgcolor="#dddddd"
| '''Text''' || Floating Text Balloon
|-
| '''Platform''' || A moving shulker box that players can stand on. Does not work moving up.
|-bgcolor="#dddddd"
| '''Schematic''' || Displays multiple blocks using a WorldEdit saved Schematic
|-
| '''Light''' || When [https://www.spigotmc.org/resources/lightapi-fork.48247/ LightAPI] is installed, spawns a moving light source at the attachment position
|-bgcolor="#dddddd"
| [[Special:MyLanguage/TrainCarts/Attachments/Sound|'''Sound''']] || Adds a sound effect played with effect signs, command or the sequencer
|-
| [[Special:MyLanguage/TrainCarts/Attachments/Sequencer|'''Sequencer''']] || Automatically plays effects. Used to create ambient sound loops, such as engine noises, or to activate particle effects on a loop, such as a smoke stack.
|}

===Physical=== 
The Physical Menu configures the length of the cart and where the rail-tracking wheels of the cart are positioned.


[[Special:MyLanguage/TrainCarts/Attachments/Physical|» Physical Menu]]

===Position=== 
The position menu configures the position and rotation of the attachment. Includes additional options for some types of attachments, such as scale and transform options for items.


[[Special:MyLanguage/TrainCarts/Attachments/Position|» Position Menu]]

===Animation=== 
Attachments can be animated, making them move or rotate around. This is especially useful for funfair rides, or animated doors.


[[Special:MyLanguage/TrainCarts/Attachments/Animation|» Animation Menu]]

===General=== 
The general menu is used to add new attachments, delete them, move them around, name them or load/save them from the [[Special:MyLanguage/TrainCarts/Attachments/Model#Model_Store|model store]].


[[Special:MyLanguage/TrainCarts/Attachments/General|» General Menu]]

==Effect Activation== 
Effect attachments such as the [[Special:MyLanguage/TrainCarts/Attachments/Sound|sound attachment]] must be activated. First, the attachment must be [[Special:MyLanguage/TrainCarts/Attachments/General#Name|named in the general menu]]. It can then be activated in multiple ways:
* Using the [[Special:MyLanguage/TrainCarts/Signs/Effect|effect sign]]
* Using the <code>/train effect <name></code> command
* Using the [[Special:MyLanguage/TrainCarts/Attachments/Sequencer|sequencer attachment]]

==Backlog== 

===Editor=== 


* [[Special:MyLanguage/TrainCarts/Attachments/Saving|Saving trains (needs a cross-link about import/export and the whole savedtrain logic)]]
-> Navigating the tree menu

===Position=== 


* [[Special:MyLanguage/TrainCarts/Attachments/TransformType|Transform type]]
* [[Special:MyLanguage/TrainCarts/Attachments/Anchor|Anchor]]

===Animations=== 


* [[Special:MyLanguage/TrainCarts/Animations/Overview|Overview]]
</translate>

TrainCarts/Attachments/Sequencer/PianoRoll

2025-10-12T09:57:32Z

RyanDo:

<languages/>
<translate>


[[File:Sequencer_piano_roll.png|thumb|Sequencer MIDI Piano Roll]]

== Introduction == 


The piano roll acts as a digital music sheet to configure melodies or repeating effects. Vertically are pitch classes, or octaves, and horizontally is time. The pitch classes are compatible with [https://minecraft.wiki/w/Note_Block#Notes Minecraft note blocks]. The mid-range pitch class (pitch 1.0, ''F#'') is indicated using a red line.

== Menu == 

=== Notes === 


Notes can be placed down after activating the ''place note'' button. This automatically focuses the piano roll, where with W/A/S/D movement controls the position of the cursor on the piano roll can be changed. The note is toggled with spacebar.


It is also possible to first select a pattern of notes, and then place this pattern down multiple times on the piano roll. Placing the pattern down on top of an existing pattern removes the pattern again.


The effect is previewed once when the note is placed down.

=== Clear Chart === 


Use the clear chart button to clear everything, which cannot be reversed.

=== Preview === 


Preview the MIDI sequence using the play button, or stop it again to abort. Displays a position marker as the MIDI sequence plays.

=== Configuration === 


[[File:Sequencer_piano_roll_config.png|thumb|Sequencer MIDI Piano Roll Configuration]]


The music chart settings can be configured by activating the gear icon. Most important are the beats per minute, which controls the tempo of the sequence. The time measure and pitch classes can be used to change the resolution of the chart. If you need additional pitch ranges, increase the number of pitch classes. If you need additional notes per beat, change the note value. The time signature is more for the music literate among us.
</translate>

TrainCarts/Attachments/Sequencer/PianoRoll

2025-10-12T09:57:27Z

RyanDo:

TrainCarts/Attachments/Sequencer/PianoRoll

2025-10-12T09:57:22Z

RyanDo:

<languages/>
<translate>

[[File:Sequencer_piano_roll.png|thumb|Sequencer MIDI Piano Roll]]

== Introduction == 


The piano roll acts as a digital music sheet to configure melodies or repeating effects. Vertically are pitch classes, or octaves, and horizontally is time. The pitch classes are compatible with [https://minecraft.wiki/w/Note_Block#Notes Minecraft note blocks]. The mid-range pitch class (pitch 1.0, ''F#'') is indicated using a red line.

== Menu == 

=== Notes === 


Notes can be placed down after activating the ''place note'' button. This automatically focuses the piano roll, where with W/A/S/D movement controls the position of the cursor on the piano roll can be changed. The note is toggled with spacebar.


It is also possible to first select a pattern of notes, and then place this pattern down multiple times on the piano roll. Placing the pattern down on top of an existing pattern removes the pattern again.


The effect is previewed once when the note is placed down.

=== Clear Chart === 


Use the clear chart button to clear everything, which cannot be reversed.

=== Preview === 


Preview the MIDI sequence using the play button, or stop it again to abort. Displays a position marker as the MIDI sequence plays.

=== Configuration === 


[[File:Sequencer_piano_roll_config.png|thumb|Sequencer MIDI Piano Roll Configuration]]


The music chart settings can be configured by activating the gear icon. Most important are the beats per minute, which controls the tempo of the sequence. The time measure and pitch classes can be used to change the resolution of the chart. If you need additional pitch ranges, increase the number of pitch classes. If you need additional notes per beat, change the note value. The time signature is more for the music literate among us.
</translate>

TrainCarts/API/SignAction

2025-10-12T09:56:29Z

RyanDo:

<languages/>
<translate>

This TrainCarts API allows custom signs to be registered, so that the registered executor callback is automatically run when trains go past them. This makes it very easy to make trains perform unique actions using a third-party plugin.

== Example Template == 


To begin, create a new class in your plugin with the following code:
<pre>
import org.bukkit.entity.Player;


import com.bergerkiller.bukkit.tc.controller.MinecartMember;
import com.bergerkiller.bukkit.tc.events.SignActionEvent;
import com.bergerkiller.bukkit.tc.events.SignChangeActionEvent;
import com.bergerkiller.bukkit.tc.signactions.SignAction;
import com.bergerkiller.bukkit.tc.signactions.SignActionType;
import com.bergerkiller.bukkit.tc.utils.SignBuildOptions;


/**
* Displays a welcome message to the players in the train
*/
public class SignActionWelcome extends SignAction {


@Override
public boolean match(SignActionEvent info) {
// Checks that the second line starts with 'welcome' (case-insensitive)
return info.isType("welcome");
}


@Override
public void execute(SignActionEvent info) {
// When a [train] sign is placed, activate when powered by redstone when the train
// goes over the sign, or when redstone is activated.
if (info.isTrainSign()
&& info.isAction(SignActionType.GROUP_ENTER, SignActionType.REDSTONE_ON)
&& info.isPowered() && info.hasGroup()
) {
for (MinecartMember<?> member : info.getGroup()) {
sendGreetingForCart(info, member);
}
return;
}


// When a [cart] sign is placed, activate when powered by redstone when each cart
// goes over the sign, or when redstone is activated.
if (info.isCartSign()
&& info.isAction(SignActionType.MEMBER_ENTER, SignActionType.REDSTONE_ON)
&& info.isPowered() && info.hasMember()
) {
sendGreetingForCart(info, info.getMember());
return;
}
}


public void sendGreetingForCart(SignActionEvent info, MinecartMember<?> member) {
// Lines 3 and 4 configure the message to send
String message = info.getLine(2) + info.getLine(3);


// Send to all player passengers of the cart (could be multiple seats!)
for (Player passenger : member.getEntity().getPlayerPassengers()) {
passenger.sendMessage(message);
}
}


@Override
public boolean build(SignChangeActionEvent event) {
// This is executed when a player places down a sign matching this sign action
// Permissions are checked and then a message is displayed to the player
// For simplicity you can use the SignBuildOptions API for this.
// You are free to use your own code here that checks permissions/etc.
return SignBuildOptions.create()
.setName(event.isCartSign() ? "cart welcome greeter" : "train welcome greeter")
.setDescription("sends a welcome message to all players in the train")
.handle(event.getPlayer());
}
}
</pre>


This is a simple example of a sign that sends a message to all players in the train. By default signs will support the standard TrainCarts conventions for the first line, where redstone options can be configured. The second line is typically used to match the sign type, and the last two lines are free to be used for anything.


To register the above class, perform the following in your plugin's main class:
<pre>
import org.bukkit.plugin.java.JavaPlugin;


import com.bergerkiller.bukkit.tc.signactions.SignAction;


public class TCWelcomeSign extends JavaPlugin {
public final SignActionWelcome signActionWelcome = new SignActionWelcome();


@Override
public void onEnable() {
// Register the signs
SignAction.register(signActionWelcome);
}


@Override
public void onDisable() {
// Unregister the signs to prevent problems during /reload
SignAction.unregister(signActionWelcome);
}
}
</pre>


It is important to both '''register''' and '''unregister''' the sign. That way, when the server is reloaded, or the plugin or reloaded using for example ''PlugMan'', things don't break.

== The Execute Method == 


Various events are sent to signs and can be handled by the sign. All events are handled through the '''execute(event)''' callback.

=== Cart/Train Enter and Leave === 


When each individual ''cart'' hits a piece of track with a sign matching the sign action, the '''MEMBER_ENTER''' event is fired. When they move off the track again, a '''MEMBER_LEAVE''' event is fired. Similarly, for entire trains, a '''GROUP_ENTER''' and '''GROUP_LEAVE''' is fired.

=== Redstone === 


When the sign becomes powered from an unpowered state, '''REDSTONE_ON''' and '''REDSTONE_CHANGE''' fire. In reverse, '''REDSTONE_OFF''' and '''REDSTONE_CHANGE''' fire. When the power state doesn't change, but other blocks nearby change redstone levels that might influence the sign behavior, just '''REDSTONE_CHANGE''' is fired. The event has helper methods to figure out the power state of the sign or a given direction of the sign.

=== Movement === 


Every tick, while the train is moving, a '''MEMBER_MOVE''' event is fired. By default through, this is disabled for performance reasons. To use this event, override '''isMemberMoveHandled(event)''' and return true there.

=== Updates === 


When players enter the train, leave it, properties change or other similar events occur, a '''MEMBER_UPDATE''' event fires. This is useful if the sign uses such information to, for example, toggle a lever.

== Loaded Changed Event == 


The '''loadedChanged(event, loaded)''' method can be overrided to get notified when a sign matching this sign action is loaded or unloaded on the server. A sign is loaded when placed, or when a chunk loads with the sign in it. A sign is unloaded when destroyed, or when a chunk unloads with the sign in it. Be careful not to load or unload chunks in this method. This is a useful method to cache data in memory while the sign is in use.

== Remote Control == 


Remote control enables the sign to be activated by redstone, to then operate on one or more trains by name pattern. To use remote control with the sign, override '''canSupportRC()''' and return true.

== Path Finding == 


Some advanced methods can be overrided to make the sign act as a node in the [[Special:MyLanguage/TrainCarts/PathFinding|path-finding]] network:
* ''isRailSwitcher(event)'' - Return true if this sign switches the rails from/to any direction
* ''getRailDestinationName(event)'' - Return non-null to provide a unique destination name
* ''isPathFindingBlocked(event, railState)'' - Return true to tell the path finding algorithm that in this direction no further movement is possible

</translate>

TrainCarts/MobEntering

2025-10-12T09:56:07Z

RyanDo:

<languages/>
<translate>
== Putting mobs into Minecarts == 


Mobs are put into minecarts through a [[Special:MyLanguage/TrainCarts/Signs/Property|collision property]] rule. By default this automatic entering is disabled. To turn it on for a train you have just spawned or [[Special:MyLanguage/TrainCarts/Commands#Selecting|selected]], run the following command:
<pre>/train collision mobs enter</pre>


This command only changes this for the one train you had selected.

== Default Behavior == 


If you want all minecarts placed by players to put mobs into them by default, you have two options. You can make it so that minecarts placed by players are vanilla Minecraft minecarts, but that means they cannot be trains. [[Special:MyLanguage/TrainCarts/VanillaMinecarts|See this page for more information about that.]]


Alternatively, you can change the default setting for newly placed minecarts. To do so, edit <code>plugins/Train_Carts/DefaultTrainProperties.yml</code>.


There's multiple blocks of configurations:
* '''default''' is for normal players
* '''admin''' for players with the <code>train.properties.admin</code> permission (OP by default)
* '''spawner''' is for trains spawned with the m/s/p/etc. syntax, on spawner signs. Does not apply to saved trains that are spawned.


For the category/categories you want to edit, find the line:
<pre>collision: {}</pre>
Or, it might look like this if it already had some configurations:
<pre> collision:
players: DEFAULT
misc: PUSH
train: LINK
block: DEFAULT</pre>


And change it to:
<pre>
collision:
animal: ENTER
monster: ENTER
</pre>
You can leave previous options if they existed.


On more modern versions of TrainCarts this can work too:
<pre>
collision:
mobs: ENTER
</pre>


Then, either restart the server, or run this command:
<pre>/train globalconfig reload --defaulttrainproperties</pre>

== Other Options == 


Besides ''mobs'' there is a more fine-grained list of categories of mobs that can be set specific collision options for. The names are case-sensitive, and must be lower-cased. On newer versions of TrainCarts plural names work, too.


{| class="wikitable"
|-
! YAML Key !! Category Description
|-
| pet || Tameable animals
|-
| jockey || Jockey mounts that can spawn for monsters, like spiders, skeletons, zombie and chickens
|-
| killer_bunny || Rabbit mob, that is a killer bunny specialized type
|-
| npc || Mobs that are NPCs, like villagers
|-
| animal || Passive animal mobs including mobs like the bat and squid
|-
| monster || Hostile monster mobs, including slimes, golems and phantom
|-
| passive || Passive mobs. Large overlap with animal
|-
| neutral || Neutral mobs that can become aggressive. For example, enderman.
|-
| hostile || Hostile mobs that cannot be passive. For example, creeper.
|-
| tameable || Same as pet. Tameable animals
|-
| utility || Utility mobs. Only Golems.
|-
| boss || Boss mobs. Ender dragon, wither.
|}

</translate>

TrainCarts/Editing

2025-10-12T09:55:32Z

RyanDo:

== Introduction ==
TrainCarts tracks what minecart entity a player is currently editing. Most [[TrainCarts/Commands|commands]] and also the [[TrainCarts/Attachments|attachment editor]] operate on the train the player has selected. There are various ways to change what train is being edited, each method will be explained on this page.

== Placing down new minecarts ==
Whenever players place down new minecarts, or use the [[TrainCarts/Train_Spawn_Chest|train spawn chest]], the cart or train is automatically selected. After placing down a minecart players can therefore instantly use commands to configure it.

== Sitting inside a minecart ==
When entering a train, players will automatically edit the cart they entered. When they leave the cart again, the cart remains selected.

== Damaging while sneaking ==
When a cart is hit while sneaking, or ''slapped'', the cart is not destroyed and instead the cart is selected. Similarly, when damaging a cart in survival, players can select carts.

== Edit command ==
The ''edit'' command can also be used to select carts. This can be done by specifying the name of the train, or by looking at the cart to edit. A particle effect is displayed when a train is selected.
{{Command|train edit|Edits the cart a player is looking at|must be a train owner}}
{{Command|train edit [name]|Edits the train with a given name|must be a train owner}}

TrainCarts/Acceleration

2025-10-12T09:55:24Z

RyanDo:

== Introduction ==
Acceleration is the rate at which trains speed up or slow down. This is an important metric when launching or stopping trains. TrainCarts supports various ways of specifying acceleration in both metric and imperial units.

As a base unit TrainCarts uses ''blocks/tick<sup>2</sup>'' This can be understood as: ''Increase the speed by <value> blocks/tick every tick''. A single tick is 1/20 second. All units are case-insensitive. Some mix-matching of units is possible, for example, you can use ''20m/hh'' even though it is not listed.

== Syntax ==
{| class="wikitable"
|-
! Input
! blocks/tick<sup>2</sup>
! Explanation
|-
| 0.2<br>0.2/tt
| 0.2
| When no unit is specified, the value is in blocks/tick<sup>2</sup>
|-
| 20m/ss<br>20/ss<br>20/s2<br>20/s/s
| 0.05
| Unit in blocks/second<sup>2</sup> (or m/s<sup>2</sup>). Can be specified with 2x s, or s2. The ''m'' before the unit is optional.
|-
| 30km/h/s<br>30kmh/s<br>30kmph/s
| 0.020833
| Unit in kilometers/hour per second. Can be specified as km/h, kmh or kmph.
|-
| 3.28ft/s/s<br>3.28ft/ss
| 0.0025
| Unit in feet/second<sup>2</sup>
|-
| 1.0mi/h/s<br>1.0mph/s
| 0.0011176
| Unit in miles/hour per second. mi/h can be specified as mph.
|-
| 1.5G
| 0.0367875
| Unit based on G-forces. 1G is assumed to be 9.81m/s<sup>2</sup>
|}

TrainCarts/Velocity

2025-10-12T09:55:16Z

RyanDo:

== Introduction ==
Velocity is the speed of the train. Speed syntax is important for [[TrainCarts/Signs/Launcher#Third_line|Launcher signs]], [[TrainCarts/Signs/Property#Properties|Speed limit property]] and any other places where a speed is specified.

As a base unit TrainCarts uses ''blocks/tick'' This can be understood as: ''Move the train by <value> blocks every tick''. A single tick is 1/20 second. All units are case-insensitive. Some mix-matching of units is possible, for example, you can use ''20m/h'' even though it is not listed. For a change in velocity, see [[TrainCarts/Acceleration]].

== Syntax ==
{| class="wikitable"
|-
! Input
! blocks/tick
! Explanation
|-
| 0.2<br>0.2/t
| 0.2
| When no unit is specified, the value is in blocks/tick
|-
| 20m/s<br>20/s
| 1.0
| Unit in blocks/second (or m/s). The ''m'' before the unit is optional.
|-
| 30km/h<br>30kmh<br>30kmph
| 0.4167
| Unit in kilometers/second. Can be specified as km/h, kmh or kmph.
|-
| 3.28ft/s
| 0.05
| Unit in feet/second
|-
| 1.0mi/h<br>1.0mph
| 0.022352
| Unit in miles/hour. mi/h can be specified as mph.
|}

TrainCarts/API

2025-10-12T09:55:03Z

RyanDo:

<languages/>
<translate>

TrainCarts is written in a way to allow third-party plugins to extend it. Various mechanics are built-in api's implemented by TrainCarts, such as the different vanilla rails, signs and more. For programmers, this page details the different modules in TrainCarts that can be used in third-party plugins.

== Custom Signs == 


The '''SignAction''' API allows custom signs to be registered with the plugin so that trains can activate them, much like the built-in [[Special:MyLanguage/TrainCarts/Signs|TrainCarts signs]].


[[Special:MyLanguage/TrainCarts/API/SignAction|» SignAction API]]

== Custom Track == 


The '''RailType''' and '''RailLogic''' API allows custom rail types to be registered. Vanilla Minecart Track uses this same API.


[[Special:MyLanguage/TrainCarts/API/Rail|» Rail API]]

== Custom Attachments == 


Custom '''Attachment Types''' can be registered to extend what visible capabilities trains can support. Once registered, they become selectable in the in-game [[Special:MyLanguage/TrainCarts/Attachments|attachment editor menu]].


[[Special:MyLanguage/TrainCarts/API/Attachments|» Attachments API]]

</translate>

BKCommonLib/ConfigurationAPI

2025-10-12T09:53:35Z

RyanDo:

==Introduction==
Let's be honest here...YAML configuration is a pain to work with. The defaults system requires additional files to be added, it is impossible to automatically cast types, and the support for headers is terrible. The Configuration API makes working with configuration a breeze.

Configuration node and value paths are delimited by '.'-characters. To obtain the value of setting in the node settings, you would use path settings.setting.

Usage
Configuration works using stored nodes in a tree of data, as this is how YAML operates.

Loading and saving configuration
We will mainly cover configuration reading from file and saving to file. The API is built around the principle to read and write files, so there is little support for anything else. If you wish to read or write to another storage system, you can use the loadFromStream and saveToStream methods found in [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/config/BasicConfiguration.java BasicConfiguration].

To start a new configuration for a file in, for example, plugin enable, you can do the following:

<pre>FileConfiguration config = new FileConfiguration(this, "config.yml");
if (config.exists()) {
config.load(); // Load the configuration from the file
} else {
config.set("config1", 12);
config.set("config2", 14);
config.save(); // Saves the new data to file
}

System.out.println(config.get("config1", Integer.class));
System.out.println(config.get("config2", Integer.class));</pre>

==Getting values and their defaults==
There is a major difference in getting values between this API and the default Bukkit implementation. In the Configuration API, the defaults specified are automatically set in the configuration if the value was not found. This makes it tonnes easier to start a (new) configuration. In the example above it first checked if the file exists, but this can be done a lot easier:

<pre>FileConfiguration config = new FileConfiguration(this, "config.yml");
config.load();
System.out.println(config.get("config1", 12));
System.out.println(config.get("config2", 14));
config.save();</pre>

Loading is allowed if the file does not exist, it will simply not load anything in that case. When getting the two values, it will automatically assign '12' to 'config1' if such a node was not loaded. When saving, it will automatically update these values.

Various stored types are supported, including all enumeration types (like Material and GameMode). To perform the same as the above but with Lists or Arrays, you can do the following:

<pre>List<Integer> ints = config.getList("blockIds", Integer.class);</pre>

It will automatically create an empty list in this case if it wasn't set. If you wish to specify defaults as well: this is possible. Non-integer convertable values are automatically filtered from the list, so no worries of having a String in there.

==Nodes==
YAML is a tree-based storage system, so support for Configuration Nodes is there as well. You do not have to use node objects to create nodes, but they can make it easier to pass around configuration in your plugin to several components. You can use getNode(path) to get a node. If the node does not yet exist, it is made and returned. For that reason, this method never returns null.

<code>ConfigurationNode entities = config.getNode("entities");
maxCount = entities.get("maxCount", 225);
message = entities.get("message", "You have reached the maximum amount of entities");
EntityLogic.initialize(entities);</code>

There is no difference between ConfigurationNode functionality and Configuration functionality - File/Basic Configuration is a node as well. The only difference is that a ConfigurationNode does not store information such as file, indent and other settings.

==Headers==
The Configuration API adds support for configuration headers, to give useful descriptions of configuration nodes and values. It produces output such as:

<pre># This is the configuration of MyAwesomePlugin

# Sets the awesomeness of this plugin
awesomeness: 85

# Controls what levels of awesomeness are enabled
enabledLevels:
# Whether awesome looks are enabled
looks: true
# Whether awesome usage is enabled
usage: false</pre>

As you can see, the first header (the 'main' header) has a slightly different syntax. This is to prevent the first node header (awesomeness) from conflicting with the main header. Setting node headers is very easy:

<pre>// Set the top-level header
config.setHeader("This is the configuration of MyAwesomePlugin");

// Set the header of an option
config.setHeader("awesomeness", "\nSets the awesomeness of this plugin");
config.setHeader("enabledLevels", "\nControls what levels of awesomeness are enabled");
config.setHeader("enabledLevels.looks", "Whether awesome looks are enabled");
config.setHeader("enabledLevels.usage", "Whether awesome usage is enabled");</pre>

You can use the newline character '\n' to have multiple header lines, or to create empty lines (as seen in the example). There is also an addHeader method, which basically appends more text to the current header on a new line. This is somewhat equivalent to:

<pre>config.setHeader("awesomeness", config.getHeader("awesomeness") + "\n" + "Something added on a new line");</pre>

==Conclusion==
By setting defaults while getting data from a configuration, it is a lot easier to perform loading and saving. The addition of per-node headers allows configuration fil

BKCommonLib/TabView

2025-10-12T09:49:52Z

RyanDo:

==Introduction==
BKCommonLib features an advanced method of changing what is shown when players press tab, previously known as the 'Player List'. With our service you can alter every cell of this list based on column and row indices. In combination, it features a name generation scheme that allows you to place the same text multiple times. Minecraft limits the text you can put to 16 characters, so we were forced to abide it. If you have the same text twice, this limit becomes 14 (due to the name generation appending two characters).

==Initialization of your tab view==
To use this service, first of all obtain a TabView instance while enabling your plugin. You can do this in onEnable, but doing it in the constructor or field area of your plugin class is fine too. For example:

<pre>public class MyPlugin extends JavaPlugin {
private TabView tabView = TabView.createTab(3, 20);

public void onEnable() {
}

public void onDisable() {
}
}</pre>
Please note that it is not possible to create new tabs while the server is running. This is because BKCommonLib can not alter the shown player list dimensions of existing players, and it requires a re-login to fix. To avoid these bugs, the '''maximum dimensions''' of the tab view you need have to be specified while your plugin starts up. After loading up, you can demand player lists that are smaller than the one you create on startup, but you can not create larger ones. If you expect to be using a variable size tab list, be sure to initialize a tab view of the maximum size you expect.

The maximum width you can use is 3, the maximum height is 20. This is the same as the server enforces.

==Altering your tab view==
Now you have a TabView instance, what can you do with it? Well, you can set, for each cell, what text and ping icon to display in it. To do so there are many methods available to you. You can fill all cells at once, fill a single row or column, set an area or a single cell. You can also create sub-views into your TabView so you can send it to a method and alter it there, with bounds checking. Look into the JavaDoc and you'll be amazed at the possibilities.

==Displaying your tab view==
Updates for changes made in the tab are automatically sent to all viewers at the end of each server tick, so no worries of having to update manually each tick. To display your Tab View to a player, or to all players, use the '''displayTo''' and '''displayToAll''' methods. In the case of displayToAll, all players that join the server will automatically see your Tab View as well. If you want to see whether a Tab View is shown to a Player (for example, to provide a toggle), you can use the '''isDisplayedTo''' method.

What happens when two plugins try to display a tab? Well, the previous tab will be hidden and the new tab will be shown. Please, do not abuse this by forcing a display each tick. It is up to the users to decide what they want to see, so provide a command toggle! Don't automate or schedule the display of tabs, it will only cause annoyance by the users.

==Displaying the default player list again==
If you want to display the default player list again, or an empty list, use the '''TabView.DEFAULT''' or '''TabView.EMPTY''' constants. By calling '''TabView.DEFAULT.displayToAll()''' everyone sees the (auto-updated) player list again.

===But I want both!===
Adding automatic player name and ping updates to custom tabs would create a confusing API, so if you wish to show player names behind, around or after your own Tab View, it is best if you do this yourself. You can use a tick task to set all text and ping values in your custom tab view. No changes are sent if the name didn't change, so it won't cause lag. Updating the text or ping of a cell is pretty much instant, there is no heavy operation involved.

===What if I want to show a different view per player?===
You can do so by cloning the TabView instance created on startup. For example:

<pre>TabView myView = this.tabView.clone();
myView.set(0, 0, player.getName(), TabView.PING_NONE);
myView.displayTo(player);</pre>
If you want different (smaller!) sizes, you can use '''cloneResize(width, height)'''.

==Example==
Below is an example code for displaying the player names, experience and their time lived in a table. A maximum of 17 players is supported. For initialization the example initialization code above was used. This code can be put anywhere, in this case it was put in a command handler. You can also place it in the enable logic of the plugin, but be aware that other plugins that do the same could cause conflicts then. It's best to allow users to toggle your Tab View on or off.

<pre>// Show header at line 1, 2 and 3
tabView.fillRow(0, "==============", TabView.PING_1);
tabView.fillRow(1, TabView.TEXT_NONE, TabView.PING_NONE);
tabView.setRowText(1, "Players", "Experience", "Time Alive");
tabView.fillRow(2, "==============", TabView.PING_1);
// Show scores
int line = 3;
for (Player player : Bukkit.getOnlinePlayers()) {
tabView.set(0, line, player.getPlayerListName(), TabView.PING_FULL);
tabView.set(1, line, "" + player.getTotalExperience(), TabView.PING_FULL);
tabView.set(2, line, "" + (player.getTicksLived() / 20) + "s", TabView.PING_FULL);
line++;
// Out of bounds!
if (line >= tabView.getHeight()) {
break;
}
}
// Display to everyone
tabView.displayToAll();</pre>
This creates the resulting image: TabView example result

==Conflicting plugins==
If there is another plugin that alters the player list view, it might not get to do what it wants to do since BKCommonLib blocks it when a custom TabView is being shown. When the DEFAULT TabView is shown, other plugins can safely send their messages, since BKCommonLib then allows these messages to go through. When DEFAULT is not shown, BKCommonLib will keep track of these discarded messages and send them again when DEFAULT is shown again.

So, if your plugin shows a custom TabView, it is best to allow players to toggle this off by showing the DEFAULT tab view. Any other plugin that was trying to show something will get a chance to do so then.

==Some tips and tricks==
* To wipe everything previously shown, use fillAll("", 0)
* To quickly set everything, use setArea/Column/RowText
* You can clone an entire view using clone()
* You can get a newly sized TabView by using cloneResize(newWidth, newHeight)
* There are many TabView.PING_X constants to display certain ping icons
* You do not have to limit the displayed text by 16, this is done for you

MyWorlds/ManagingWorlds

2025-10-12T09:49:26Z

RyanDo:

<languages/>
<translate>

==How to create, load, save, unload, delete and copy worlds== 
This page covers all the details for creating new worlds, loading existing worlds, saving worlds, unloading worlds and world file operations such as delete and copy.

==Setting up the server== 


The server always generates a few initial worlds, which are mainworld, mainworld_nether and mainworld_the_end (if hellworld is enabled). It is required to have these worlds loaded at all times, and since MyWorlds enables after these worlds are loaded, MyWorlds is unable to alter the properties of these main worlds. If you plan on not using the overworld/nether/the end worlds, you still have to have them loaded. You can change 'keep spawn loaded' to false so these worlds do not occupy any memory, and change 'mainworld' to the desired main world where new people spawn in the config.yml. Then these worlds are not used (but could be used).

==Preface== 


All commands except delete match the world name you type in against already existing worlds. If you have a world named 'CreeperCraft12', you can access the world using 'Creeper' or 'Craft12' as well. It first looks for world names that equal your name entered, then the world names containing what you entered and finally the world names contained in what you entered.


For command permissions, [[MyWorlds/Permissions|see here]].

==Creating New Worlds== 


The first step is to create new worlds you want to use on your server. There are two kinds of ways you can create worlds, they will be listed separately.

===Creating Vanilla worlds=== 


To create normal/nether/flat/the_end worlds, you can use the commands:


<pre>/world create worldname_environment(::options) (seed)</pre>


The ()-surrounded parts are optional. If no seed is specified, a random seed is used instead. When worldname_environment is used, the environment type is appended to the world name, while with worldname/environment it will not append it to the name. Appending the world environment to the name is recommended, since it eases loading the worlds if no configuration is available for it yet. Not specifying an environment means that the NORMAL environment will be used. Bear in mind that the Bukkit 'Environment' and 'Worldtype' are merged as one in MyWorlds. To have a 'nether flatworld', you use 'nether_flat' as environment. Note that most combinations are not used by Bukkit at all and are a bit useless, they are only useful if you have a modded server such as MCPC+ where these custom options are used.


In the case of the flatworld generator, you can specify addition world options to specify what type of layers to generate. These are the same options as can be seen in the 'Create new world - Customize' windows in the client. It is here that you can, for example, change the height of the flatworld, change block types or include populators such as ores, villages and trees. The format of the options is a bit vague, you can find more help on this subject on the Minecraft Wiki.

===Creating worlds using a generator plugin=== 


You can also specify a world generator plugin to generate the worlds for you. When these plugins ask for a 'World manager' to do so, just like Multiverse, MyWorlds allows you to do this. Similar to 'world options' above, you can specify a generator plugin and generator arguments in the command.


<pre>/world create worldname_environment:plugin(:arguments) (seed)</pre>


Arguments and seed are optional. Some plugins support arguments, others don't. For more help on what the arguments are and what the format is, visit the plugin pages of these generator plugins.

===Examples=== 


Command Result
{| class="wikitable"
! Command !! Description
|-
| /world create world1 || Creates a new overworld called 'world1'
|-
| /world create world1_nether || Creates a new netherworld called 'world1_nether'
|-
| /world create mynether/nether || Creates a new netherworld called 'mynether'
|-
| /world create HippoCraft/flat 251 || Creates a new flatworld called 'HippoCraft' using seed 251
|-
| /world create waterworld/flat::2;7,5x1,5x3,5x12,90x9;1;biome_1,village || Creates a flat waterworld
|-
| /world create Space:bSpace:awesome || Create a spaceworld using the bSpace generator plugin with the 'awesome' settings
|}

==Loading existing worlds== 


You want to load worlds created by others or by a previous/other plugin: this is of course possible. But, if the world is completely new and unknown to MyWorlds its configuration, be VERY sure to specify all arguments required to load the world properly.


{| class="wikitable"
! Command !! Description
|-
| /world load worldname || Loads world 'worldname'
|-
| /world load worldname/nether || Loads world 'worldname' as a 'nether' environment world
|-
| /world load worldname/nether:plugin:arguments || Loads world 'worldname' making use of a chunk generator plugin "plugin"
|}
The same create world command syntax is applied. The seed and world options are stored in the world data file, and don't have to be specified. The environment and optional generator plugin, however, do have to be specified, as it is not stored in the world. Of course, if you already loaded the world once before, just using <code>/world load worldname</code> is sufficient, since MyWorlds already knows what kind of environment and generator plugin the world uses. The other commands only apply when loading worlds not created by MyWorlds.


Not specifying the right environment or generator plugin will cause chunks to be generated at the borders of the world that do not match with the world. For example, loading a flatworld named 'creativeworld' for the first time without specifying the 'flat' environment will cause overworld chunks to be generated at the borders.

==Listing available environments/generators== 


You can use <code>/world listgenerators</code> to show a list of all available generator plugins. Using <code>/world create</code> will list the usage in combination with all available environments.

==Listing available worlds== 


You can use <code>/world list</code> to list all available (loaded, broken and not loaded) worlds. All folders containing a level.dat or a region folder are listed.

==Unloading worlds== 


To unload worlds when you no longer need them, use <code>/world unload worldname</code>. In case you having autosaving disabled for the world, use <code>/world save worldname</code> before unloading just to avoid losing progress.

==Saving worlds== 


To save worlds, use <code>/world save worldname</code> to save a single world or /world save all to save all worlds. Instead of 'all' you can also use '*'.

==Copying worlds - renaming worlds== 


You can copy a world to a new name using <code>/world copy worldname newworldname</code>. The new world can then be loaded again. All world properties from the old world are copied over as well, including generator plugin and environment information. After copying you can load the world safely and/or delete the previous world. You need the right permissions to do this in-game, you can always do this through the console.

==Deleting worlds== 


To delete a world from disk permanently, use <code>/world delete worldname</code>. The worldname must be completely accurate. Name matching is not used, since deleting the wrong world would become possible then. You need the right permissions to do this in-game, you can always do this through the console.

==Repairing worlds== 


Shit happens, so it may occur that a world no longer loads properly or the server crashes when loading the world. To repair these worlds, you can use:


<pre>/world repair worldname
/world repair worldname seed</pre>
If you know what seed the world used, it is best to specify that as well. Just in case the level.dat of the world got corrupted and it can no longer read the seed from it, it can use your specified seed to regenerate the settings. It is best if you keep a backup of your level.dat somewhere so that, may it ever get corrupted, you can fix it up without losing settings.


Apart from regenerating the level.dat, it also goes by all region files and:


Removes chunks that are lost (compression error), and will be regenerated
Relocate chunks
Keep a backup of the old, unchanged region files
In all cases, every chunk lost is an actual chunk lost, there is nothing that can be done about that. Making frequent backups of the world is recommended for that reason.


Only unloaded worlds can be repaired. If your corrupted world is the main world, set up a small server somewhere and repair it using that, or simply change the main world in the server configuration and then repair it while unloaded.
</translate>

MyWorlds/ManagingWorlds

2025-10-12T09:49:11Z

RyanDo:

MyWorlds/ManagingWorlds

2025-10-12T09:49:04Z

RyanDo: Marked this version for translation

<languages/>
<translate>
==How to create, load, save, unload, delete and copy worlds== 
This page covers all the details for creating new worlds, loading existing worlds, saving worlds, unloading worlds and world file operations such as delete and copy.

==Setting up the server== 


The server always generates a few initial worlds, which are mainworld, mainworld_nether and mainworld_the_end (if hellworld is enabled). It is required to have these worlds loaded at all times, and since MyWorlds enables after these worlds are loaded, MyWorlds is unable to alter the properties of these main worlds. If you plan on not using the overworld/nether/the end worlds, you still have to have them loaded. You can change 'keep spawn loaded' to false so these worlds do not occupy any memory, and change 'mainworld' to the desired main world where new people spawn in the config.yml. Then these worlds are not used (but could be used).

==Preface== 


All commands except delete match the world name you type in against already existing worlds. If you have a world named 'CreeperCraft12', you can access the world using 'Creeper' or 'Craft12' as well. It first looks for world names that equal your name entered, then the world names containing what you entered and finally the world names contained in what you entered.


For command permissions, [[MyWorlds/Permissions|see here]].

==Creating New Worlds== 


The first step is to create new worlds you want to use on your server. There are two kinds of ways you can create worlds, they will be listed separately.

===Creating Vanilla worlds=== 


To create normal/nether/flat/the_end worlds, you can use the commands:


<pre>/world create worldname_environment(::options) (seed)</pre>


The ()-surrounded parts are optional. If no seed is specified, a random seed is used instead. When worldname_environment is used, the environment type is appended to the world name, while with worldname/environment it will not append it to the name. Appending the world environment to the name is recommended, since it eases loading the worlds if no configuration is available for it yet. Not specifying an environment means that the NORMAL environment will be used. Bear in mind that the Bukkit 'Environment' and 'Worldtype' are merged as one in MyWorlds. To have a 'nether flatworld', you use 'nether_flat' as environment. Note that most combinations are not used by Bukkit at all and are a bit useless, they are only useful if you have a modded server such as MCPC+ where these custom options are used.


In the case of the flatworld generator, you can specify addition world options to specify what type of layers to generate. These are the same options as can be seen in the 'Create new world - Customize' windows in the client. It is here that you can, for example, change the height of the flatworld, change block types or include populators such as ores, villages and trees. The format of the options is a bit vague, you can find more help on this subject on the Minecraft Wiki.

===Creating worlds using a generator plugin=== 


You can also specify a world generator plugin to generate the worlds for you. When these plugins ask for a 'World manager' to do so, just like Multiverse, MyWorlds allows you to do this. Similar to 'world options' above, you can specify a generator plugin and generator arguments in the command.


<pre>/world create worldname_environment:plugin(:arguments) (seed)</pre>


Arguments and seed are optional. Some plugins support arguments, others don't. For more help on what the arguments are and what the format is, visit the plugin pages of these generator plugins.

===Examples=== 


Command Result
{| class="wikitable"
! Command !! Description
|-
| /world create world1 || Creates a new overworld called 'world1'
|-
| /world create world1_nether || Creates a new netherworld called 'world1_nether'
|-
| /world create mynether/nether || Creates a new netherworld called 'mynether'
|-
| /world create HippoCraft/flat 251 || Creates a new flatworld called 'HippoCraft' using seed 251
|-
| /world create waterworld/flat::2;7,5x1,5x3,5x12,90x9;1;biome_1,village || Creates a flat waterworld
|-
| /world create Space:bSpace:awesome || Create a spaceworld using the bSpace generator plugin with the 'awesome' settings
|}

==Loading existing worlds== 


You want to load worlds created by others or by a previous/other plugin: this is of course possible. But, if the world is completely new and unknown to MyWorlds its configuration, be VERY sure to specify all arguments required to load the world properly.


{| class="wikitable"
! Command !! Description
|-
| /world load worldname || Loads world 'worldname'
|-
| /world load worldname/nether || Loads world 'worldname' as a 'nether' environment world
|-
| /world load worldname/nether:plugin:arguments || Loads world 'worldname' making use of a chunk generator plugin "plugin"
|}
The same create world command syntax is applied. The seed and world options are stored in the world data file, and don't have to be specified. The environment and optional generator plugin, however, do have to be specified, as it is not stored in the world. Of course, if you already loaded the world once before, just using <code>/world load worldname</code> is sufficient, since MyWorlds already knows what kind of environment and generator plugin the world uses. The other commands only apply when loading worlds not created by MyWorlds.


Not specifying the right environment or generator plugin will cause chunks to be generated at the borders of the world that do not match with the world. For example, loading a flatworld named 'creativeworld' for the first time without specifying the 'flat' environment will cause overworld chunks to be generated at the borders.

==Listing available environments/generators== 


You can use <code>/world listgenerators</code> to show a list of all available generator plugins. Using <code>/world create</code> will list the usage in combination with all available environments.

==Listing available worlds== 


You can use <code>/world list</code> to list all available (loaded, broken and not loaded) worlds. All folders containing a level.dat or a region folder are listed.

==Unloading worlds== 


To unload worlds when you no longer need them, use <code>/world unload worldname</code>. In case you having autosaving disabled for the world, use <code>/world save worldname</code> before unloading just to avoid losing progress.

==Saving worlds== 


To save worlds, use <code>/world save worldname</code> to save a single world or /world save all to save all worlds. Instead of 'all' you can also use '*'.

==Copying worlds - renaming worlds== 


You can copy a world to a new name using <code>/world copy worldname newworldname</code>. The new world can then be loaded again. All world properties from the old world are copied over as well, including generator plugin and environment information. After copying you can load the world safely and/or delete the previous world. You need the right permissions to do this in-game, you can always do this through the console.

==Deleting worlds== 


To delete a world from disk permanently, use <code>/world delete worldname</code>. The worldname must be completely accurate. Name matching is not used, since deleting the wrong world would become possible then. You need the right permissions to do this in-game, you can always do this through the console.

==Repairing worlds== 


Shit happens, so it may occur that a world no longer loads properly or the server crashes when loading the world. To repair these worlds, you can use:


<pre>/world repair worldname
/world repair worldname seed</pre>
If you know what seed the world used, it is best to specify that as well. Just in case the level.dat of the world got corrupted and it can no longer read the seed from it, it can use your specified seed to regenerate the settings. It is best if you keep a backup of your level.dat somewhere so that, may it ever get corrupted, you can fix it up without losing settings.


Apart from regenerating the level.dat, it also goes by all region files and:


Removes chunks that are lost (compression error), and will be regenerated
Relocate chunks
Keep a backup of the old, unchanged region files
In all cases, every chunk lost is an actual chunk lost, there is nothing that can be done about that. Making frequent backups of the world is recommended for that reason.


Only unloaded worlds can be repaired. If your corrupted world is the main world, set up a small server somewhere and repair it using that, or simply change the main world in the server configuration and then repair it while unloaded.
</translate>

MyWorlds/ManagingWorlds

2025-10-12T09:48:58Z

RyanDo:

<languages/>
<translate>
==How to create, load, save, unload, delete and copy worlds==

This page covers all the details for creating new worlds, loading existing worlds, saving worlds, unloading worlds and world file operations such as delete and copy.

==Setting up the server== 


The server always generates a few initial worlds, which are mainworld, mainworld_nether and mainworld_the_end (if hellworld is enabled). It is required to have these worlds loaded at all times, and since MyWorlds enables after these worlds are loaded, MyWorlds is unable to alter the properties of these main worlds. If you plan on not using the overworld/nether/the end worlds, you still have to have them loaded. You can change 'keep spawn loaded' to false so these worlds do not occupy any memory, and change 'mainworld' to the desired main world where new people spawn in the config.yml. Then these worlds are not used (but could be used).

==Preface== 


All commands except delete match the world name you type in against already existing worlds. If you have a world named 'CreeperCraft12', you can access the world using 'Creeper' or 'Craft12' as well. It first looks for world names that equal your name entered, then the world names containing what you entered and finally the world names contained in what you entered.


For command permissions, [[MyWorlds/Permissions|see here]].

==Creating New Worlds== 


The first step is to create new worlds you want to use on your server. There are two kinds of ways you can create worlds, they will be listed separately.

===Creating Vanilla worlds=== 


To create normal/nether/flat/the_end worlds, you can use the commands:


<pre>/world create worldname_environment(::options) (seed)</pre>


The ()-surrounded parts are optional. If no seed is specified, a random seed is used instead. When worldname_environment is used, the environment type is appended to the world name, while with worldname/environment it will not append it to the name. Appending the world environment to the name is recommended, since it eases loading the worlds if no configuration is available for it yet. Not specifying an environment means that the NORMAL environment will be used. Bear in mind that the Bukkit 'Environment' and 'Worldtype' are merged as one in MyWorlds. To have a 'nether flatworld', you use 'nether_flat' as environment. Note that most combinations are not used by Bukkit at all and are a bit useless, they are only useful if you have a modded server such as MCPC+ where these custom options are used.


In the case of the flatworld generator, you can specify addition world options to specify what type of layers to generate. These are the same options as can be seen in the 'Create new world - Customize' windows in the client. It is here that you can, for example, change the height of the flatworld, change block types or include populators such as ores, villages and trees. The format of the options is a bit vague, you can find more help on this subject on the Minecraft Wiki.

===Creating worlds using a generator plugin=== 


You can also specify a world generator plugin to generate the worlds for you. When these plugins ask for a 'World manager' to do so, just like Multiverse, MyWorlds allows you to do this. Similar to 'world options' above, you can specify a generator plugin and generator arguments in the command.


<pre>/world create worldname_environment:plugin(:arguments) (seed)</pre>


Arguments and seed are optional. Some plugins support arguments, others don't. For more help on what the arguments are and what the format is, visit the plugin pages of these generator plugins.

===Examples=== 


Command Result
{| class="wikitable"
! Command !! Description
|-
| /world create world1 || Creates a new overworld called 'world1'
|-
| /world create world1_nether || Creates a new netherworld called 'world1_nether'
|-
| /world create mynether/nether || Creates a new netherworld called 'mynether'
|-
| /world create HippoCraft/flat 251 || Creates a new flatworld called 'HippoCraft' using seed 251
|-
| /world create waterworld/flat::2;7,5x1,5x3,5x12,90x9;1;biome_1,village || Creates a flat waterworld
|-
| /world create Space:bSpace:awesome || Create a spaceworld using the bSpace generator plugin with the 'awesome' settings
|}

==Loading existing worlds== 


You want to load worlds created by others or by a previous/other plugin: this is of course possible. But, if the world is completely new and unknown to MyWorlds its configuration, be VERY sure to specify all arguments required to load the world properly.


{| class="wikitable"
! Command !! Description
|-
| /world load worldname || Loads world 'worldname'
|-
| /world load worldname/nether || Loads world 'worldname' as a 'nether' environment world
|-
| /world load worldname/nether:plugin:arguments || Loads world 'worldname' making use of a chunk generator plugin "plugin"
|}
The same create world command syntax is applied. The seed and world options are stored in the world data file, and don't have to be specified. The environment and optional generator plugin, however, do have to be specified, as it is not stored in the world. Of course, if you already loaded the world once before, just using <code>/world load worldname</code> is sufficient, since MyWorlds already knows what kind of environment and generator plugin the world uses. The other commands only apply when loading worlds not created by MyWorlds.


Not specifying the right environment or generator plugin will cause chunks to be generated at the borders of the world that do not match with the world. For example, loading a flatworld named 'creativeworld' for the first time without specifying the 'flat' environment will cause overworld chunks to be generated at the borders.

==Listing available environments/generators== 


You can use <code>/world listgenerators</code> to show a list of all available generator plugins. Using <code>/world create</code> will list the usage in combination with all available environments.

==Listing available worlds== 


You can use <code>/world list</code> to list all available (loaded, broken and not loaded) worlds. All folders containing a level.dat or a region folder are listed.

==Unloading worlds== 


To unload worlds when you no longer need them, use <code>/world unload worldname</code>. In case you having autosaving disabled for the world, use <code>/world save worldname</code> before unloading just to avoid losing progress.

==Saving worlds== 


To save worlds, use <code>/world save worldname</code> to save a single world or /world save all to save all worlds. Instead of 'all' you can also use '*'.

==Copying worlds - renaming worlds== 


You can copy a world to a new name using <code>/world copy worldname newworldname</code>. The new world can then be loaded again. All world properties from the old world are copied over as well, including generator plugin and environment information. After copying you can load the world safely and/or delete the previous world. You need the right permissions to do this in-game, you can always do this through the console.

==Deleting worlds== 


To delete a world from disk permanently, use <code>/world delete worldname</code>. The worldname must be completely accurate. Name matching is not used, since deleting the wrong world would become possible then. You need the right permissions to do this in-game, you can always do this through the console.

==Repairing worlds== 


Shit happens, so it may occur that a world no longer loads properly or the server crashes when loading the world. To repair these worlds, you can use:


<pre>/world repair worldname
/world repair worldname seed</pre>
If you know what seed the world used, it is best to specify that as well. Just in case the level.dat of the world got corrupted and it can no longer read the seed from it, it can use your specified seed to regenerate the settings. It is best if you keep a backup of your level.dat somewhere so that, may it ever get corrupted, you can fix it up without losing settings.


Apart from regenerating the level.dat, it also goes by all region files and:


Removes chunks that are lost (compression error), and will be regenerated
Relocate chunks
Keep a backup of the old, unchanged region files
In all cases, every chunk lost is an actual chunk lost, there is nothing that can be done about that. Making frequent backups of the world is recommended for that reason.


Only unloaded worlds can be repaired. If your corrupted world is the main world, set up a small server somewhere and repair it using that, or simply change the main world in the server configuration and then repair it while unloaded.
</translate>

BKCommonLib/NBTTagAPI

2025-10-12T09:48:11Z

RyanDo:

==Introduction==
To use NBT Tag objects to store information, or to interact with the Minecraft server internals which uses this format, BKCommonLib provides wrapper classes to work with them safely. These classes are:

CommonTag - for storing actual raw data like floats, doubles, String, arrays, etc. All other tag types extend this one.
CommonTagList - for storing integer-indexed values of the same type. Implements List.
CommonTagCompound - for storing text-mapped values of different types. Implements Map.
NBTUtil - for server-specific operations like loading and saving entities
The CommonTag classes are so-called 'wrapper' classes around actual internal NBT tag objects. They make it easier, and safer, to pass around tags. Internally, no CommonTag objects are stored, only the NBT types. Like all wrapper classes extending BasicWrapper, you can get (and set) the internal handle of the tag. This way you are able to use these objects with internal logic. In general, you will not really use that, but it's there.

==Usage==
There are several use cases for these tags:

==Working with NBT 'handle' Tags==
You can construct a CommonTag from the handle using:

<pre>CommonTag tag = CommonTag.create(handle);</pre>
If you are absolutely certain about the type of handle you pass in, you can cast the result to CommonTagList or Compound directly. After creation you can work on it directly, and changes you perform automatically update the handle you passed in initially.

==Creating new tags==
To construct new CommonTags from data, there are several options:

<pre>CommonTag tag1 = CommonTag.create("myTagName", "text");
CommonTag tag2 = new CommonTag("myIntData", 12);
CommonTagList tagList = new CommonTagList();
CommonTagList tagList = new CommonTagList("MyName", someListOfValues);
CommonTagCompound compound = new CommonTagCompound("SomeMap", someMapOfValues);</pre>
When no name is provided, a 'null' name is used. A tag name is not required, a value always is. You can not construct a data tag (CommonTag) without non-null and supported data. For that reason, this will NOT work:

<pre>CommonTag myData = new CommonTag("Data", null);
myData.setData(12);</pre>
This has to do with the fact that the internal handle can not change after creation, and it is impossible to hotswap this type.

==Methods==
'''Name'''
You can set the name of the tag using setName and get the current name using getName.

'''Data'''
All Common Tags provide setData and getData methods. These methods directly change the data stored by the internal implementation. In the case of CommonTagList and Compound, it allows you to directly set a map or list of values, instead of adding or removing a single mapped value.

'''Values'''
CommonTagList and Compound implement Map and List in a way that it stores other CommonTags, but if all you want is the value and do not want to create a wrapper class to get it each time, you can use the 'values' methods.

They store multiple values (or entries), so to make a distinction, index or text-mapped data are called values. They are called this way because it obtains the value from a tag stored. CommonTagList has many methods for adding, removing, getting and setting values, CommonTagList has many methods for putting, removing and getting values.

==Getting values==
At compile time it is never really certain what type of data is stored. For this reason, there are many overloads that automatically convert values. This way you are able to get a 'String' from an int or byte tag, or the other way around, without issues. To do this, you do have to specify the Class type to obtain, or a non-null default. Examples:

<pre>CommonTagCompound data = new CommonTagCompound("data");
data.putValue("x", 12);
data.putValue("y", 15);
data.putValue("difficulty", -1);
String textX = data.getValue("x", String.class);
double doubleY= data.getValue("y", 0.0);
Difficulty diffculty = data.getValue("difficulty", Difficulty.class, null);
if (difficulty != null) {
System.out.println(difficulty);
}</pre>
As you can see, it is even possible to obtain a difficulty from the difficulty identifier. The internal conversion system takes care of that for you.

==Using tags as lists and maps==
CommonTagList and Compound fully implement List and Map respectively. This includes iteration and other logic. For example:

<pre>CommonTagList list = new CommonTagList(12, 14, 16, 18, 12, -3);
for (CommonTag tag : list) {
System.out.println("VALUE: " + tag.getData(0));
}</pre>
Also note the getData(0), which gets the data as an Integer with 0 as default if this fails. If you wish to access the data directly, you can use the getAllValues method for list to do so:

<pre>for (int value : list.getAllValues(int[].class)) {
System.out.println(value);
}</pre>
Do note that this allocates a new int[] array for the result.

==Conclusion==
This API allows you to use tags as maps, lists or actual data. Additionally, it provides methods to directly obtain values from lists and maps, without creating new tags. It utilizes the internal conversion system to dynamically obtain values of any type you want, without forced method overloads. This allows further integration of NBT in other, generic classes.

BKCommonLib/PluginBase

2025-10-12T09:47:56Z

RyanDo:

==Introduction==
For more information, see also:

* [[BKCommonLib/Localization|Localization]]
* [[BKCommonLib/PermissionDefaults|Permission Defaults]]
* [[BKCommonLib/Metrics|Metrics]]
PluginBase is a basic JavaPlugin base class that eases the use of Localization, Permissions, error handling, logging and more. The base implementation takes care of a lot of things going on in the background, including a BKCommonLib compatibility check.

==Features==
All common plugin routines are taken care of. They will all be listed below. To use PluginBase in your plugin, simply instantiate it as follows:

<pre>public class MyPlugin extends PluginBase {
@Override
public void enable() {
// Enable logic
}

@Override
public void disable() {
// Disable logic
}

@Override
public boolean command(CommandSender sender, String command, String[] args) {
return false;
}

@Override
public int getMinimumLibVersion() {
return Common.VERSION;
}
}</pre>
==BKCommonLib routines==
getMinimumLibVersion() has to be overrided when using this base class. This method tells BKCommonLib the minimum version this plugin supports, so a proper message can be sent to the end-user if BKCommonLib is outdated. This avoids needless dependency-related issues.

==Localization==
The localization() method is called before enabling and can be used to load Locale information to read/write from/to the Localization.yml. You can load single localization lines or an entire enumeration of them using the loadLocale and loadLocales methods. Examples:

Loading localization lines one by one

<pre>@Override
public void localization() {
loadLocale("noperm", ChatColor.RED + "You do not have permission!");
loadLocale("nobuild", ChatColor.RED + "You can not build here!");
}</pre>
Loading localization lines from a class containing constants, or an enum

<pre>@Override
public void localization() {
loadLocales(MyLocale.class);
}

public class MyLocale extends LocalizationEnum {
public static final MyLocale NOPERM = new MyLocale("noperm", ChatColor.RED + "You do not have permission!");
public static final MyLocale NOBUILD = new MyLocale("nobuild", ChatColor.RED + "You can not build in world %0%!");

private Localization(String name, String defValue) {
super(name, defValue);
}

@Override
public String get(String... arguments) {
return MyPlugin.getInstance().getLocale(this.getName(), arguments);
}
}</pre>
The benefit of using a Locale class like the above is that you do not have to use getLocale(name), allowing you to get localization messages a lot easier. For example:

<pre>MyLocale.NOPERM.message(player);
MyLocale.NOBUILD.message(player, player.getWorld().getName());</pre>
==Permission defaults==
It works exactly the same way localization works, but instead you override permissions() and use the loadPermission and loadPermissions methods. The equivalent enumeration class to use is called PermissionEnum. This enumeration automatically provides methods for permission checks, such as handle and has.

==Commands==
BKCommonLib automatically gives you the name version command to display the currently running plugin and BKCommonLib version. It also takes care of permission issues, by using and handling the NoPermissionException. If this is thrown for the console, a message is displayed that the command is not possible for use in the console.

==Dependencies==
The updateDependency method is called whenever a new plugin enables, and after your plugin has enabled it calls it once for all currently enabled plugins. It allows you to keep track of dependencies, or to change some internal settings to provide support.

==Metrics==
You can automatically use Metrics by adding the following in the plugin.yml:

<pre>metrics: true</pre>
By default this is disabled. To use Metrics, call the provided hasMetrics and getMetrics methods. There is no need to start the Metrics instance when enabling, PluginBase does that for you. For more information about Metrics, see this page.

==Other==
* '''handle''' allows you to handle errors occurring in your plugin, which takes care of proper formatting and plugin disabling for critical errors
* '''log''' and '''logAction''' uses the plugin's logger to write messages, it's a simple shortcut
* '''register''' methods allow you to register Bukkit or packet listeners, and to register commands/commandhandlers
* '''getDataFile''' obtains a File object pointing to a file relative to the plugin 'workspace' directory
* Properly disables other plugins depending on you before your plugin disables to avoid conflicts
* Handles enable, disable and command method errors automatically

BKCommonLib/Metrics

2025-10-12T09:47:40Z

RyanDo:

{{Update|BKCommonLib|10 June 2021|reason=BKCommonLib now uses bStats metrics.|date=16 June 2023}}
==Introduction==
[https://dev.bukkit.org/linkout?remoteUrl=https%253a%252f%252fmcstats.org%252f Metrics] is a service provided by '''Hidendra''' to keep track of plugin statistics. It allows plugin developers to see who uses their plugin the most, and to keep track of certain features. This makes it easier to decide on new features and to see what parts of the plugin really matter to most people. The data is sent anonymously, that is, no server IP/player names/personal information is sent to the database.

You do not want to participate in this as a server? Aw...oh well, you can opt-out on Metrics globally in the metrics configuration file:

<pre>plugins\PluginMetrics\config.yml < change opt-out: to true.</pre>

==Metrics in BKCommonLib==
A Metrics implementation, almost entirely similar as the one provided by mcstats, is included in BKCommonLib. It provides an easy API layer to set up the data you wish to send to the server. Instead of scheduling a task to update it every other time, or having synchronization issues, the Metrics implementation in BKCommonLib works slightly differently.

==Creating Metrics for your plugin==
How to obtain a [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/metrics/Metrics.java Metrics] class instance to use it in your plugin.

===PluginBase===
If you use [[BKCommonLib/PluginBase|PluginBase]] for your plugin, all you have to do is add 'metrics: true' to the plugin.yml of the plugin. After that you can obtain the Metrics instance using the provided '''getMetrics()''' method. Before using it, check that metrics is available (and enabled) using the '''hasMetrics()''' method, otherwise errors will occur.

===Manually===
To manually create a new Metrics instance, use the following code:

<pre>Metrics metrics = Metrics.initialize(this);
if (metrics != null) {
// Add your graphs here
}</pre>
You can also create a new Metrics instance using the provided constructor, and handle the errors yourself. In that case, make sure you also call start() once all graphs are added. The initialize method does that for you.

==Adding graphs==
Graphs in this implementation work slightly different than the ones found elsewhere. In BKCommonLib, Metrics graphs contain an '''onUpdate''' method in which the values can be set. It also does not contain a 'Plotter' class, instead it uses a map of values. it is up to the plugin to fill or update the data in the graph. The '''onUpdate''' method is called on the main thread (synchronized), so it is thread-safe to access Bukkit or plugin resources.

To add a graph, use '''Metrics.addGraph'''.

==Changing plotter values in graphs==
A plotter value is basically a single value for part of a graph displayed on [https://mcstats.org mcstats.org]. For example, if you have a Commands graph, you can add plotter values for all commands the plugin provides, mapped to the amount of times it was performed.

Plotter values have to be numeric (int, double, float, etc.), non-numeric text is not possible simply because it can't be displayed in a graph.

There are several methods to change 'plotter' values:
* '''clearPlotters''' - removes all set plotters
* '''togglePlotter''' - Adds a plotter with value '1' if enabled, or removes the plotter if disabled
* '''addPlotter''' - Adds a plotter mapping the value to a key

Example graph implementation (found in enable() of a PluginBase):
<pre>// Total server memory
getMetrics().addGraph(new Graph("Total server memory") {
@Override
public void onUpdate(Plugin plugin) {
clearPlotters();
// Get server total memory in MB (>> 20 = / (1024 * 1024))
final long mem = Runtime.getRuntime().totalMemory() >> 20;
final String key;
if (mem <= 512) {
key = "0-512 MB";
} else if (mem <= 1024) {
key = "512-1024 MB";
} else if (mem <= 2048) {
key = "1024-2048 MB";
} else if (mem <= 4096) {
key = "2048-4096 MB";
} else if (mem <= 8192) {
key = "4096-8192 MB";
} else if (mem <= 16384) {
key = "8-16 GB";
} else {
key = "16+ GB";
}
togglePlotter(key, true);
}
});</pre>
This produces a graph as follows (pie chart): Total server memory - Pie chart

==Default graph implementations==
BKCommonLib also includes some 'common' Graph implementations. These are:
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/metrics/MyDependingPluginsGraph.java MyDependingPluginsGraph] - shows the plugins depending on your plugin
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/metrics/SoftDependenciesGraph.java SoftDependenciesGraph] - shows the plugins enabled that your plugin has a soft dependency on

Important notes
* '''onUpdate''' is not called if the server opted out, also if the server opted out after your metrics instance was started.
* '''getMetrics()''' throws an exception if no metrics is available - use '''hasMetrics()''' before using it
* To use metrics in '''PluginBase''', add the '''metrics: true''' to the plugin.yml. By default metrics is disabled.
* Only use numeric plotter values

MyWorlds/Permissions

2025-10-12T09:47:21Z

RyanDo:

Below the permission nodes of MyWorlds. Works best with Luckperms as it better handles .* permissions natively.

== Command permissions ==
The following permissions are used with the respectable Commands:

{| class="wikitable"
|-
! Command !! Permission Node !! Header text
|-
| /world create || myworlds.world.create || OP
|-
| /world load || myworlds.world.load || OP
|-
| /world unload || myworlds.world.unload || OP
|-
| /world list || myworlds.world.list || OP
|-
| /world info || myworlds.world.info || OP
|-
| /world portals || myworlds.world.portals || OP
|-
| /world listgenerators || myworlds.world.listgenerators || OP
|-
| /world setdefaultportal || myworlds.world.setportal || OP
|-
| /world spawn || myworlds.world.spawn || OP
|-
| /world evacuate || myworlds.world.evacuate || OP
|-
| /world repair || myworlds.world.repair || OP
|-
| /world save|| myworlds.world.save || OP
|-
| /world saving || myworlds.world.setsaving || OP
|-
| /world delete || myworlds.world.delete || NO
|-
| /world copy || myworlds.world.copy || NO
|-
| /world difficulty || myworlds.world.difficulty || OP
|-
| /world togglepvp || myworlds.world.togglepvp || OP
|-
| /world op || myworlds.world.op || OP
|-
| /world deop || myworlds.world.deop || OP
|-
| /world togglespawnloaded || myworlds.world.togglespawnloaded || OP
|-
| /world allowspawn || myworlds.world.allowspawn || OP
|-
| /world denyspawn || myworlds.world.denyspawn || OP
|-
| /world weather || myworlds.world.weather || OP
|-
| /world time || myworlds.world.time || OP
|-
| /world gamemode || myworlds.world.gamemode || OP
|-
| /world setspawn || myworlds.world.setspawn || OP
|-
| /world config || myworlds.world.config|| OP
|-
| /tpp|| myworlds.tpp || OP
|}
== Chat permissions ==
The following permissions set with what world(s) a player can chat when being on certain or any world. Chat permissions need to be enabled in the Configuration first.

{| class="wikitable"
|-
! Situation !! Permission
|-
| The player can chat with world2 from world1 || myworlds.world.chat.world1.world2
|-
| The player can chat with every world from world1 || myworlds.world.chat.world1.*
|-
| The player can chat with world2 from every world || myworlds.world.chat.*.world2
|-
| The player can chat globally from every world with every world (default OP) || myworlds.world.chat.*.*
|-
| The player can chat in every world, but not to other worlds (default true)|| myworlds.world.chat.*
|-
| The player can chat in world1 (also needed to chat with other worlds from world1) || myworlds.world.chat.world1
|}

'''Important:''' For all other permissions it is needed to have the permissions to use chat in a certain world:

<code>myworlds.world.chat.world1.world2</code>

He needs permission to use the chat in world1 too, so he also needs one or both of these two:

<code>myworlds.world.chat.world1
myworlds.world.chat.*</code>

==General permissions==
{| class="wikitable"
|-
! Type !! Permission node !! Extra information !! Default
|-
| Sets if the player can enter a world || myworlds.world.enter.[name]] || [name] is the world name || NO*
|-
| Sets if the player can enter any world || myworlds.world.enter.* || || OP*
|-
| Sets if the player can enter a portal || myworlds.portal.enter.[name]] || [name] is the portal name || NO*
|-
| Sets if the player can enter any portal || myworlds.portal.enter.* || || OP*
|-
| Sets if the player can teleport to a world || myworlds.world.teleport.[name]] || [name] is the world name || NO*
|-
| Sets if the player can teleport to any world || myworlds.world.teleport.* || || OP*
|-
| Sets if the player can teleport to a portal || myworlds.portal.teleport.[name]] || [name] is the portal name || NO*
|-
| Sets if the player can teleport to any portal || myworlds.portal.teleport.* || || OP*
|-
| Sets if the player can create portals || myworlds.portal.create || || OP
|-
| Sets if the player can replace portals || myworlds.portal.override || || OP*
|-
| Sets if the player can use (enter) portals || myworlds.portal.use || || YES
|-
| Sets if the player can build on a world || myworlds.world.build.[name]] || [name] is the world name || NO*
|-
| Sets if the player can build on any world || myworlds.world.build.* || || OP*
|-
| Sets if the player can use blocks on a world || myworlds.world.use.[name] || [name] is the world name || NO*
|-
| Sets if the player can use blocks on any world || myworlds.world.use.* || || OP*
|-
| Sets if the player is ignored during game mode changes || myworlds.world.ignoregamemode || || FALSE
|-
| Sets if the player is ignored during per-world inventory changes || myworlds.world.keepinventory || || OP
|-
| Sets whether the player can generate nether portals when taking a linked nether portal || myworlds.world.linknether || || TRUE
|}
''* = Needs to be enabled in the main [[MyWorlds/Configuration|Configuration]]''

* Portal enter permissions are for when a player enters the physical portal. The portal name (second line on the sign) is used, '''not''' the destination name (third line).
* Portal enter permissions are not used when teleporting using chat commands, you need to use the teleport permissions then
* World enter permissions are active when entering portals, and when teleporting to portals and worlds using chat command
* Portal and world teleport permissions are only used when teleporting using chat commands, they are not active when walking into a physical portal
A player can teleport to another portal by entering a portal when these two conditions are met:

* Portal enter permissions are disabled, the player has 'enter any portal' permission or the player has the specific permission for the portal he entered
* World enter permissions are disabled, the player has 'enter any world' permission or the player has the specific permission for the world he is about to enter
A player can teleport to another world using chat commands when these three conditions are met:

* The player has access over the 'teleport to portal' or 'world spawn' commands
* World enter permissions are disabled, the player has 'enter any world' permission or the player has the specific permission for the world he is about to teleport to
* World teleport permissions are disabled, the player has 'teleport to any world' permission or the player has the specific permission to teleport to the world

BKCommonLib/Task

2025-10-12T09:47:06Z

RyanDo:

==Introduction==
The Task class is a wrapper class for starting Bukkit scheduler tasks (synchronized only). They can be used to execute a task with a certain tick delay, or with a certain tick interval. They can easily be started and stopped.

==Usage==
Tasks are abstract implementations - you need to make a new Class that extends the Task class and implement the run() method. In there you can execute your logic. In almost all cases, you will want to do something like this:

<pre>Task myTask = new Task(MyPlugin.plugin) {
@Override
public void run() {
Bukkit.broadcastMessage("Test after 10 ticks!");
}
}.start(10);</pre>
As you can see, all start() and stop() methods return the 'this' Task instance, allowing calls to be chained and the Task to be stored in a single line. In case of a task in your own plugin, this is a general way of doing it:

<pre>public class MyPlugin extends JavaPlugin {
private Task myTask;

@Override
public void onEnable() {
myTask = new Task(this) {
@Override
public void run() {
Bukkit.broadcastMessage("This message is displayed about every second");
}
}.start(20, 20);
}

@Override
public void onDisable() {
Task.stop(myTask);
myTask = null;
}
}</pre>
It is possible to use myTask.stop() instead, but in the event that myTask is not initialized (and is null) Task.stop is more secure, as it includes a null check. Who knows, perhaps there was an error while enabling or for some other reason your task ended up nulled sooner.

==Start types==
You can start in multiple ways:

* Task.start() - runs the task a single time at the end of the current tick
* Task.start(10) - runs the task a single time in 10 ticks
* Task.start(10, 20) - runs the task every 20 ticks, with a delay of 10 ticks before starting to repeat
==Next-tick tasks==
Since you have to start these tasks so often, there is an alternative to using the Task class for executing next-tick tasks: CommonUtil.nextTick. It allows you to schedule a Runnable to execute at the end of the current tick, similar to how Task.start() works. Example:

<pre>CommonUtil.nextTick(new Runnable() {
@Override
public void run() {
Bukkit.broadcastMessage("Next tick message!");
}
});</pre>
You do not have to pass in a Plugin instance, and it is also impossible to cancel the task once scheduled. When BKCommonLib disables all remaining tasks are discarded - only use this to schedule tasks while the server is enabling or running, not when disabling.

==Tips for passing in parameters==
It is possible that you want to use data obtained in an event or function to pass into the scheduled task - so how to easily use it? Making your own Task wrapper class with all these variables stored is possible, but also very inefficient. Java has a nice trick for that: final variables:

<pre>@EventHandler
public void onPlayerJoin(PlayerJoinEvent event) {
final Player player = event.getPlayer();
new Task(plugin) {
@Override
public void run() {
player.sendMessage("Welcome to our server!");
}
}.start(40);
}</pre>
Be very careful with this, as it IS prone to memory leaks. As a rule of thumb, don't use final variables to pass them into repeating tasks, as these variables then never get garbage collected. Even better would be to use primitive types only - a player name instead of a Player.

BKCommonLib/Localization

2025-10-12T09:46:54Z

RyanDo:

==Introduction==
BKCommonLib will create a Localization.yml file in the plugin's folder if the plugin contains localized keys or commands. Commands are automatically read from plugin.yml file in the plugin itself, which allows users to externally modify the usages and descriptions of commands without opening up the plugin in an archive extracting program.

== The keys==
Localization keys have to be lower-cased, otherwise they are not detected and probably overwritten as well. This is important later on, if you want to make argument-specific nodes. They have to be lower-case too.

==Colors==
The § 'text formatting code' can be used to add colors and other formatting styles to the messages. See this page for more information about the characters to put after this sign.

==Arguments==
Some localization nodes allow arguments from the plugin to be passed into the message. These arguments are surrounded by percentage signs. %0% is the first argument, %1% is the second argument, and so on. This identifier does not have to be in the message, you can leave it out.

==Argument specific nodes==
It is possible to use completely different messages for different arguments from the plugin. For example, there is the player.enter node that looks like this:

<pre>someplugin:
player:
enter: §ePlayer %0% joined the server! Say hello!</pre>

You can give a special welcome message to the player called player1:

<pre>someplugin:
player:
enter:
default: §ePlayer %0% joined the server! Say hello!
player1: §eThe magnificent player1 joined the server, bow before his might!</pre>

This applies to all nodes that have an input argument. It is possible to extend this logic for two arguments as well, for example:

<pre>someplugin:
use:
default: You used a %0% against a %1%!
sword:
default: You used a powerful sword against a %1%</pre>
block: You used a sword against a block, it's not very effective!
Note how the second argument is still %1%. The argument key stays the same for sub-argument nodes. This is to prevent confusion when copy-pasting the same message and allow small modifications. Otherwise you would have to change all %0% arguments to the argument name, which can be tiresome.

==Example in MyWorlds==
You can set an enter message for worlds. This example has a special enter message for world1 and Lowgrass:

<pre>world:
enter:
default: §aYou teleported to world '%0%'!
world1: §aYou teleported to world 1, have a nice stay!
lowgrass: §aYou teleported to the nicely built Lowgrass, have fun there!</pre>
As can be seen, the node is a lowercase lowgrass and not Lowgrass. As stated in the beginning, localization keys have to be lower case.

==Internals==
You can skip this part if you are not programming using the library. BKCommonLib features built-in Localization reading for plugins extending the PluginBase in BKCommonLib. It automatically manages localization nodes reading and writing from/to the Localization.yml file in the plugin's folder.

This localization system automatically reads all command descriptions and usages found in the plugin.yml of your plugin and makes them configurable in the Localization.yml file. Alternatively, the plugin can add more nodes using the loadLocale(path, value) method. This method will check the localization file for the node, and if it doesn't exist, it adds the default value specified to it. This should be done in the localization() method, which is fired right before enabling the plugin.

MyWorlds/Localization

2025-10-12T09:46:40Z

RyanDo:

==Introduction==
BKCommonLib will create a Localization.yml file in the plugin's folder if the plugin contains localized keys or commands. Commands are automatically read from plugin.yml file in the plugin itself, which allows users to externally modify the usages and descriptions of commands without opening up the plugin in an archive extracting program.

==The keys==
Localization keys have to be lower-cased, otherwise they are not detected and probably overwritten as well. This is important later on, if you want to make argument-specific nodes. They have to be lower-case too.

==Colors==
The § 'text formatting code' can be used to add colors and other formatting styles to the messages. See this page for more information about the characters to put after this sign.

==Arguments==
Some localization nodes allow arguments from the plugin to be passed into the message. These arguments are surrounded by percentage signs. %0% is the first argument, %1% is the second argument, and so on. This identifier does not have to be in the message, you can leave it out.

==Argument specific nodes==
It is possible to use completely different messages for different arguments from the plugin. For example, there is the player.enter node that looks like this:

someplugin:
player:
enter: §ePlayer %0% joined the server! Say hello!
You can give a special welcome message to the player called player1:

someplugin:
player:
enter:
default: §ePlayer %0% joined the server! Say hello!
player1: §eThe magnificent player1 joined the server, bow before his might!
This applies to all nodes that have an input argument. It is possible to extend this logic for two arguments as well, for example:

someplugin:
use:
default: You used a %0% against a %1%!
sword:
default: You used a powerful sword against a %1%
block: You used a sword against a block, it's not very effective!
Note how the second argument is still %1%. The argument key stays the same for sub-argument nodes. This is to prevent confusion when copy-pasting the same message and allow small modifications. Otherwise you would have to change all %0% arguments to the argument name, which can be tiresome.

==Example in MyWorlds==
You can set an enter message for worlds. This example has a special enter message for world1 and Lowgrass:

world:
enter:
default: §aYou teleported to world '%0%'!
world1: §aYou teleported to world 1, have a nice stay!
lowgrass: §aYou teleported to the nicely built Lowgrass, have fun there!
As can be seen, the node is a lowercase lowgrass and not Lowgrass. As stated in the beginning, localization keys have to be lower case.

==Internals==
You can skip this part if you are not programming using the library. BKCommonLib features built-in Localization reading for plugins extending the PluginBase in BKCommonLib. It automatically manages localization nodes reading and writing from/to the Localization.yml file in the plugin's folder.

This localization system automatically reads all command descriptions and usages found in the plugin.yml of your plugin and makes them configurable in the Localization.yml file. Alternatively, the plugin can add more nodes using the loadLocale(path, value) method. This method will check the localization file for the node, and if it doesn't exist, it adds the default value specified to it. This should be done in the localization() method, which is fired right before enabling the plugin.

BKCommonLib/General

2025-10-12T09:46:06Z

RyanDo:

==Introduction==
There are various utilities that have nothing to do with Bukkit or Minecraft alone. These are utilities working with mathematics, logic, strings and blockfaces. There are a lot of utilities, and listing them all here is going to result in too much information. Instead the basic features covered are listed so you know where to find them.

==Math==
[https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/MathUtil.java MathUtil] contains various common operations involving math:

* length, lengthSquared, distance, distanceSquared, normalize - both 2D and 3D vector length operations
* wrapAngle, getAngleDifference, toChunk, Long<>2Int, fixNaN, clamp, lerp, atan2 - for simplistic number calculations
* getLookAtYaw/Pitch, getDirection, isHeadingTo, move, rotate - for rotation-based vector calculations and checks
==BlockFace==
[https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/FaceUtil.java FaceUtil] contains various common operations involving the conversion from and to BlockFaces:

* Conversion between yaw and BlockFace
* Conversion between vector directions and BlockFace
* Conversion between 'notch' (0-7) and BlockFace
* Several BlockFace constants for easier logic
==Logic==
[https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/LogicUtil.java LogicUtil] contains methods to work with general logic such as checking for null and returning something else, logic involving collections and more:

* Conversion between primitive and boxed class types
* Checking whether an Object is null or empty
* Checking whether an index is in bounds of an array or list
* Dynamically creating arrays and getting array elements
* Checking to see if a given value is present in a primitive type array
==String==
[https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/StringUtil.java StringUtil] contains methods to format Strings, get the first index of text in a String and other String-related operations:

* Get the width of text in Minecraft font (might become deprecated)
* Get the first index of multiple pieces of text
* Get the text before or after a piece of text
* Obtain a String filled with certain text appended N times
* Trimming the end or start of text from whitespaces
* Combining multiple pieces of text together with a delimiter, or using , and and
* Converting "-surrounded parts into a single element (for command argument conversion)
* Get the amount of successive times a given character is present in a text
* Chat style conversion methods
* Replacing text, or all text
==Parsing==
[https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/ParseUtil.java ParseUtil] takes care of number, boolean and enum parsing. Note that the Conversion system already includes redirects to this class:

* Parsing booleans, checking whether a piece of text can be interpreted as a boolean
* Parsing numbers, checking whether a piece of text can be interpreted as a number
* Parsing enumerations from text, generic
* Parsing materials, by checking for an ID or the material name
==Time==
[https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/TimeUtil.java TimeUtil] is used to convert between time and text, by interpreting words such as 'day' and 'night' and turning it into Minecraft time. Although it has something to do with Minecraft, it is still basic logic. Methods:

* get Minecraft time from text
* get name in text format from Minecraft time
* getting the current time in a certain date format

BKCommonLib/Conversion

2025-10-12T09:45:52Z

RyanDo:

==Introduction==
BKCommonLib features a broad and versatile data type conversion system to convert (or cast, in some cases) one data type to another. For example, conversion between:

* numeric values (byte, short, int, long, float, double)
* String (or String producing object) data and numeric values
* Collections and arrays (list, set, map, object array, primitive array (int[]))
* Wrappers and their handles (CommonTag, Entity, World, Chunk, DataWatcher, etc.)
* Enumerations and Strings (Material, GameMode, PermissionDefault, etc.)
* Properties (item container and item, difficulty and difficulty ID, etc.)
* Custom (plugins can register their own)
Whenever you set something in a generic way, or try to obtain one in a generic way, the Conversion service takes care of it. It is used in most of the data storage classes BKCommonLib provides, including configuration and NBT API. The conversion service adds functionality where serialization and de-serialization of data fails.

==Converter==
The [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/conversion/Converter.java Converter] takes care of the conversion from an unknown Object to a certain output type. It also provides several helper methods to make working with converters easier. These, if not provided in a base class, can be copied over without an issue. The default base class, which provides the basic needs, is called [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/conversion/BasicConverter.java BasicConverter].

Every converter defines several methods:
* '''convert''' (and overloads) converts to the output type of the converter. The convert without default should be final.
* '''getOutputType''' tells the Conversion service what type of Object this converter can produce
* '''isCastingSupported''' tells the Conversion service whether the produced type allows casting (e.g. Entity to Creeper)
* '''isRegisterSupported''' tells the Conversion service whether the converter can be registered at all
Make sure that for converters that produce common types, such as Object and Integer, the isRegisterSupported returns false. Not doing so may result in your (limited) converter replacing other converters that can actually do the job. This mainly applies to conversion from property owner to property. You do not want your 'Item to Item Material' converter to replace the 'Anything to Material' converter.

==Conversion types==
You can access and use default converters in the [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/conversion/type/ConversionTypes.java ConversionTypes] class, or it's extension, the [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/conversion/Conversion.java Conversion] class.

==Converter pair==
A [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/conversion/ConverterPair.java ConverterPair] is a combination of two Converters that can convert from one to the other, and back. The class is self-explanatory. These pairs can be used to provide self-converting collections, accessors and other two-way 'setting and getting' types. All default pairs can be found in the [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/conversion/ConversionPairs.java ConversionPairs] class.

==Translator==
The main use case for Converter Pairs is reflection. To access a field of type 'net.minecraft.server.Entity' without losing type information, you can provide a '''translation'''. For example, the definition of the field 'passenger' in the nms.Entity class:

<pre>public static final TranslatorFieldAccessor<Entity> = entityTemplate.getField("passenger").translate(ConversionPairs.entity);</pre>
Now you can get and set the passenger using Bukkit entities. The TranslatorFieldAccessor allows you to still get and set the base type (nms.Entity), but no type is exposed (it's an Object).

==Converting to a generic type==
To convert a value to a type that is not known at compile time (generics), use the following method:

<pre>Object input = ...;
Class<T> typeToGet = ...;
T default = ...;
T value = Conversion.convert(input, typeToGet, default);</pre>
The default is returned when conversion, for some reason, fails. There are also overloads of this method to return null on failure, or to use the default class type instead of typeToGet.

BKCommonLib/PermissionDefaults

2025-10-12T09:45:41Z

RyanDo:

==Introduction==
All permissions, with a description and a default value, can be found in the PermissionDefaults.yml file. Open it using a text editor and you can view an hierarchical view of all permissions of the plugin. In here you can freely change the default permission value (op/not_op/true/false) for all permissions the plugin uses. A server reload or restart is required for new permission nodes to take effect.

==Variable permissions==
Sometimes so-called 'variable' permission nodes exist. They are, by default, shown with a main name followed up by a * node. These nodes allow additional sub-permissions to be added, or represent a permission for a certain world, player or some other name. An example of a such a permission can be found below:

<pre>myplugin:
use:
'*':
default: op
description: Can use all tools
hammer:
default: true
description: Can use the hammer tool
drill:
default: false
description: Can use the drill tool</pre>
In the above example, OP players can use all tools. This includes the drill! All players can use the hammer, but no one can use the drill. Note that the false default is usually pointless, because not-added variable permissions are false by default anyhow. Generally you would want to add either true or op as default for these sub-permission nodes. (hammer and drill)

==Permission nodes==
The nodes in the file correspond to the permission nodes you can give to players. In the above example, you can use the permission node 'myplugin.use.hammer' to allow a player to use the hammer. If you wish to give someone the use for all tools, you can use 'myplugin.use.*'. Again, the nodes in PermissionDefaults.yml are defaults; you can override them for individual players or groups.

==Permission plugins==
If you wish to use a permission plugin that doesn't use Super Permissions, you can install Vault to redirect the permission handling. BKCommonLib automatically detects when Vault is enabled and will switch to using Vault for permission handling.

MyWorlds/SeperateInventories

2025-10-12T09:45:26Z

RyanDo:

==Configuration==
MyWorlds has an advanced system in place to separate player data on different 'island' groups of worlds. This way you can prevent items going between worlds, while allowing them between linked worlds in survival. Player data is saved inside the world folder, in standard Minecraft NBT format. No special database is used.

To begin using this system, set useWorldInventories to true in plugins/My_Worlds/config.yml.

The moment it is turned on, all worlds will have their own inventory state. This includes the player's items, experience, potion effects, health, hunger. Normally all player data is stored on the main world ('world'). Now this is no longer the case, it means players on other worlds will see their inventory wiped. Their items are still there, but only on the main world.

You'll have to arrange '''inventory migration''' if you have existing players. Make a backup of the main world's playerdata folder. This ensures players don't lose their inventory/experience/etc. due to a missing merged inventory world configuration.

To start, you will probably want to merge the main world/nether/end inventories. Use the following command (replace 'world' with your main world name):
<pre>/world inventory merge world world_nether world_the_end</pre>

===Migration===
MyWorlds loads player data in two stages. First the main world's player data is loaded. If that data points to the player being in another world with a different inventory, then that world's player data is loaded. If players were on a world pre-migration that is now on a separate, split inventory, they will log on and see that their inventory is empty.

To fix that, copy the affected player's player data file to the world they were last on. If you copy all the main world's player data files to the split-off worlds, this will fix it for everyone, but it will also cause all players that weren't on the split-off world to have the same inventory as they have on the main world. Basically, it's complicated, which is why backups are important.

==Commands==

The main command to manage world inventory configuration is the /world inventory command. Syntax is as follows:

<code>/world inventory merge [world1] [world2] [world3]

/world inventory split [world1] [world2] [world3]

/world inventory enable [world]

/world inventory disable [world]</code>

When merging inventories, all their state is shared. The data of this shared state is saved in the first world argument of your merge command, in the example 'world1'. If players have existing data on a particular world you want to keep, make sure to use this world name as a first argument.

When splitting, world name order doesn't matter. Each world you specify is detached from any shared state, and given its own inventory for that world alone. To migrate a world, you can first split it from the original shared world group, then use merge to connect it to the other group.

No player data will ever be lost as a result of splitting/merging. If you accidentally 'lose' people's data by setting the main world for an inventory group, you can either copy the worldname/playerdata folder to the right place, or use the split command for that world to allow players to (temporarily) access their old inventories again.

With enable/disable, inventory saving for that world can be turned off entirely. When players rejoin the world, their inventory will be completely wiped every time.

==Permissions==

There are several permissions which configure inventory behavior:
myworlds.world.inventory - Whether the inventory merge/split/etc. commands can be used
myworlds.world.keepinventory - Makes player exempt from splitting inventories, always keeping the inventory when switching between worlds.

BKCommonLib/Scoreboards

2025-10-12T09:45:12Z

RyanDo:

==ScoreBoards==
Scoreboards are new functions that came with mc 1.5. It allows you to popup a gui in the screen of a player and put custom inferomation inside of it. This already has a very weak api in NMS but we decided to redo it and support global settings as well.
The Scoreboards from BKCommonLib allows you to merge with orther plugins unlike the NMS api.

Here is an example:
<pre>Player player = Bukkit.getOnlinePlayers()[0]; //just get an online player as example
CommonScoreboard board = CommonScoreboard.get(player); //Get the scoreboard form the player
CommonObjective sidebar = board.getObjective(Display.SIDEBAR); //Get the sidebar scoreboard
sidebar.show(); //Shwo the sidebar (use siderbar.hide() to hide)
sidebar.createScore("kills", 17); //Create a new score called 'kills' and make the value 17</pre>
You can also edit the score if the value needs to be changed.
<pre>CommonScore kills = siderbar.getScore("kills");
kills.setValue(18); //Change the value to 18 kills
kills.update(); //Don't forget ot update the score after changing it!</pre>
And if the display name from the sidebar is not the thing you want, you can allways call this:
<pre>sidebar.setDisplayName("PvP Info");</pre>
You can also create Scoreboard teams:
<pre>CommonTeam team = CommonScoreboard.getTeam("example");
if(team == nul) {
team = CommonScoreboard.createTeam("example");
team.setSendToAll(true); //set if team is visible for everyone
team.show(); //Create team
team.setDisplayName("Example"); //Not sure where this is used for
team.setPrefix(ChatColor.RED.toString()); //Prefix (in front of name)
team.setSuffix(" - Example");
}

team.addPlayer(player);</pre>
These are all available displays:

* LIST - Tab list (i think)
* SIDEBAR - Right sidebar of your screen
* BELOWNAME - Below nametags

Showing off a BELOWNAME example:
<pre>Player player = event.getPlayer(); //Player who will see the food from lenis0012
Player lenis0012 = Bukkit.getPlayer("lenis0012"); //Example player to show food from
CommonObjective obj = CommonScoreboard.get(player).getObjective(Display.BELOWNAME);
obj.setDisplayName("Hunger");
obj.show(); //Allways call this
obj.createScore("lenis0012", "lenis0012", (int) lenis0012.getFoodLevel());</pre>

Result of nametag:

lenis0012

20 Hunger

BKCommonLib/IIIT

2025-10-12T09:44:56Z

RyanDo:

==Introduction==
This page covers the item to item, inventory to item, item to inventory and inventory to inventory transfer principles. It covers how item(s) go from one place to another, and the methods available to achieve this. It also covers several other item utilities, new base classes you can use and use cases.

==ItemParser==
An ItemParser is used to define the rules for a transfer operation. It can be created from user input using a certain format, but can also be created in-code. An item parser has the following 'fields':
* '''Has amount''' and '''amount''': the maximum amount of items that is allowed to be transferred, and whether this is used
* '''Has type''' and '''type''': the item type to be transferred, and whether an item type restriction is there
* '''Has data''' and '''data''': the item data to be transferred, and whether an item data restriction is there All these settings will be used when transferring items.

==Parsed format==
There are rules defined to create an item parser from user input, these are:

* The : sign delimits type and data
* The '''x''', '''X''', '''*''', '''<space>''', '''<comma>''' and '''@''' signs are used to delimit data/type and the amount
* Type can be the material ID, or the material name, or part of a material name (it uses ParseUtil.parseMaterial)
* Data can be a value from 0 to 15, or an identifier of data for the type (e.g. wood, stone, etc.)

{| class="wikitable"
|+ '''Examples'''
|-
! Format !! Result
|-
| 5xwood || 5 pieces of wood
|-
| 12@ironore || 12 pieces of iron ore
|-
| 5xwool:red || 5 pieces of red wool
|-
| 6xcoal:1 || 6 pieces of charcoal
|-
| 22xlog:birch || 22 pieces of birch logs
|}

==Transfer and Item Utilities==
All utilities can be found in [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/ItemUtil.java ItemUtil]. All methods called 'transfer' transfer items from one place to another. There are also methods to check whether a full transfer is possible at all, allowing you to check it before having a failing result.

This class also contains several other item-related utilities, such as those to clone items, clone inventory contents, transfer item metadata, constructing an empty item which has a handle, and much more. Whenever you run into something that has to do with items, check whether there is a method in ItemUtil that could make your life easier.

==Inventories==
There are also several base classes you can use. All of them extend CraftInventory (or another type used by the implementation), so it is required to compile against CraftBukkit to get around 'class hierarchy' errors. They pose no real threat in this case. The base classes are:
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/inventory/InventoryBase.java InventoryBase] - a base class that has everything implemented except the getting and setting of items
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/inventory/InventoryBaseImpl.java InventoryBaseImp] - base implementation backed by an array of ItemStack
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/inventory/MergedInventory.java MergedInventory] - an inventory of inventories, merging multiple together as one
If you need a quick and dirty way to implement your own Inventory type, these base classes make this a lot easier. Since the base class extends CraftBukkit's inventory, you are automatically provided with the latest methods Bukkit has to offer.

BKCommonLib/Block

2025-10-12T09:44:44Z

RyanDo:

==Introduction==
BlockUtil contains various handy Block-related utilities. It offers:

* get Block State cast to a certain type (null on failure)
* get Block Data cast to a certain type (null on failure)
* Shortcuts for get/setFacing
* get Block attached face or Block
* Toggling all levers attached to a block
* get all Block States in a cuboid area
See also: MaterialUtil for block type equality checks. It contains various material properties, for example, to check whether a material is a type of rails or sign, or whether a block is a power source. It can save some time implementing your own systems if used right.

==Block State==
Unlike block.getState(), this version won't throw random NPE's when the tile entity is glitched. There is also an overload to cast to a certain type of state, for example, a chest. This can be useful to reduce the amount of code needed to get a chest state. For example:

<pre>Chest chest = BlockUtil.getState(block, Chest.class);
if (chest != null) {
// Work with it
}</pre>

==Block Material Data==
Optimized version of Block.getState().getData() - creates Material Data without first creating a (useless) BlockState instance. It also includes several safety checks to avoid malformed data resulting in unusable MaterialData classes. Glitched signs are fixed right up! Usage is very similar to the getState methods.

==Getting block states in an area==
This optimized method allows obtaining all nearby chests, signs, furnaces and other tile entities that have specific Block States. This way you can heavily optimize your previous for-loop check. Note that this method is not cross-thread safe - only use it on the main thread.

BKCommonLib/ForDevelopers

2025-10-12T09:44:34Z

RyanDo:

{{Update|BKCommonLib|18 November 2020|reason=BKCommonLib is now a Gradle project, not a Maven project.|date=16 February 2023}}
==Introduction==
This is a page where help is given for new and existing developers of BKCommonLib and everything related to it. If something needs to be redone or fixed, you can find information regarding it here.

==BKCommonLib project structure==
BKCommonLib is a maven project - you need to support it to contribute to it. If you are using the Eclipse IDE, you can install [https://projects.eclipse.org/projects/technology.m2e m2eclipse] so you can properly import maven projects. To install this software, go to the marketplace in the Eclipse GUI and install it from there. See also: [https://marketplace.eclipse.org/marketplace-client-intro installation instructions].

Upon first looking over all packages and classes it may seem overwhelming - and it is. BKCommonLib is extremely large, but it has a fixed structure.

* Internal and server packages: try not to touch these, here is where all our CraftBukkit-specific logic resides
* Reflection: here is where we put all fields and methods contained within CraftBukkit so others can access it safely
* Proxies and Bases: here we store all base classes that can be extended or worked with. Includes math utility classes such as vectors
* [[BKCommonLib/Conversion|Conversion]]: here are all convertors meant for converting one datatype to the other
* Collections: here we store all special type of collections, such as those that convert one type to the other dynamically
* [[BKCommonLib/CommonEntity|Entity]] and [[BKCommonLib/Controller|Controller]]: all Entity-related utility classes which add new functionality, of which controllers
* [[BKCommonLib/EventsAndListeners|Events]]: Some events plugins can use, fired by BKCommonLib. See also: internal.
* [[BKCommonLib/Localization|Localization]] and [[BKCommonLib/PermissionDefaults|Permissions]]: speaks for itself, base classes for name given
* [[BKCommonLib/ConfigurationAPI|Config]] and [[BKCommonLib/NBTTagAPI|NBT]]: speaks for itself, helper classes for dealing with configuration/file data storage/NBT tags
* [[BKCommonLib/Scoreboards|Scoreboards]]: the Scoreboards API of BKCommonLib
* [[BKCommonLib/TabView|Tab]]: the Tab API of BKCommonLib
* Wrappers: for working with internal classes through a secure and non-reflection ridden layer
* [[BKCommonLib/General|Utils]]: All classes contain static utility methods that can be used for whatever purpose you seek
If you need to fix a bug or want to have a new feature, your first step is looking at which packages are or could be affected. Please don't make new packages for already covered things, it works confusing. If you plan on moving a class around, be sure to keep a (deprecated) redirecting proxy class behind so depending plugins don't stop working all of a sudden.

==BKCommonLib build process==
When first starting to work with it, you may notice that there are no package versions in the net.minecraft.server and org.bukkit.craftbukkit imports. The resulting build, however, does. How come? Well, to skip the process of manually updating all versions, we do multiple things:

* Use reflection where possible so we don't need these imports
* Use [https://github.com/bergerkiller/Spinot Spinot] instead of CraftBukkit/Spigot to build against
* Use the 'maven-shade-plugin' to turn all imports to the proper versioned imports instead
In addition we have several other dependencies and respective repositories for per-plugin compatibility.

==Jenkins build server and GitHub==
We use GitHub to host our projects and have our own CI build server to build the GitHub projects on. Here is a checklist to see whether the Jenkins build server is ready to go:

* GitHub, Git server, Git client and other Git-related plugins are installed and set active (manage/manage plugins)
* JDK 6u38 and 7 are installed (manage/configure system)
* Git account information including a valid SSH key is set and hooks are set on manual (manage/configure system)
Per job (configuration):

* GitHub project path is set and Sourcecode management is set on 'git' and configured fully
* Repository URL and GitHub project path is the same (<nowiki>http://github.com/etc/etc</nowiki>)
* 'Build when changes are sent' checked, nothing else by default
* JDK 6 or 7 is selected properly for building the project (usually 6)
* Github plugin hook url (<nowiki>http://sitename.something/github-webhook/</nowiki>) is added to service hooks on the GitHub project
* Post-build step 'archive artifacts' is set (output: target/*.jar)
* Multiple branches? Be sure to specify 'origin/master' if needed!
Common errors and issues:

* Dependency issues on the server and not locally: delete the .m2/repository/* contents locally and refresh
* Compilation failure: change between different compiler versions until it works
* This is not what I wanted to build!: make sure it isn't building the wrong branch

MyWorlds/Portals

2025-10-12T09:44:21Z

RyanDo:

[[Image:myworlds_portals_examples.png|thumb|right|Several types of portals on display]]
== Introduction ==
Besides commands, this plugin comes with the simplest cross-world teleportation solution: Actual portals. Walk from world to world simply, by walking into a portal. To make a portal, all you have to do is place a [portal] sign nearby a block structure that looks like a portal.

There are three types of portals to choose from:
* Nether portals
* End portals
* Water portals

== Default Portal Destination ==
MyWorlds Portals are created using signs. If you want player-created nether portals or naturally generated end gateways to send players to a certain destination, configure that using <code>/world endportal</code> and </code>/world netherportal</code>. [[MyWorlds/Commands#Set_default_nether_portal_or_end_portal_behavior|See the commands page for more information.]]

=== Vanilla Defaults ===
Nether portals automatically teleport players from ''worldname'' to ''worldname_nether'' and back. Similarly an end gateway teleportation is automatically set up between ''worldname'' and ''worldname_the_end''. If this is not working, run the following commands while in the world to apply the options to (/tpp worldname). This assumes world names "overworld", "nether_world" and "end_world". Replace these with the names of your worlds.
{| class="wikitable"
! From where !! Command !! Explanation
|-
| overworld || /mw netherportal destination nether_world<br>/mw netherportal mode nether_link<br>/mw endportal destination end_world<br>/mw endportal mode end_platform || When players enter a nether portal in the overworld they should go to /8 coordinates (nether link mode) to the nether world. When they enter an end gateway they should teleport to the end platform in the end world.
|-
| nether_world || /mw netherportal destination overworld<br>/mw netherportal mode nether_link || When players enter a nether portal in the nether, teleport x8 (nether link) to the overworld
|-
| end_world || /mw endportal destination overworld<br>/mw endportal mode respawn || When players enter an end gateway in the end, respawn the player at their bed or world spawn
|}

=== Nether Link Permissions ===
If you have a default portal mode set to '''nether_link''', then it will create a new nether portal on the destination world (at x8 coordinates). For this creation, players require the following permission (default true):
<code>myworlds.world.linknether</code>

== Enable ==
This portal behavior must be enabled in MyWorlds' ''config.yml'' before they can be used. If portal signs aren't working, first check that all relevant portal types are enabled:
<pre># Turns different types of portals on or off
# When the portal is disabled, MyWorlds will not handle the portal's logic
enabledPortals:
# Turns handling of nether portal teleportation on or off
# Vanilla Minecraft will handle nether portals when disabled
netherPortal: true
# Turns handling of end portal teleportation on or off
# Vanilla Minecraft will handle end portals when disabled
endPortal: true
# Enables or disables the water stream portals
waterPortal: true
</pre>

== Usage ==
=== Nether portals and End gateways ===
Standard nether portals and end gateways can also be used as portals. For a custom frame or shape, this command can be used to get a special item to place them down:
{{Command|world giveportal [end/nether]|Gives an item to place end/nether portals|myworlds.world.giveportal}}

=== Water portals ===
To use water as a portal, the water must be surrounded on at least two sides with a solid block and at least one side with open air. This is to prevent random lakes to act as portals. With a hole in the ground you can prevent the water from flooding outwards. Water is counted as a solid block, so they can be infinitely wide.

=== Portal Sign ===
[[Image:myworlds_portal_sign_placement.png|thumb|right|Portal sign is placed below a nether portal, teleporting players inside]]
{{sign|[portal]|name|destination|title}}

For each line:
* on the first line: [portal]
* on the second line the portal name. You can teleport to this portal by this name, for example, with /tpp [name].
* on the third line the portal or world name to teleport to. This is taken when the portal is entered.
* optionally on the fourth line the destination display name (otherwise uses portal/world name on third line). Can be left empty.
<br>
{{sign|[portal]|Portal1|HubWorld|}}

==== Placement ====
Players are teleported to the first open space above the portal sign. You can put the portal sign underground, and the player will be teleported on top of the solid blocks above. It is safe to put the portal sign below the portal itself, cyclical teleports are prevented.

=== Cleaning up portals ===
If you want to remove a portal you lost, you can remove the saved portal data from: ''root\plugins\My Worlds\portals.txt''

=== Teleporting to portals ===
Please see the /world teleport and /tpp commands on the [[MyWorlds/Commands#Teleport_to_portal_or_world_spawn|Commands page]]

=== Use with Traincarts ===
The Traincarts plugin supports this type of sign for creating (cross-world) train teleporters. [[TrainCarts/Signs/Teleporter|See this page for more information]].

== Rejoin Portals ==
Rejoin portals are special portals which mimic the ''/world rejoin'' command. Rejoining means a player is teleported to the last position of the world name put on the sign. You must specify one of the worlds that should be rejoined on the last line.

{{sign|[portal rejoin]|Portal1||world|}}

To make sure rejoining 'world' also rejoins 'world_nether' if the player was last in the nether, see the [[MyWorlds/Commands#Last_Position|lastposition command]] to merge worlds. This way players also rejoin the last world they were on when rejoining one of the merged worlds.

== Additional Options ==
Additional options that don't really fit on the sign can be configured using the <code>/world setportaloption <portal name> <option> <value></code> command. If you want to set per portal whether mobs and items can pass through the portal, rather than relying on the global option in config.yml, this can be set per portal here:

<code>/world setportaloption hub playersonly [no/yes]</code>

BKCommonLib/Controller

2025-10-12T09:43:46Z

RyanDo:

==Introduction==
The EntityController class contains various methods a plugin can override to alter entity behaviour.

==Functionalities==
* Altering, cancelling or completely rewriting entity movement physics
* Handling block collisions, cancelling them
* Handling entity collisions, cancelling them
* Handling onTick to disable or completely alter Entity logic
* Handling damage dealt to the Entity
* Handling entity interaction (by players)
* Altering the name of an Entity
* Handling when an Entity dies

==How to use==
Entity Controllers are used in combination with Common Entities. Assigning one is fairly simple: use setController. There is no need to manually bind the entity to the controller, setController takes care of that for you.

For example, here we assign an onBlockCollision handler for items to create an explosion.

<pre>Item item = ...;
CommonItem entity = CommonEntity.get(item);
entity.setController(new EntityController<CommonItem>() {
@Override
public boolean onBlockCollision(Block block, BlockFace hitFace) {
block.getWorld().createExplosion(block.getLocation(), 5.0f);
return false;
}
});</pre>
What you put in the (overridden) methods is completely up to you. You can (literally) make pigs fly.

==Replacing all entities==
If you wish to replace all entities globally, so set controllers whenever a new Entity is added to the server, you can use the EntityAdd event provided by BKCommonLib:

<pre>@EventHandler(priority = EventPriority.LOWEST)
public void onEntityAdd(EntityAddEvent event) {
if (!(event.getEntity() instanceof Item)) {
return;
}
CommonEntity.get((Item) event.getEntity()).setController(new CustomItemController());
}</pre>

BKCommonLib/Packets

2025-10-12T09:43:36Z

RyanDo:

==Introduction==
To keep keep track of packets being sent between the server and the client, BKCommonLib provides a packet listener to intercept and handle these packets. When [https://www.spigotmc.org/resources/protocollib.1997/ ProtocolLib] is found, this plugin is used to provide the listening, otherwise a hacky workaround is used. We recommend you install ProtocolLib as well for that reason.

==Usage==
How to register a packet listener and how to read and change the packets.

==Registering==
Use the following method to register your [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/protocol/PacketListener.java PacketListener] implementing class:

<pre>PacketUtil.addPacketListener(plugin, myPacketListener, PacketType.OUT_CHAT);</pre>
To create a Packet listener class for your plugin, create a new Class that implements PacketListener, and override the '''onPacketReceive''' and '''onPacketSend''' methods. There are INcoming and OUTgoing Packet Types, they register for the methods respectively.

==Working with packets==
Packets change all the time, so it was not possible to include a wrapper class for each and every packet. To work with packets, BKCommonLib provides you a reflection-based system for accessing fields and constructing new packets, namely [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/protocol/PacketType.java PacketType]:

<pre>@Override
public void onPacketSend(PacketSendEvent event) {
CommonPacket packet = event.getPacket();
if (packet.getType() == PacketType.OUT_CHAT) {
String oldMessage = packet.read(PacketType.OUT_CHAT.message);
if (oldMessage.contains("curse")) {
packet.write(PacketType.OUT_CHAT.message, oldMessage.replace("curse", "curse is awesome"));
}
}
}</pre>
There are also methods to read/write a certain parameter index or by name, but they are generally unsafe. We recommend you use the PacketFields constants for this instead, so your plugin remains compatible when fields change. For example, if the 'message' String field is replaced with a List of Strings, we can still provide you with a (deprecated) message field which sets that other field.

BKCommonLib/FileData

2025-10-12T09:43:26Z

RyanDo:

==Introduction==
To make raw data storage possible without the common try-catch logic blurring your vision, there are data reading and writing classes to help you. IO exceptions, missing files or access errors are automatically dealt with.

==Usage==
To use it, create a new instance of the class (nested class), implement the read/write methods and call read() or write() at the end. Examples:

<pre>DataReader
new DataReader(filename) {
public void read(DataInputStream stream) throws IOException {
final int count = stream.readInt();
for (int i = 0; i < count; i++) {
data.add(stream.readInt());
}
}
}.read();
DataWriter
new DataWriter(filename) {
public void write(DataOutputStream stream) throws IOException {
int count = stream.writeInt(data.size());
for (Integer val : data) {
data.writeInt(val.intValue());
}
}
}.write();</pre>

==Compressed DataReader/DataWriter==
The exact same code, only use the respective classes instead. The data is compressed using a DeflaterOutputStream and decompressed using a InflaterInputStream

==Notes==
You are using nested classes here, which means that it is not possible to access all variables 'just like that'. To access a variable from within read or write, you have several options:

Declare them statically or provide a way to access them statically (getInstance())
Declare the variables final
Example of final variables being used this way:

<pre>public void writeMyValue(String filename) {
final int value = this.getSpecialValue(); // Variable is final, therefore we can access it
new DataWriter(filename) {
public void write(DataOutputStream stream) throws IOException {
stream.writeInt(value);
}
}.write();
}</pre>

BKCommonLib/Recipes

2025-10-12T09:43:13Z

RyanDo:

==Introduction==
[https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/RecipeUtil.java RecipeUtil] provides various utility methods to work with item crafting and furnace recipes. It allows you to obtain the information required to do various recipe-related operations.

==Craft Recipes==
To perform crafting operations, BKCommonLib has it's own implementation, or wrapper class, to store and use a crafting (table) recipe: [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/inventory/CraftRecipe.java CraftRecipe]. In this class, all required input items and resulting output item(s) are stored. You can then, by calling just one method, perform the crafting in an inventory, with an optional maximum amount of times.

==Obtaining a Craft Recipe==
There are methods in [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/RecipeUtil.java RecipeUtil] to obtain the Craft Recipes that are able to produce a given item, this method is called '''getCraftingRequirements'''. As a plugin, you can then go through all recipes and try to craft something, or design your own filter to get the desired results.

==Example of Craft Recipes being used==
The following example will try to craft 64 wood 'pieces' (one item with amount 64) using the items from a player inventory. Note that '''craft''' does not take in account how many items you get per crafting operation, therefore '''craftItems''' was added that takes care of that. It only uses the first recipe that can be found in this example, so other ways to craft wood are ignored.

<pre>Inventory inventory = player.getInventory();
CraftRecipe[] recipes = RecipeUtil.getCraftingRequirements(Material.WOOD, null);
if (recipes.length > 0) {
recipes[0].craftItems(inventory, 64);
}</pre>
If you want to be certain that crafting is possible, make a copy of the inventory (e.g. InventoryBaseImpl) and pass that into the crafting method first.

==Furnace 'recipes'==
The furnace does not really maintain a list of recipes, instead it more or less assigns a property to certain items that make them 'furnace craftable'. For that reason, and because the output amount is always 1, no special FurnaceCraftRecipe is added. Instead, you can obtain the furnace results, check the fuel time of items, check whether an item is fuel and whether an item can be heated, and so on. All of these methods can be found in [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/utils/RecipeUtil.java RecipeUtil].

MyWorlds/Configuration

2025-10-12T09:42:59Z

RyanDo:

==Configuration==
Below the general configuration nodes found in:

root\plugins\My Worlds\config.yml

For world-specific settings, see [[MyWorlds/WorldConfiguration|World Configuration]]

==Configuration==
Below the configuration nodes with matching descriptions are given:

{| class="wikitable"
|-
! Node !! Default !! Description !! Value type
|-
| usePermissions || false || Sets if the Permission 3.* plugin is used || Boolean
|-
| useWaterTeleport || true || Sets if water Portals are used || Boolean
|-
| allowPortalNameOverride || false || Sets if portals can be replaced || Boolean
|-
| teleportInterval || 2000 || The minimum delay between portal teleportations in miliseconds || Number
|-
| timeLockInterval || 20 || Sets the interval, in ticks, to re-set the time when locked || Number
|-
| useWorldOperators || false || Sets if the world-specific OP lists are used || Boolean
|-
| locale || default || Sets the localization file to use|| Text
|-
| useWorldEnterPermissions || false || Sets if world enter permission nodes are used || Boolean
|-
| usePortalEnterPermissions || false || Sets if portal enter permission nodes are used || Boolean
|-
| useWorldTeleportPermissions || false || Sets if world teleport permission nodes are used || Boolean
|-
| usePortalTeleportPermissions|| false || Sets if portal teleport permission nodes are used || Boolean
|-
| useWorldBuildPermissions || false || Sets if world build permission nodes are used || Boolean
|-
| useWorldUsePermissions || false || Sets if world use permission nodes are use || Boolean
|-
| useWorldChatPermissions || false || Sets if world chat permission nodes are used || Boolean
|-
| useWorldInventories || true || Sets if world inventories are separated using the settings || Boolean
|-
| onlyObsidianPortals || false || Sets if portals have to be surrounded by obsidian blocks to function || Boolean
|}

BKCommonLib/NetworkController

2025-10-12T09:42:48Z

RyanDo:

==Introduction==
The EntityNetworkController class provides ways of altering how clients (players) observe an Entity. For example, you can use it to make cows look like pigs to all players, or some other nifty trick. The default implementation of the EntityNetworkController also contains various bugfixes and code optimizations to make your live easier.

==Functionalities==
* Alter the spawn packets
* Alter packets sent to update entity position
* Keep track of what players can 'see' an Entity
* Handle player viewers being added or removed

==How to use==
Just like Entity Controllers, you can assign it to Common Entities. They can only be assigned to entities that have been spawned on a world, mind you. If you want to spawn an Entity with a network controller, use the spawn(location, networkController) method instead. Example code to change the spawn packet:

<pre>Entity bukkitEntity = ...;
CommonEntity<?> entity = CommonEntity.get(bukkitEntity);
entity.setNetworkController(new EntityNetworkController<CommonEntity<?>>() {
@Override
public CommonPacket getSpawnPacket() {
return PacketFields.VEHICLE_SPAWN.newInstance(entity.getEntity(), 13);
}
});</pre>
In general, you probably won't be using network controllers. If you do, and wish to alter live entities, you may have to respawn the entity after attaching the network controller for new spawn messages to have effect.

MyWorlds/WorldConfiguration

2025-10-12T09:42:37Z

RyanDo:

==World Configuration==
Below the world configuration nodes of MyWorlds found in:

root\plugins\My Worlds\worlds.yml

For the general configuration, see the [[MyWorlds/Configuration|Configuration]] page

==World configuration==
Every world has their own properties. Below the setting nodes with a description is given:

{| class="wikitable"
|-
! Setting node !! Description !! Value type
|-
| loaded || If the world is loaded (on startup) || Boolean
|-
| keepSpawnLoaded || If the world spawn is kept in memory|| Boolean
|-
| environment || The world environment. (NORMAL/NETHER) || Environment
|-
| chunkGenerator || The name of the chunk generator plugin to use || Plugin name
|-
| gamemode || The game mode applied to the players that join the world || Game mode
|-
| lockedtime || The time the world is locked to. (tick time) || Number
|-
| defaultPortal || The default destination portal for the world || Portal or World name
|-
| operators || The operator player names || Player array
|-
| deniedCreatures || The creatures who are denied to spawn on the world || Creature type array
|-
| holdWeather || If the weather states on this world are locked/frozen || Boolean
|-
| diffuculty || The set difficulty of the world || Difficulty
|-
| spawn || The spawn point of the world || Coordinate (xyz) with degree angles
|-
| world || The spawn point of the world: world name || World name
|}

The above settings can also be altered through [[MyWorlds/Commands|commands]].

BKCommonLib/CommonEntity

2025-10-12T09:42:26Z

RyanDo:

==Introduction==
The CommonEntity class provides additional advanced entity utilities Bukkit does not provide. Most evidently, these are:

Utilities to alter entity position, velocity
Perform cross-world teleportation of all entity types
Added properties (isInWater, isMoving, etc.)
Entity controllers
Entity network controllers
In addition, it contains several 'specialized' CommonEntity extensions. For example, minecarts, players and items have an additional class to handle the entity-specific methods. More CommonEntity extensions are added as the project goes on, but it partially depends on what Bukkit is unable to provide by default.

==Usage==
The basic usage of CommonEntity instances is as follows:

'''Creating a new entity and spawning it afterwards'''
<pre>CommonEntity<?> entity = CommonEntity.create(EntityType.CREEPER);
// Some pre-spawn conditions, and what not
entity.spawn(location);</pre>

'''Obtaining a (new) CommonEntity from an existing Entity'''
<pre>CommonEntity<?> entity = CommonEntity.get(entity);
CommonPlayer player = CommonEntity.get(playerEntity);
CommonItem item = CommonEntity.get(itemEntity);</pre>

==Entity Controllers==
CommonEntity is the hub for Entity Controllers. For more information, see [[BKCommonLib/Controller|this page]].

==Entity Network Controllers==
For spawned CommonEntities, network controllers can be assigned as well. For more information, see [[BKCommonLib/NetworkController|this page]].

BKCommonLib/EventsAndListeners

2025-10-12T09:42:09Z

RyanDo:

==Introduction==
BKCommonLib keeps track of several server events that can not be monitored using Bukkit alone. The following events (and listeners) are available:

==Entities==
The following entity related events are available:

* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/events/EntityAddEvent.java EntityAddEvent] - when an entity is added to the server
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/events/EntityRemoveEvent.java EntityRemoveEvent] - when an entity is removed from a world
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/events/EntityRemoveFromServerEvent.java EntityRemoveFromServerEvent] - when an entity is permanently removed from the server
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/events/EntityMoveEvent.java EntityMoveEvent] - fired every tick to update entity movement. This event is optimized.

==Packets==
The following events are available when registering a [[BKCommonLib/Packets|PacketListener]]:
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/events/PacketReceiveEvent.java PacketReceiveEvent] when a packet is received from the client
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/events/PacketSendEvent.java PacketSendEvent] when a packet is about to be sent to the client

==Internal==
Developers should ignore these events, as they are mainly used to keep track of internal BKCommonLib changes:
* [https://github.com/bergerkiller/BKCommonLib/blob/master/src/main/java/com/bergerkiller/bukkit/common/internal/TimingsListener.java TimingsListener] for keeping track of execution times on the server