Bolt API

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

softdepend:
  - Retention

Getting Started

import xyz.refinedev.practice.api.BoltAPI;

BoltAPI api = BoltAPI.INSTANCE;

Match API

import org.bukkit.entity.Player;
import xyz.refinedev.practice.api.kit.IKit;
import xyz.refinedev.practice.api.match.IMatch;
import xyz.refinedev.practice.api.match.MatchAPI;
import xyz.refinedev.practice.api.match.enums.MatchEndReason;

MatchAPI matchAPI = api.getMatchAPI();

IMatch currentMatch = matchAPI.getMatchByPlayer(player);
IMatch sameMatch = matchAPI.getMatch(player); // alias

matchAPI.end(currentMatch, MatchEndReason.NORMAL);
matchAPI.terminateMatch(currentMatch);

IMatch ranked = matchAPI.createSoloRankedMatch(playerA, playerB, kit);
IMatch unranked = matchAPI.createSoloUnrankedMatch(playerA, playerB, kit);
IMatch directSolo = matchAPI.createSoloMatch(playerA, playerB, kit, false);
IMatch teamMatch = matchAPI.createTeamMatch(teamAPlayers, teamBPlayers, kit, true);
IMatch partyFfa = matchAPI.createPartyFFAMatch(partyPlayers, kit);
IMatch partySplit = matchAPI.createPartySplitMatch(partyPlayers, kit);
IMatch partyVsParty = matchAPI.createPartyVsPartyMatch(partyAPlayers, partyBPlayers, kit, false);

matchAPI.addSpectator(currentMatch, spectator, playerA);
matchAPI.removeSpectator(currentMatch, spectator);
IMatch spectated = matchAPI.getMatchBySpectator(spectator);

matchAPI.handleRespawn(currentMatch, player);
int fighting = matchAPI.getFightingCount();
int botFights = matchAPI.getBotMatchesCount();

List<Player> spectators = match.getSpectatingPlayers();
List<Player> alive = match.getAlivePlayers();
List<? extends IMatchPlayer> players = match.getMatchPlayers();
List<? extends IMatchTeam> teams = match.getMatchTeams();

IMatchPlayer winner = match.getWinningPlayer();
IMatchTeam winningTeam = match.getWinningTeam();

String duration = match.getDuration();
String lasted = match.getLasted();

Party API

import xyz.refinedev.practice.api.party.IParty;
import xyz.refinedev.practice.api.party.IPartySettings;
import xyz.refinedev.practice.api.party.PartyAPI;
import xyz.refinedev.practice.api.match.IMatch;

PartyAPI partyAPI = api.getPartyAPI();

IParty party = 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);

boolean canQueueRanked = partyAPI.canQueue(party, true);

IMatch ffaMatch = partyAPI.startFFA(party, kit);
IMatch splitMatch = partyAPI.startSplit(party, kit);
IMatch partyMatch = partyAPI.startMatch(partyA, partyB, kit, false);
partyAPI.spectatePartyMatch(spectator, party);

IParty currentParty = partyAPI.getParty(player);
IPartySettings settings = currentParty.getSettings();

String name = party.getName();
PartyState state = party.getState();
boolean busy = party.isBusy();

List<UUID> invites = party.getInvites();
boolean invited = party.isInvited(player.getUniqueId());
boolean member = party.isMember(player.getUniqueId());

IQueue queue = party.getQueue();
IMatch partyMatch = party.getMatch();
party.reloadHotbar();
party.reloadNameTag();

Duel API

import xyz.refinedev.practice.api.duel.DuelAPI;
import xyz.refinedev.practice.api.duel.IDuelRequest;
import xyz.refinedev.practice.api.duel.IPartyDuelRequest;
import xyz.refinedev.practice.api.duel.IProfileDuelRequest;

DuelAPI duelAPI = api.getDuelAPI();

IProfileDuelRequest soloRequest = duelAPI.request(playerA, playerB, kit);
IProfileDuelRequest sameSoloRequest = duelAPI.getRequest(playerA, playerB);

IPartyDuelRequest partyRequest = duelAPI.request(partyA, partyB, kit);
IPartyDuelRequest samePartyRequest = duelAPI.getRequest(partyA, partyB);

Collection<IDuelRequest> activeRequests = duelAPI.getActiveRequests();

if (soloRequest != null && soloRequest.isActive()) {
    soloRequest.accept();
}

if (partyRequest != null && partyRequest.isActive()) {
    duelAPI.cancel(partyRequest);
}

Tournament API

import org.bukkit.command.CommandSender;
import xyz.refinedev.practice.api.tournament.ITournament;
import xyz.refinedev.practice.api.tournament.TournamentAPI;
import xyz.refinedev.practice.api.tournament.TournamentEndReason;
import xyz.refinedev.practice.api.tournament.TournamentType;

TournamentAPI tournamentAPI = api.getTournamentAPI();

ITournament soloTournament = tournamentAPI.startTournament(sender, kit, TournamentType.SOLO);
ITournament teamTournament = tournamentAPI.startTournament(sender, kit, TournamentType.TEAM, 2);

tournamentAPI.join(player);
tournamentAPI.leave(player);
tournamentAPI.forceStart();
tournamentAPI.cancelTournament();
tournamentAPI.end(TournamentEndReason.CANCELLED);

List<? extends IMatch> matches = tournament.getMatches();
List<Player> players = tournament.getPlayerParticipants();
List<IParty> parties = tournament.getPartyParticipants();

Player winningPlayer = tournament.getWinningPlayer();
IParty winningParty = tournament.getWinningParty();
Object winningSubject = tournament.getWinningSubject();
boolean fighting = tournament.hasStarted(); // true only while the tournament is actively fighting

Other APIs

ProfileAPI profileAPI = api.getProfileAPI();
QueueAPI queueAPI = api.getQueueAPI();
KitAPI kitAPI = api.getKitAPI();
StatsAPI statsAPI = api.getStatsAPI();
LeaderboardAPI leaderboardAPI = api.getLeaderboardAPI();
IKnockbackHandler knockbackHandler = api.getKnockbackHandler();

Events

@EventHandler
public void onSoloWin(MatchWinEvent event) {
    IMatchPlayer winner = event.getWinner();
}

@EventHandler
public void onTeamWin(MatchTeamWinEvent event) {
    IMatchTeam winningTeam = event.getWinningTeam();
}

@EventHandler
public void onTeamLose(MatchTeamLoseEvent event) {
    IMatchTeam losingTeam = event.getLosingTeam();
}

@EventHandler
public void onTeamPreEnd(MatchTeamPreEndEvent event) {
    if (event.getMatch().isPartyMode()) {
        // Optional cancellation hook
    }
}

@EventHandler
public void onTeamRoundEnd(MatchTeamRoundEndEvent event) {
    int round = event.getRound();
}

@EventHandler
public void onPartyCreate(PartyCreateEvent event) {
    IParty party = event.getParty();
}

@EventHandler
public void onTournamentStart(TournamentStartEvent event) {
    ITournament tournament = event.getTournament();
}