Bolt API

Bolt's public API for profiles, queues, kits, matches, parties, tournaments, duels, stats, leaderboards, and knockback hooks.

Installation

Gradle

repositories {
maven {
name ="refine-public"
url = uri("https://maven.refinedev.org/public-repo/")
}
}
dependencies {
compileOnly("xyz.refinedev.practice:BoltAPI:1.0.6")
}

Maven

<repositories>
<repository>
<id>refine-public</id>
<url>https://maven.refinedev.org/public-repo/</url>
</repository>
</repositories>
<dependencies>
<dependency>
<groupId>xyz.refinedev.practice</groupId>
<artifactId>BoltAPI</artifactId>
<version>1.0.6</version>
<scope>provided</scope>
</dependency>
</dependencies>

plugin.yml

Bolt is loaded through Retention, so your plugin should soft-depend on it.

softdepend:
- Retention

Getting Started

importxyz.refinedev.practice.api.BoltAPI;
BoltAPIapi = BoltAPI.INSTANCE;

Match API

importorg.bukkit.entity.Player;
importxyz.refinedev.practice.api.kit.IKit;
importxyz.refinedev.practice.api.match.IMatch;
importxyz.refinedev.practice.api.match.MatchAPI;
importxyz.refinedev.practice.api.match.enums.MatchEndReason;
MatchAPImatchAPI = api.getMatchAPI();
IMatchcurrentMatch = matchAPI.getMatchByPlayer(player);
IMatchsameMatch = matchAPI.getMatch(player); // aliasmatchAPI.end(currentMatch, MatchEndReason.NORMAL);
matchAPI.terminateMatch(currentMatch);
IMatchranked = matchAPI.createSoloRankedMatch(playerA, playerB, kit);
IMatchunranked = matchAPI.createSoloUnrankedMatch(playerA, playerB, kit);
IMatchdirectSolo = matchAPI.createSoloMatch(playerA, playerB, kit, false);
IMatchteamMatch = matchAPI.createTeamMatch(teamAPlayers, teamBPlayers, kit, true);
IMatchpartyFfa = matchAPI.createPartyFFAMatch(partyPlayers, kit);
IMatchpartySplit = matchAPI.createPartySplitMatch(partyPlayers, kit);
IMatchpartyVsParty = matchAPI.createPartyVsPartyMatch(partyAPlayers, partyBPlayers, kit, false);
matchAPI.addSpectator(currentMatch, spectator, playerA);
matchAPI.removeSpectator(currentMatch, spectator);
IMatchspectated = matchAPI.getMatchBySpectator(spectator);
matchAPI.handleRespawn(currentMatch, player);
intfighting = matchAPI.getFightingCount();
intbotFights = matchAPI.getBotMatchesCount();

Useful IMatch runtime methods:

List<Player> spectators = match.getSpectatingPlayers();
List<Player> alive = match.getAlivePlayers();
List<? extendsIMatchPlayer> players = match.getMatchPlayers();
List<? extendsIMatchTeam> teams = match.getMatchTeams();
IMatchPlayerwinner = match.getWinningPlayer();
IMatchTeamwinningTeam = match.getWinningTeam();
Stringduration = match.getDuration();
Stringlasted = match.getLasted();

Party API

importxyz.refinedev.practice.api.party.IParty;
importxyz.refinedev.practice.api.party.IPartySettings;
importxyz.refinedev.practice.api.party.PartyAPI;
importxyz.refinedev.practice.api.match.IMatch;
PartyAPIpartyAPI = api.getPartyAPI();
IPartyparty = partyAPI.createParty(leader);
partyAPI.invite(leader, invitedPlayer);
partyAPI.join(invitedPlayer, party);
partyAPI.promote(leader, newLeader);
partyAPI.kick(newLeader, kickedMember);
partyAPI.leave(member);
partyAPI.disband(newLeader);
booleancanQueueRanked = partyAPI.canQueue(party, true);
IMatchffaMatch = partyAPI.startFFA(party, kit);
IMatchsplitMatch = partyAPI.startSplit(party, kit);
IMatchpartyMatch = partyAPI.startMatch(partyA, partyB, kit, false);
partyAPI.spectatePartyMatch(spectator, party);
IPartycurrentParty = partyAPI.getParty(player);
IPartySettingssettings = currentParty.getSettings();

Useful IParty runtime methods:

Stringname = party.getName();
PartyStatestate = party.getState();
booleanbusy = party.isBusy();
List<UUID> invites = party.getInvites();
booleaninvited = party.isInvited(player.getUniqueId());
booleanmember = party.isMember(player.getUniqueId());
IQueuequeue = party.getQueue();
IMatchpartyMatch = party.getMatch();
party.reloadHotbar();
party.reloadNameTag();

Duel API

importxyz.refinedev.practice.api.duel.DuelAPI;
importxyz.refinedev.practice.api.duel.IDuelRequest;
importxyz.refinedev.practice.api.duel.IPartyDuelRequest;
importxyz.refinedev.practice.api.duel.IProfileDuelRequest;
DuelAPIduelAPI = api.getDuelAPI();
IProfileDuelRequestsoloRequest = duelAPI.request(playerA, playerB, kit);
IProfileDuelRequestsameSoloRequest = duelAPI.getRequest(playerA, playerB);
IPartyDuelRequestpartyRequest = duelAPI.request(partyA, partyB, kit);
IPartyDuelRequestsamePartyRequest = duelAPI.getRequest(partyA, partyB);
Collection<IDuelRequest> activeRequests = duelAPI.getActiveRequests();
if (soloRequest != null && soloRequest.isActive()) {
soloRequest.accept();
}
if (partyRequest != null && partyRequest.isActive()) {
duelAPI.cancel(partyRequest);
}

Bolt handles arena selection internally for API-created duel requests.

Tournament API

importorg.bukkit.command.CommandSender;
importxyz.refinedev.practice.api.tournament.ITournament;
importxyz.refinedev.practice.api.tournament.TournamentAPI;
importxyz.refinedev.practice.api.tournament.TournamentEndReason;
importxyz.refinedev.practice.api.tournament.TournamentType;
TournamentAPItournamentAPI = api.getTournamentAPI();
ITournamentsoloTournament = tournamentAPI.startTournament(sender, kit, TournamentType.SOLO);
ITournamentteamTournament = tournamentAPI.startTournament(sender, kit, TournamentType.TEAM, 2);
tournamentAPI.join(player);
tournamentAPI.leave(player);
tournamentAPI.forceStart();
tournamentAPI.cancelTournament();
tournamentAPI.end(TournamentEndReason.CANCELLED);

Useful ITournament runtime methods:

List<? extendsIMatch> matches = tournament.getMatches();
List<Player> players = tournament.getPlayerParticipants();
List<IParty> parties = tournament.getPartyParticipants();
PlayerwinningPlayer = tournament.getWinningPlayer();
IPartywinningParty = tournament.getWinningParty();
ObjectwinningSubject = tournament.getWinningSubject();
booleanfighting = tournament.hasStarted(); // true only while the tournament is actively fighting

Other APIs

ProfileAPIprofileAPI = api.getProfileAPI();
QueueAPIqueueAPI = api.getQueueAPI();
KitAPIkitAPI = api.getKitAPI();
StatsAPIstatsAPI = api.getStatsAPI();
LeaderboardAPIleaderboardAPI = api.getLeaderboardAPI();
IKnockbackHandlerknockbackHandler = api.getKnockbackHandler();

Events

Solo-only match events:

@EventHandlerpublicvoidonSoloWin(MatchWinEventevent) {
IMatchPlayerwinner = event.getWinner();
}

Team-safe match events:

@EventHandlerpublicvoidonTeamWin(MatchTeamWinEventevent) {
IMatchTeamwinningTeam = event.getWinningTeam();
}
@EventHandlerpublicvoidonTeamLose(MatchTeamLoseEventevent) {
IMatchTeamlosingTeam = event.getLosingTeam();
}
@EventHandlerpublicvoidonTeamPreEnd(MatchTeamPreEndEventevent) {
if (event.getMatch().isPartyMode()) {
// Optional cancellation hook
}
}
@EventHandlerpublicvoidonTeamRoundEnd(MatchTeamRoundEndEventevent) {
intround = event.getRound();
}

Party and tournament lifecycle events:

@EventHandlerpublicvoidonPartyCreate(PartyCreateEventevent) {
IPartyparty = event.getParty();
}
@EventHandlerpublicvoidonTournamentStart(TournamentStartEventevent) {
ITournamenttournament = event.getTournament();
}