QuickBoardX

Name: QuickBoardX
Availability: InStock
Author: Sueta

1.2.0

A Free Scoreboard Plugin

·Plugin

Description Updates2 Version history2 Addons Discussion Reviews

A fast, free Scoreboard plugin for Spigot and Paper

- Free!
- No Flickering or Artifacts
- Compatible with 1.8.8, 1.12.2, 1.14.4, 1.15.2 and 1.16.1
- Updating Title
- Scrolling Text Elements
- Changeable Text Elements
- Support for Placeholders; Placeholder API and MaximVDW
- Tab Completion for all Commands
- Fully Configurable Scoreboards: Control Visibility by World Names
- Fully Configurable Teams for the Player Tab List, which can change based upon the board displayed
- Scoreboards can be created and configured using Commands
- Multiple Scoreboards for the Same World
- An API for Interacting with Scoreboards and Creating Temporary Scoreboards

All quickboardx commands can be accessed using /quickboardx or either of the aliases: /qbx or /qb
I recommend using LuckPerms to manage your permissions.

Commands

Any command that has a scoreboard for a parameter will require the name of the scoreboard's config file, without the extension.
For example, to set your visible scoreboard to the default scoreboard you would use /qbx set scoreboard.default

All parameters in <brackets> are required

Commands and Permissions

/qbx
description: Shows all commands and summaries for each of them.

/qbx check
permission: quickboardx.check
description: Displays a list of the available Scoreboards, whether you have permission and if you are in one of its enabled worlds

/qbx toggle
aliases: tog
permission: quickboardx.toggle
description: Toggle your scoreboard's visibility

/qbx next
permission: quickboardx.toggle
description: Select the next available scoreboard from the list of accessible boards.

/qbx prev
permission: quickboardx.toggle
description: Select the previous scoreboard from the list of accessible boards.

/qbx on
permission: quickboardx.toggle
description: Enable your scoreboard.

/qbx reload
aliases: rl
permission: quickboardx.reload
description: Reload the configuration files for QuickBoardX.

/qbx set <scoreboard>
aliases: s
permission: quickboardx.set
description: Sets the visible scoreboard for a player, using the board's name (permission).

/qbx select <scoreboard>
aliases: sl
permission: quickboardx.select
description: Switch to the selected scoreboard from the list of accessible boards.

/qbx create <scoreboard>
aliases: c
permission: quickboardx.create
description: Create a scoreboard with the provided name (permission).

/qbx addtitle <scoreboard> <line_number> <text>
aliases: at
permission: quickboardx.edit
description: Add a line to a Scoreboard's Title.

/qbx removetitle <scoreboard> <line_number>
aliases: rt
permission: quickboardx.edit
description: Remove a line from a Scoreboard's Title.

/qbx inserttitle <scoreboard> <line_number> <text>
aliases: it
permission: quickboardx.edit
description: Insert a line into a Scoreboard's Title.

/qbx addline <scoreboard> <line_number> <text>
aliases: al
permission: quickboardx.edit
description: Add a line to a Scoreboard's Text.

/qbx removeline <scoreboard> <line_number>
aliases: rl
permission: quickboardx.edit
description: Remove a line from a Scoreboard's Text.

/qbx insertline <scoreboard> <line_number> <text>
aliases: il
permission: quickboardx.edit
description: Inserts a line into a Scoreboard's Text.

/qbx list
aliases: ls
permission: quickboardx.info
description: View a list of all available scoreboards.

/qbx listworlds
aliases: lsw
permission: quickboardx.info
description: List the Enabled Worlds for a Scoreboard.

/qbx addworld <scoreboard> <world>
aliases: aw
permission: quickboardx.edit
description: Add a world to the enabled worlds for a Scoreboard.

/qbx removeworld <scoreboard> <world>
aliases: rw
permission: quickboardx.edit
description: Remove a world from the enabled worlds for a Scoreboard.

/qbx check_team
aliases: t_check
permission: quickboardx.check
description: Displays your current Player Tab List team based upon your active Scoreboard, and whether the team is applied for that scoreboard

/qbx list_teams
aliases: lst
permission: quickboardx.info
description: View the list of all Player Tab List teams.

/qbx show_team
aliases: t_show
permission: quickboardx.check
description: Shows the configuration for your Player Tab List team.

Scoreboards

QuickBoardX allows for the customization of both the Sidebar Slot and the Player Tab List.
This is accomplished by creating per player Scoreboards which define the contents in the Sidebar and Tab List.
The permission required to see a scoreboard comes from the name of the scoreboard's configuration file.

For example, the default scoreboard configuration file is scoreboard.default.yml, the permission
required to see the default scoreboard is scoreboard.default

Teams

The default Player Tab List team definition is in teams/teams.default.yml. You can add additional
teams to the config.

The properties for each team defined in the config match up with those defined by the Spigot API which
is based upon how they are defined in Vanilla Minecraft.

When defining a color for a team prefix or suffix, you must use a color code, preceded by an &; make sure to include the
reset color code at the end of the prefix (&r), otherwise the color might will be applied to the player's
name.

The color property for a team applies to all player names that have been added to that team.

NOTE: To allow pvp between players on your server, make sure that all tab list teams have allowFriendlyFire: true. If you don't want to define custom tab list teams - all players will be on the default team - make sure to set allowFriendlyFire: true - if you want pvp enabled.

enabledScoreboards The defined teams will only apply to the QuickBoardX Scoreboards in this list.
applyToAllScoreboards All Scoreboards defined by QuickBoardX will use the teams defined in the config.

Team Docs

For further details about Scoreboard Teams in Minecraft and the Spigot API for Scoreboard teams
check out the following links:

Gamepedia Scoreboard Teams
How-to: Create Scoreboard Teams for Dummies
Spigot Javadocs

Want to use placeholders in your scoreboards? Then follow the steps below to get started!

PlaceholderAPI

Placeholder API

1. Download PlaceholderAPI
2. Install in your plugins directory
3. Restart
4. To use the placeholders in the default scoreboard, install the Server and Player extensions.
i. /papi ecloud download Server
ii. /papi ecloud download Player
iii. /papi reload
iv. /qbx reload
5. To learn more about PlaceholderAPI (Papi), visit their Discord!

MaximVdw

1. Install a plugin that uses Maxim Placeholders
2. Download and install [mvdwplaceholderapi][2]
3. Reference one of the placeholders in a Scoreboard's config: [code single]{the_placeholder_name}[/code]

Changeable Text elements can be defined in the config file of your scoreboard. You define a list of strings, and on any lines where you reference the Changeable Text element, the scoreboard will cycle through the list of values that you added for the element. Placeholders can also be included in the lines of Changeable Text elements.

Reference a changeable text element in your scoreboard's config yml file
by using a placeholder starting with CH_ and ending with its name.
For example, if the key for the changeableText element is healthloc, then the placeholder would be {CH_healthloc}

Changeable Example

text:
- '{CH_healthloc}'
changeableText:
  healthloc:
    text:
    - '&aHealth: &c%player_health% &lHP'
    - '&e%player_x% %player_y% %player_z%'
    - '&aJoined &e%player_first_join_date%'

Scrollers are scrolling text elements that can be added to the text lines (body) of your scoreboard by referencing them using a placeholder.
Scroller placeholders use the form SC_ followed by their name.

For example, a scroller named info is referenced with the placeholder {SC_info}.

Scroller Example

text:
- '{SC_info}'
scroller:
  info:
    text: '&7Welcome to the server, &e{PLAYER}! This server is running on &e&lQuickBoardX'
    width: 26
    spaceBetween: 6
    update: 1

The API provides plugin developers with methods for creating scoreboards, both permanent and temporary.
Temporary boards will only be displayed for a short period of time, and using Scrollable or Changeable elements
is not recommended.
Methods are provided for referencing existing scoreboard configuration files. Those methods allow you to reference
the lists of text and titles already defined in that scoreboard's yml file.

API Usage

CloudRepo.io allows open source projects to use their services at no cost.
They provide Public, Private and Proxy Repositories

Maven Artifact

<!-- QuickBoardX -->
<dependency>
    <groupId>net.frostbyte.quickboardx</groupId>
    <artifactId>quickboardx-core</artifactId>
    <version>1.2.0-SNAPSHOT</version>
    <scope>provided</scope>
</dependency>

Repository

<!-- frost-byte snapshots -->
<repository>
    <id>io.cloudrepo.snapshots</id>
    <url>https://frostbyte.mycloudrepo.io/public/repositories/snapshots</url>
</repository>
<!-- frost-byte releases -->
<repository>
    <id>io.cloudrepo</id>
    <url>https://frostbyte.mycloudrepo.io/public/repositories/releases</url>
</repository>

plugin.yml

depend: [QuickBoardX]

Interface

QuickBoardX API

Example Usage

package net.frostbyte.quickboardx.api.example;

import org.bukkit.plugin.java.JavaPlugin;

import net.frostbyte.quickboardx.api.QuickBoardAPI;

public class APIExample extends JavaPlugin implements Listener {
    @Override
    public void onEnable()
    {
        RegisteredServiceProvider<QuickBoardAPI> boardProvider = serviceManager.getRegistration(QuickBoardAPI.class);

        // The QuickBoard API
        QuickBoardAPI boardAPI;

        if (boardProvider != null) {
            boardAPI = boardProvider.getProvider();

            if (boardAPI != null) {
                new BukkitRunnable()
                {
                    @Override
                    public void run()
                    {
                        // Create a Temporary Board for each player online
                        for (Player p : Bukkit.getServer().getOnlinePlayers())
                        {
                            List<String> title = new ArrayList<>();
                            title.add("> Temp Title <");
                            title.add("> Temp Titl <");
                            title.add("> Temp Tit <");
                            title.add("> Temp Ti <");
                            title.add("> Temp T <");
                            title.add("> Temp  <");
                            title.add("> Temp <");
                            List<String> lines = new ArrayList<>();
                            lines.add("line 1");
                            lines.add("");
                            lines.add("%player_name%");
                            lines.add("");
                            lines.add("line 5");
                            lines.add("");

                            boardAPI.createTemporaryBoard(
                                p.getUniqueId(),
                                "scoreboard.temp",
                                title,
                                lines,
                                6,
                                2
                            );
                        }
                    }
                }.runTask(plugin);

                // Register your Plugin as a Listener, so it can respond to the PlayerJoinEvent
                PluginManager pm = getServer().getPluginManager();

                pm.registerEvents(
                    this,
                    this
                );
            }
        }
    }

    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event)
    {
        if (event == null)
            return;

        // Assign the player to a team in the Player List.
        // The team can be based upon a permission, for example, a luckperms group.
        // This also requires you to have the team defined in a team configuration
        // in your QuickBoardX plugin folder (plugins/QuickBoardX/teams/team.default.yml)
        // Assuming that your own method for determining a player's team is called getPlayerTeam...
        String teamName = getPlayerTeam(event.getPlayer());

        // Tell QuickBoardX to update each Online Player's Player List to
        // show the player as a member of the team.
        Bukkit.getPluginManager().callEvent(
            new PlayerTeamUpdateEvent(
                player.getUniqueId(),
                teamName
            )
        );
    }
}

}

PlaceholderAPI
mvdw PlaceholderAPI
LuckPerms
HelpChat Discord (PlaceholderAPI)
Github Repository
tejdik
QuickBoard