├── .github ├── ISSUE_TEMPLATE │ ├── bug-report.yml │ ├── config.yml │ ├── expansion-request.yml │ └── feature-requests.yml ├── PULL_REQUEST_TEMPLATE │ └── default.md ├── dependabot.yml └── funding.yml ├── .gitignore ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.MD ├── Jenkinsfile ├── LICENSE ├── README.MD ├── SECURITY.md ├── api ├── README.MD ├── build.gradle.kts ├── gradle.properties └── src │ └── main │ ├── java │ └── com │ │ └── github │ │ └── sirblobman │ │ └── combatlogx │ │ └── api │ │ ├── ICombatLogX.java │ │ ├── ICombatLogXNeeded.java │ │ ├── command │ │ ├── CombatLogCommand.java │ │ └── CombatLogPlayerCommand.java │ │ ├── configuration │ │ ├── CommandConfiguration.java │ │ ├── MainConfiguration.java │ │ └── PunishConfiguration.java │ │ ├── event │ │ ├── CustomPlayerEvent.java │ │ ├── CustomPlayerEventCancellable.java │ │ ├── NPCDropItemEvent.java │ │ ├── PlayerEnemyRemoveEvent.java │ │ ├── PlayerPreTagEvent.java │ │ ├── PlayerPunishEvent.java │ │ ├── PlayerReTagEvent.java │ │ ├── PlayerTagEvent.java │ │ └── PlayerUntagEvent.java │ │ ├── expansion │ │ ├── Expansion.java │ │ ├── ExpansionClassLoader.java │ │ ├── ExpansionComparator.java │ │ ├── ExpansionDescription.java │ │ ├── ExpansionDescriptionBuilder.java │ │ ├── ExpansionListener.java │ │ ├── ExpansionLogger.java │ │ ├── ExpansionManager.java │ │ ├── ExpansionWithDependencies.java │ │ ├── disguise │ │ │ ├── DisguiseExpansion.java │ │ │ ├── DisguiseExpansionListener.java │ │ │ ├── DisguiseHandler.java │ │ │ └── DisguiseListener.java │ │ ├── region │ │ │ ├── RegionExpansion.java │ │ │ ├── RegionHandler.java │ │ │ ├── configuration │ │ │ │ └── RegionExpansionConfiguration.java │ │ │ ├── listener │ │ │ │ ├── RegionExpansionListener.java │ │ │ │ ├── RegionMoveListener.java │ │ │ │ ├── RegionTeleportListener.java │ │ │ │ └── RegionVulnerableListener.java │ │ │ └── task │ │ │ │ └── KnockbackPlayerTask.java │ │ ├── skyblock │ │ │ ├── IslandWrapper.java │ │ │ ├── SkyBlockExpansion.java │ │ │ ├── SkyBlockExpansionListener.java │ │ │ ├── SkyBlockHandler.java │ │ │ └── SkyBlockListener.java │ │ └── vanish │ │ │ ├── VanishExpansion.java │ │ │ ├── VanishExpansionConfiguration.java │ │ │ ├── VanishExpansionListener.java │ │ │ ├── VanishHandler.java │ │ │ └── VanishListener.java │ │ ├── listener │ │ └── CombatListener.java │ │ ├── manager │ │ ├── ICombatManager.java │ │ ├── ICrystalManager.java │ │ ├── IDeathManager.java │ │ ├── IForgiveManager.java │ │ ├── IPlaceholderManager.java │ │ ├── IPunishManager.java │ │ └── ITimerManager.java │ │ ├── object │ │ ├── CitizensSlotType.java │ │ ├── CombatTag.java │ │ ├── KillTime.java │ │ ├── NoEntryMode.java │ │ ├── SpecialPunishCommand.java │ │ ├── TagInformation.java │ │ ├── TagReason.java │ │ ├── TagType.java │ │ ├── TimerType.java │ │ ├── TimerUpdater.java │ │ └── UntagReason.java │ │ ├── placeholder │ │ ├── IPlaceholderExpansion.java │ │ └── PlaceholderHelper.java │ │ └── utility │ │ ├── CommandHelper.java │ │ └── EntityHelper.java │ └── resources │ └── default-region-expansion-config.yml ├── build.gradle.kts ├── builder ├── build.gradle.kts └── src │ └── main │ └── resources │ └── README.TXT ├── crowdin.yml ├── expansion ├── action-bar │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── action │ │ │ └── bar │ │ │ ├── ActionBarExpansion.java │ │ │ ├── ActionBarUpdater.java │ │ │ └── configuration │ │ │ └── ActionBarConfiguration.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── boss-bar │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── boss │ │ │ └── bar │ │ │ ├── BossBarConfiguration.java │ │ │ ├── BossBarExpansion.java │ │ │ └── BossBarUpdater.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── build.gradle.kts ├── cheat-prevention │ ├── abstract │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── cheat │ │ │ └── prevention │ │ │ ├── ICheatPreventionExpansion.java │ │ │ ├── configuration │ │ │ ├── IBlockConfiguration.java │ │ │ ├── IBucketConfiguration.java │ │ │ ├── IChatConfiguration.java │ │ │ ├── ICommandConfiguration.java │ │ │ ├── IConfiguration.java │ │ │ ├── IEntityConfiguration.java │ │ │ ├── IFlightConfiguration.java │ │ │ ├── IGameModeConfiguration.java │ │ │ ├── IInventoryConfiguration.java │ │ │ ├── IItemConfiguration.java │ │ │ ├── IPotionConfiguration.java │ │ │ └── ITeleportConfiguration.java │ │ │ └── listener │ │ │ └── CheatPreventionListener.java │ ├── build.gradle.kts │ ├── gradle.properties │ ├── legacy │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── cheat │ │ │ └── prevention │ │ │ └── listener │ │ │ └── legacy │ │ │ ├── ListenerChat.java │ │ │ ├── ListenerLegacyItemPickup.java │ │ │ ├── ListenerLegacyPortalCreate.java │ │ │ └── ListenerLegacyPotions.java │ ├── modern │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── cheat │ │ │ └── prevention │ │ │ └── listener │ │ │ └── modern │ │ │ └── ListenerInventoriesModern.java │ ├── paper │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── cheat │ │ │ └── prevention │ │ │ └── listener │ │ │ └── paper │ │ │ ├── ListenerPaperChat.java │ │ │ └── ListenerPaperEntityInsideBlock.java │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── cheat │ │ │ └── prevention │ │ │ ├── CheatPreventionExpansion.java │ │ │ ├── configuration │ │ │ ├── BlockConfiguration.java │ │ │ ├── BucketConfiguration.java │ │ │ ├── ChatConfiguration.java │ │ │ ├── CheatPreventionConfiguration.java │ │ │ ├── CommandConfiguration.java │ │ │ ├── EntityConfiguration.java │ │ │ ├── FlightConfiguration.java │ │ │ ├── GameModeConfiguration.java │ │ │ ├── InventoryConfiguration.java │ │ │ ├── ItemConfiguration.java │ │ │ ├── PotionConfiguration.java │ │ │ └── TeleportConfiguration.java │ │ │ ├── listener │ │ │ ├── ListenerBlocks.java │ │ │ ├── ListenerBuckets.java │ │ │ ├── ListenerCommands.java │ │ │ ├── ListenerDrop.java │ │ │ ├── ListenerElytra.java │ │ │ ├── ListenerEntities.java │ │ │ ├── ListenerFlight.java │ │ │ ├── ListenerGameMode.java │ │ │ ├── ListenerInventories.java │ │ │ ├── ListenerRiptide.java │ │ │ ├── ListenerTeleport.java │ │ │ ├── ListenerTotem.java │ │ │ └── modern │ │ │ │ ├── ListenerModernItemPickup.java │ │ │ │ ├── ListenerModernPortalCreate.java │ │ │ │ └── ListenerModernPotions.java │ │ │ └── task │ │ │ ├── ElytraRetagTask.java │ │ │ └── FlightRetagTask.java │ │ └── resources │ │ ├── blocks.yml │ │ ├── buckets.yml │ │ ├── chat.yml │ │ ├── commands.yml │ │ ├── config.yml │ │ ├── entities.yml │ │ ├── expansion.yml │ │ ├── flight.yml │ │ ├── game-mode.yml │ │ ├── inventories.yml │ │ ├── items.yml │ │ ├── potions.yml │ │ └── teleportation.yml ├── compatibility │ ├── ASkyBlock │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── askyblock │ │ │ │ ├── ASkyBlockExpansion.java │ │ │ │ └── listener │ │ │ │ └── ListenerASkyBlock.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── AngelChest │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── angelchest │ │ │ │ ├── AngelChestConfiguration.java │ │ │ │ ├── AngelChestExpansion.java │ │ │ │ └── ListenerAngelChest.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── BSkyBlock │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── bskyblock │ │ │ │ ├── BSkyBlockExpansion.java │ │ │ │ ├── hook │ │ │ │ └── HookBentoBox.java │ │ │ │ └── listener │ │ │ │ └── ListenerBSkyBlock.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── CMI │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── cmi │ │ │ │ ├── CMIExpansion.java │ │ │ │ └── VanishHandlerCMI.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── Citizens │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── citizens │ │ │ │ ├── CitizensExpansion.java │ │ │ │ ├── configuration │ │ │ │ ├── CitizensConfiguration.java │ │ │ │ ├── Configuration.java │ │ │ │ └── SentinelConfiguration.java │ │ │ │ ├── listener │ │ │ │ ├── CitizensExpansionListener.java │ │ │ │ ├── ListenerCombat.java │ │ │ │ ├── ListenerConvert.java │ │ │ │ ├── ListenerDeath.java │ │ │ │ ├── ListenerJoin.java │ │ │ │ ├── ListenerPunish.java │ │ │ │ ├── ListenerQuit.java │ │ │ │ └── ListenerResurrect.java │ │ │ │ ├── manager │ │ │ │ ├── CombatNpcManager.java │ │ │ │ └── InventoryManager.java │ │ │ │ ├── object │ │ │ │ ├── CombatNPC.java │ │ │ │ └── StoredInventory.java │ │ │ │ └── task │ │ │ │ └── PunishTask.java │ │ │ └── resources │ │ │ ├── citizens.yml │ │ │ ├── config.yml │ │ │ ├── expansion.yml │ │ │ └── sentinel.yml │ ├── CrackShot │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── crackshot │ │ │ │ ├── CrackShotExpansion.java │ │ │ │ └── listener │ │ │ │ └── ListenerCrackShot.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── CrashClaim │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── crash │ │ │ │ └── claim │ │ │ │ ├── CrashClaimExpansion.java │ │ │ │ └── CrashClaimRegionHandler.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── EssentialsX │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── essentials │ │ │ │ ├── EssentialsExpansion.java │ │ │ │ ├── EssentialsExpansionConfiguration.java │ │ │ │ ├── VanishHandlerEssentialsX.java │ │ │ │ └── listener │ │ │ │ └── ListenerEssentials.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── FabledSkyBlock │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── fabled │ │ │ │ └── skyblock │ │ │ │ ├── FabledSkyBlockExpansion.java │ │ │ │ ├── IslandWrapperFabled.java │ │ │ │ └── SkyBlockHandlerFabled.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── Factions │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── factions │ │ │ │ ├── FactionsExpansion.java │ │ │ │ └── RegionHandlerFactions.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── FeatherBoard │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── featherboard │ │ │ │ ├── FeatherBoardConfiguration.java │ │ │ │ ├── FeatherBoardExpansion.java │ │ │ │ └── listener │ │ │ │ └── ListenerFeatherBoard.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── GriefDefender │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── grief │ │ │ │ └── defender │ │ │ │ ├── GriefDefenderExpansion.java │ │ │ │ └── RegionHandlerGriefDefender.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── GriefPrevention │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── grief │ │ │ │ └── prevention │ │ │ │ ├── GriefPreventionExpansion.java │ │ │ │ └── RegionHandlerGriefPrevention.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── HuskHomes │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── huskhomes │ │ │ │ ├── HuskHomesExpansion.java │ │ │ │ └── listener │ │ │ │ └── ListenerHuskHomes.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── HuskSync │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── husksync │ │ │ │ ├── DropItemsTask.java │ │ │ │ ├── HuskSyncExpansion.java │ │ │ │ ├── ListenerHuskSync.java │ │ │ │ └── PlayerData.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── HuskTowns │ │ ├── README.MD │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── husktowns │ │ │ │ ├── HuskTownsExpansion.java │ │ │ │ └── RegionHandlerHuskTowns.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── IridiumSkyblock │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── iridium │ │ │ │ └── skyblock │ │ │ │ ├── IridiumSkyblockExpansion.java │ │ │ │ ├── IslandWrapperIridium.java │ │ │ │ └── SkyBlockHandlerIridium.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── KingdomsX │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── kingdomsx │ │ │ │ ├── ExpansionKingdomsX.java │ │ │ │ └── RegionHandlerKingdomsX.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── Konquest │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── konquest │ │ │ │ ├── KonquestExpansion.java │ │ │ │ └── RegionHandlerKonquest.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── Lands │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── lands │ │ │ │ ├── LandsConfiguration.java │ │ │ │ ├── LandsExpansion.java │ │ │ │ ├── RegionHandlerLands.java │ │ │ │ └── listener │ │ │ │ └── ListenerLands.java │ │ │ └── resources │ │ │ ├── expansion.yml │ │ │ └── lands.yml │ ├── LibsDisguises │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── libsdisguises │ │ │ │ ├── DisguiseHandlerLibsDisguises.java │ │ │ │ └── LibsDisguisesExpansion.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── LuckPerms │ │ ├── README.MD │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── luckperms │ │ │ │ ├── LuckPermsExpansion.java │ │ │ │ ├── context │ │ │ │ ├── AbstractContext.java │ │ │ │ ├── ContextInCombat.java │ │ │ │ ├── ContextNewbieHelperProtected.java │ │ │ │ └── ContextNewbieHelperPvpStatus.java │ │ │ │ └── hook │ │ │ │ └── HookNewbieHelper.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── MCPets │ │ ├── README.md │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── mcpets │ │ │ │ ├── ListenerMcPets.java │ │ │ │ └── McPetsExpansion.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── MarriageMaster │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── marriagemaster │ │ │ │ ├── MarriageMasterExpansion.java │ │ │ │ └── listener │ │ │ │ └── ListenerMarriageMaster.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── MythicMobs │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── mythicmobs │ │ │ │ ├── ListenerMythicMobs.java │ │ │ │ ├── MythicMobsConfiguration.java │ │ │ │ └── MythicMobsExpansion.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── PlaceholderAPI │ │ ├── README.MD │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── placeholderapi │ │ │ │ ├── HookPlaceholderAPI.java │ │ │ │ └── PlaceholderAPIExpansion.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── PlayerParticles │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── player │ │ │ │ └── particles │ │ │ │ ├── ListenerPlayerParticles.java │ │ │ │ ├── PlayerParticlesConfiguration.java │ │ │ │ └── PlayerParticlesExpansion.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── PreciousStones │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── preciousstones │ │ │ │ ├── ListenerPreciousStones.java │ │ │ │ ├── PreciousStonesConfiguration.java │ │ │ │ ├── PreciousStonesExpansion.java │ │ │ │ └── RegionHandlerPreciousStones.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── ProtectionStones │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── protectionstones │ │ │ │ ├── ProtectionStonesConfiguration.java │ │ │ │ ├── ProtectionStonesExpansion.java │ │ │ │ ├── ProtectionStonesListener.java │ │ │ │ └── RegionHandlerProtectionStones.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── README.MD │ ├── RedProtect │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── redprotect │ │ │ │ ├── RedProtectExpansion.java │ │ │ │ └── RegionHandlerRedProtect.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── Residence │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── residence │ │ │ │ ├── RegionHandlerResidence.java │ │ │ │ └── ResidenceExpansion.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── SuperVanish │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── supervanish │ │ │ │ ├── SuperVanishExpansion.java │ │ │ │ └── VanishHandlerSuper.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── SuperiorSkyblock │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── superior │ │ │ │ └── skyblock │ │ │ │ ├── IslandWrapperSuperior.java │ │ │ │ ├── SkyBlockHandlerSuperior.java │ │ │ │ └── SuperiorSkyblockExpansion.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── Towny │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── towny │ │ │ │ ├── RegionHandlerTowny.java │ │ │ │ ├── TownyConfiguration.java │ │ │ │ └── TownyExpansion.java │ │ │ └── resources │ │ │ ├── expansion.yml │ │ │ └── towny.yml │ ├── UltimateClaims │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── ultimateclaims │ │ │ │ ├── RegionHandlerUltimateClaims.java │ │ │ │ └── UltimateClaimsExpansion.java │ │ │ └── resources │ │ │ └── expansion.yml │ ├── VanishNoPacket │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── vnp │ │ │ │ ├── VanishHandlerNoPacket.java │ │ │ │ └── VanishNoPacketExpansion.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ └── expansion.yml │ ├── WorldGuard │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── region │ │ │ │ └── world │ │ │ │ └── guard │ │ │ │ ├── WorldGuardConfiguration.java │ │ │ │ ├── WorldGuardExpansion.java │ │ │ │ ├── handler │ │ │ │ └── WorldGuardRegionHandler.java │ │ │ │ ├── hook │ │ │ │ └── HookWorldGuard.java │ │ │ │ └── listener │ │ │ │ ├── ListenerPreventLeaving.java │ │ │ │ └── ListenerWorldGuard.java │ │ │ └── resources │ │ │ ├── expansion.yml │ │ │ └── worldguard.yml │ ├── ZNPCsPlus │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── znpc │ │ │ │ ├── CombatNpc.java │ │ │ │ ├── CombatNpcManager.java │ │ │ │ ├── ZNPCExpansion.java │ │ │ │ ├── configuration │ │ │ │ ├── Configuration.java │ │ │ │ └── NpcConfiguration.java │ │ │ │ ├── listener │ │ │ │ └── NpcExpansionListener.java │ │ │ │ └── task │ │ │ │ └── NpcRemoveTask.java │ │ │ └── resources │ │ │ ├── config.yml │ │ │ ├── expansion.yml │ │ │ └── npcs.yml │ ├── build.gradle.kts │ ├── iDisguise │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ ├── java │ │ │ └── combatlogx │ │ │ │ └── expansion │ │ │ │ └── compatibility │ │ │ │ └── idisguise │ │ │ │ ├── DisguiseHandler_iDisguise.java │ │ │ │ └── Expansion_iDisguise.java │ │ │ └── resources │ │ │ └── expansion.yml │ └── uSkyBlock │ │ ├── build.gradle.kts │ │ ├── gradle.properties │ │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── compatibility │ │ │ └── uskyblock │ │ │ ├── IslandWrapper_uSkyBlock.java │ │ │ ├── SkyBlockHandler_uSkyBlock.java │ │ │ └── uSkyBlockExpansion.java │ │ └── resources │ │ └── expansion.yml ├── damage-effects │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── damage │ │ │ └── effects │ │ │ ├── DamageEffectsConfiguration.java │ │ │ ├── DamageEffectsExpansion.java │ │ │ ├── ListenerDamageEffects.java │ │ │ └── effect │ │ │ ├── Blood.java │ │ │ ├── DamageEffect.java │ │ │ └── Offset.java │ │ └── resources │ │ ├── effects.yml │ │ └── expansion.yml ├── damage-tagger │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── damage │ │ │ └── tagger │ │ │ ├── DamageTaggerExpansion.java │ │ │ ├── configuration │ │ │ └── DamageTaggerConfiguration.java │ │ │ └── listener │ │ │ └── ListenerDamage.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── death-effects │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── death │ │ │ └── effects │ │ │ ├── DeathEffectsConfiguration.java │ │ │ ├── DeathEffectsExpansion.java │ │ │ ├── ListenerDeathEffects.java │ │ │ └── task │ │ │ └── ItemRemoveTask.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── end-crystal │ ├── build.gradle.kts │ ├── gradle.properties │ ├── legacy │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── endcrystals │ │ │ ├── CheckEndCrystalTask.java │ │ │ └── ListenerCrystals_Legacy.java │ ├── modern │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── endcrystals │ │ │ └── ListenerCrystals_Modern.java │ ├── moderner │ │ ├── gradle.properties │ │ └── src │ │ │ └── main │ │ │ └── java │ │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── endcrystals │ │ │ └── ListenerCrystals_Moderner.java │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── endcrystals │ │ │ └── EndCrystalExpansion.java │ │ └── resources │ │ └── expansion.yml ├── force-field │ ├── README.MD │ ├── build.gradle.kts │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── force │ │ │ └── field │ │ │ ├── ForceFieldExpansion.java │ │ │ ├── configuration │ │ │ └── ForceFieldConfiguration.java │ │ │ └── task │ │ │ ├── ForceFieldAdapter.java │ │ │ └── ForceFieldTask.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── glowing │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── glowing │ │ │ ├── GlowingExpansion.java │ │ │ └── listener │ │ │ └── ListenerGlow.java │ │ └── resources │ │ └── expansion.yml ├── logger │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── logger │ │ │ ├── LoggerExpansion.java │ │ │ ├── configuration │ │ │ ├── LogEntryOptions.java │ │ │ ├── LogFileInfo.java │ │ │ ├── LogOptions.java │ │ │ ├── LogType.java │ │ │ └── LoggerConfiguration.java │ │ │ └── listener │ │ │ └── ListenerLogger.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── loot-protection │ ├── build.gradle.kts │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── loot │ │ │ └── protection │ │ │ ├── LootProtectionExpansion.java │ │ │ ├── configuration │ │ │ └── LootProtectionConfiguration.java │ │ │ ├── event │ │ │ └── QueryPickupEvent.java │ │ │ ├── listener │ │ │ └── ListenerLootProtection.java │ │ │ └── object │ │ │ └── ProtectedItem.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── mob-tagger │ ├── README.MD │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── mob │ │ │ └── tagger │ │ │ ├── MobTaggerExpansion.java │ │ │ ├── configuration │ │ │ └── MobTaggerConfiguration.java │ │ │ ├── listener │ │ │ └── ListenerDamage.java │ │ │ └── manager │ │ │ ├── ISpawnReasonManager.java │ │ │ ├── SpawnReasonManager_Legacy.java │ │ │ └── SpawnReasonManager_New.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml ├── newbie-helper │ ├── README.MD │ ├── build.gradle.kts │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── newbie │ │ │ └── helper │ │ │ ├── NewbieHelperExpansion.java │ │ │ ├── command │ │ │ ├── CommandTogglePVP.java │ │ │ ├── SubCommandCheck.java │ │ │ ├── SubCommandOff.java │ │ │ ├── SubCommandOn.java │ │ │ └── admin │ │ │ │ ├── SubCommandAdmin.java │ │ │ │ ├── SubCommandAdminOff.java │ │ │ │ └── SubCommandAdminOn.java │ │ │ ├── configuration │ │ │ ├── NewbieHelperConfiguration.java │ │ │ └── WorldsConfiguration.java │ │ │ ├── listener │ │ │ ├── ListenerDamage.java │ │ │ └── ListenerJoin.java │ │ │ ├── manager │ │ │ ├── CooldownManager.java │ │ │ ├── PVPManager.java │ │ │ └── ProtectionManager.java │ │ │ └── placeholder │ │ │ └── NewbieHelperPlaceholderExpansion.java │ │ └── resources │ │ ├── config.yml │ │ ├── expansion.yml │ │ └── worlds.yml ├── rewards │ ├── README.MD │ ├── build.gradle.kts │ ├── gradle.properties │ └── src │ │ └── main │ │ ├── java │ │ └── combatlogx │ │ │ └── expansion │ │ │ └── rewards │ │ │ ├── RewardExpansion.java │ │ │ ├── configuration │ │ │ ├── Reward.java │ │ │ ├── RewardConfiguration.java │ │ │ └── requirement │ │ │ │ ├── EconomyRequirement.java │ │ │ │ ├── ExperienceRequirement.java │ │ │ │ └── Requirement.java │ │ │ ├── hook │ │ │ └── HookVault.java │ │ │ └── listener │ │ │ └── ListenerRewards.java │ │ └── resources │ │ ├── config.yml │ │ └── expansion.yml └── scoreboard │ ├── README.MD │ ├── build.gradle.kts │ ├── gradle.properties │ └── src │ └── main │ ├── java │ └── combatlogx │ │ └── expansion │ │ └── scoreboard │ │ ├── ScoreboardConfiguration.java │ │ ├── ScoreboardExpansion.java │ │ ├── ScoreboardUpdater.java │ │ ├── manager │ │ └── CustomScoreboardManager.java │ │ └── scoreboard │ │ ├── CustomLine.java │ │ ├── CustomScoreboard.java │ │ └── PaperScoreboard.java │ └── resources │ ├── config.yml │ └── expansion.yml ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── plugin ├── README.MD ├── build.gradle.kts ├── gradle.properties └── src │ └── main │ ├── java │ └── com │ │ └── github │ │ └── sirblobman │ │ └── combatlogx │ │ ├── CombatPlugin.java │ │ ├── command │ │ ├── CommandCombatTimer.java │ │ ├── CommandTogglePVP.java │ │ └── combatlogx │ │ │ ├── CommandCombatLogX.java │ │ │ ├── SubCommandAbout.java │ │ │ ├── SubCommandHelp.java │ │ │ ├── SubCommandReload.java │ │ │ ├── SubCommandTag.java │ │ │ ├── SubCommandToggle.java │ │ │ ├── SubCommandUntag.java │ │ │ ├── SubCommandVersion.java │ │ │ └── forgive │ │ │ ├── SubCommandForgive.java │ │ │ ├── SubCommandForgiveAccept.java │ │ │ ├── SubCommandForgiveReject.java │ │ │ ├── SubCommandForgiveRequest.java │ │ │ └── SubCommandForgiveToggle.java │ │ ├── configuration │ │ └── ConfigurationChecker.java │ │ ├── listener │ │ ├── ListenerConfiguration.java │ │ ├── ListenerDamage.java │ │ ├── ListenerDeath.java │ │ ├── ListenerEndCrystal.java │ │ ├── ListenerInvulnerable.java │ │ ├── ListenerPunish.java │ │ └── ListenerUntag.java │ │ ├── manager │ │ ├── CombatManager.java │ │ ├── CrystalManager.java │ │ ├── DeathManager.java │ │ ├── ForgiveManager.java │ │ ├── Manager.java │ │ ├── PlaceholderManager.java │ │ └── PunishManager.java │ │ ├── placeholder │ │ └── BasePlaceholderExpansion.java │ │ └── task │ │ ├── PlayerVulnerableTask.java │ │ ├── TimerUpdateTask.java │ │ └── UntagTask.java │ └── resources │ ├── commands.yml │ ├── config.yml │ ├── language.yml │ ├── language │ ├── ar_sa.lang.yml │ ├── cs_cz.lang.yml │ ├── da_dk.lang.yml │ ├── de_at.lang.yml │ ├── de_ch.lang.yml │ ├── de_de.lang.yml │ ├── el_gr.lang.yml │ ├── en_us.lang.yml │ ├── es_ar.lang.yml │ ├── es_cl.lang.yml │ ├── es_ec.lang.yml │ ├── es_es.lang.yml │ ├── es_mx.lang.yml │ ├── es_uy.lang.yml │ ├── es_ve.lang.yml │ ├── fi_fi.lang.yml │ ├── fr_ca.lang.yml │ ├── fr_fr.lang.yml │ ├── hu_hu.lang.yml │ ├── it_it.lang.yml │ ├── ka_ge.lang.yml │ ├── nl_be.yml │ ├── nl_nl.yml │ ├── nn_no.yml │ ├── no_no.yml │ ├── pl_pl.lang.yml │ ├── pt_br.lang.yml │ ├── pt_pt.lang.yml │ ├── ru_ru.lang.yml │ ├── sv_se.lang.yml │ ├── tr_tr.lang.yml │ ├── uk_ua.lang.yml │ └── zh_cn.lang.yml │ ├── plugin.yml │ └── punish.yml ├── settings.gradle.kts ├── spigot.documentation.bbcode └── spigot.overview.bbcode /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- 1 | blank_issues_enabled: false 2 | contact_links: 3 | - name: "Discord Server" 4 | url: "https://discord.gg/XMq2agT" 5 | about: "Get help through Discord." 6 | - name: "E-Mail Support" 7 | url: "mailto:support@sirblobman.xyz" 8 | about: "Contact SirBlobman through e-mail. Response will be more delayed than GitHub/Discord." 9 | -------------------------------------------------------------------------------- /.github/PULL_REQUEST_TEMPLATE/default.md: -------------------------------------------------------------------------------- 1 | ## Description 2 | 3 | 4 | 5 | ### Testing done 6 | 7 | 12 | 13 | ### Submitter checklist 14 | 15 | - [ ] Make sure you are opening from a **topic/feature/bugfix branch** (right side) and not your main branch! 16 | - [ ] Please describe what you did 17 | - [ ] Link to relevant issues in GitHub. 18 | - [ ] Link to relevant pull requests. 19 | - [ ] Ensure you have provided tests - that demonstrates feature works or fixes the issue. 20 | 21 | 24 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: gradle 4 | directory: "/" 5 | schedule: 6 | interval: daily 7 | open-pull-requests-limit: 20 8 | -------------------------------------------------------------------------------- /.github/funding.yml: -------------------------------------------------------------------------------- 1 | github: 2 | - "SirBlobman" 3 | 4 | custom: 5 | - "https://bit.ly/SirBlobmanDonate" 6 | -------------------------------------------------------------------------------- /CONTRIBUTING.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Contribution Guide 2 | 3 | 1) Try to keep the code style the same. Do not change the import order if possible. 4 | 2) If your feature requires a separate plugin, you may want to create an expansion instead. 5 | 3) Please give full details for any changes you make. 6 | 4) Follow the GitHub rules, project license, and all guidelines. 7 | 5) Good Luck and have fun! 8 | -------------------------------------------------------------------------------- /SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | ## Supported Versions 4 | 5 | | Version | Supported | 6 | |-------------------|--------------------| 7 | | 11.5-SNAPSHOT | :white_check_mark: | 8 | | 11.4-SNAPSHOT | :x: | 9 | | 11.3-SNAPSHOT | :x: | 10 | | 11.2-SNAPSHOT | :x: | 11 | | 11.0.0.0-SNAPSHOT | :x: | 12 | | < 11.0 | :x: | 13 | 14 | ## Expansions 15 | 16 | You must update all expansions when updating CombatLogX 17 | 18 | ## Reporting a Vulnerability 19 | 20 | Please report any security vulnerabilities to my [e-mail](mailto:combatlogx@sirblobman.xyz) 21 | -------------------------------------------------------------------------------- /api/build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | id("maven-publish") 3 | } 4 | 5 | java { 6 | withSourcesJar() 7 | withJavadocJar() 8 | } 9 | 10 | repositories { 11 | maven("https://repo.helpch.at/releases/") 12 | } 13 | 14 | dependencies { 15 | compileOnly("me.clip:placeholderapi:2.11.6") 16 | } 17 | 18 | publishing { 19 | repositories { 20 | maven("https://nexus.sirblobman.xyz/public/") { 21 | credentials { 22 | username = rootProject.ext.get("mavenUsername") as String 23 | password = rootProject.ext.get("mavenPassword") as String 24 | } 25 | } 26 | } 27 | 28 | publications { 29 | create("maven") { 30 | groupId = "com.github.sirblobman.combatlogx" 31 | artifactId = "api" 32 | version = rootProject.ext.get("apiVersion") as String 33 | from(components["java"]) 34 | } 35 | } 36 | } 37 | 38 | tasks.withType { 39 | val standardOptions = (options as StandardJavadocDocletOptions) 40 | standardOptions.addStringOption("Xdoclint:none", "-quiet") 41 | } 42 | -------------------------------------------------------------------------------- /api/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.11.2-R0.1-SNAPSHOT 2 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/ICombatLogXNeeded.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api; 2 | 3 | import java.util.logging.Logger; 4 | 5 | import org.jetbrains.annotations.NotNull; 6 | 7 | public interface ICombatLogXNeeded { 8 | @NotNull ICombatLogX getCombatLogX(); 9 | 10 | default @NotNull Logger getLogger() { 11 | ICombatLogX combatLogX = getCombatLogX(); 12 | return combatLogX.getLogger(); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/event/CustomPlayerEvent.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.event; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.player.PlayerEvent; 7 | 8 | public abstract class CustomPlayerEvent extends PlayerEvent { 9 | public CustomPlayerEvent(@NotNull Player player) { 10 | super(player); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/event/CustomPlayerEventCancellable.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.event; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.Cancellable; 7 | 8 | public abstract class CustomPlayerEventCancellable extends CustomPlayerEvent implements Cancellable { 9 | private boolean cancelled; 10 | 11 | public CustomPlayerEventCancellable(@NotNull Player player) { 12 | super(player); 13 | this.cancelled = false; 14 | } 15 | 16 | @Override 17 | public boolean isCancelled() { 18 | return this.cancelled; 19 | } 20 | 21 | @Override 22 | public void setCancelled(boolean cancel) { 23 | this.cancelled = cancel; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/disguise/DisguiseExpansionListener.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.disguise; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.expansion.ExpansionListener; 6 | 7 | public abstract class DisguiseExpansionListener extends ExpansionListener { 8 | private final DisguiseExpansion expansion; 9 | 10 | public DisguiseExpansionListener(@NotNull DisguiseExpansion expansion) { 11 | super(expansion); 12 | this.expansion = expansion; 13 | } 14 | 15 | protected final @NotNull DisguiseExpansion getDisguiseExpansion() { 16 | return this.expansion; 17 | } 18 | 19 | protected final @NotNull DisguiseHandler getDisguiseHandler() { 20 | DisguiseExpansion expansion = getDisguiseExpansion(); 21 | return expansion.getDisguiseHandler(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/disguise/DisguiseHandler.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.disguise; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | public abstract class DisguiseHandler { 8 | private final DE expansion; 9 | 10 | public DisguiseHandler(@NotNull DE expansion) { 11 | this.expansion = expansion; 12 | } 13 | 14 | protected final DE getExpansion() { 15 | return this.expansion; 16 | } 17 | 18 | public abstract boolean hasDisguise(@NotNull Player player); 19 | 20 | public abstract void removeDisguise(@NotNull Player player); 21 | } 22 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/disguise/DisguiseListener.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.disguise; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.EventPriority; 8 | 9 | import com.github.sirblobman.api.language.LanguageManager; 10 | import com.github.sirblobman.combatlogx.api.event.PlayerTagEvent; 11 | 12 | public final class DisguiseListener extends DisguiseExpansionListener { 13 | public DisguiseListener(@NotNull DisguiseExpansion expansion) { 14 | super(expansion); 15 | } 16 | 17 | @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 18 | public void onTag(PlayerTagEvent e) { 19 | Player player = e.getPlayer(); 20 | DisguiseHandler handler = getDisguiseHandler(); 21 | if (handler.hasDisguise(player)) { 22 | handler.removeDisguise(player); 23 | LanguageManager languageManager = getLanguageManager(); 24 | languageManager.sendMessageWithPrefix(player, "expansion.disguise-compatibility.remove-disguise"); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/skyblock/IslandWrapper.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.skyblock; 2 | 3 | import java.util.Set; 4 | import java.util.UUID; 5 | 6 | import org.jetbrains.annotations.NotNull; 7 | 8 | import org.bukkit.OfflinePlayer; 9 | 10 | public abstract class IslandWrapper { 11 | public abstract @NotNull Set getMembers(); 12 | 13 | public boolean isMember(@NotNull OfflinePlayer player) { 14 | UUID playerId = player.getUniqueId(); 15 | Set memberIdSet = getMembers(); 16 | return memberIdSet.contains(playerId); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/skyblock/SkyBlockExpansionListener.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.skyblock; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.expansion.ExpansionListener; 6 | 7 | public abstract class SkyBlockExpansionListener extends ExpansionListener { 8 | private final SkyBlockExpansion expansion; 9 | 10 | public SkyBlockExpansionListener(@NotNull SkyBlockExpansion expansion) { 11 | super(expansion); 12 | this.expansion = expansion; 13 | } 14 | 15 | protected final @NotNull SkyBlockExpansion getSkyBlockExpansion() { 16 | return this.expansion; 17 | } 18 | 19 | protected final @NotNull SkyBlockHandler getSkyBlockHandler() { 20 | SkyBlockExpansion expansion = getSkyBlockExpansion(); 21 | return expansion.getSkyBlockHandler(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/skyblock/SkyBlockHandler.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.skyblock; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | import org.jetbrains.annotations.Nullable; 5 | 6 | import org.bukkit.Location; 7 | import org.bukkit.OfflinePlayer; 8 | 9 | public abstract class SkyBlockHandler { 10 | private final SE expansion; 11 | 12 | public SkyBlockHandler(@NotNull SE expansion) { 13 | this.expansion = expansion; 14 | } 15 | 16 | protected final SE getExpansion() { 17 | return this.expansion; 18 | } 19 | 20 | public abstract @Nullable IslandWrapper getIsland(@NotNull Location location); 21 | 22 | public abstract @Nullable IslandWrapper getIsland(@NotNull OfflinePlayer player); 23 | 24 | public abstract boolean doesIslandMatch(@NotNull OfflinePlayer player1, @NotNull OfflinePlayer player2); 25 | } 26 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/skyblock/SkyBlockListener.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.skyblock; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Entity; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.event.EventHandler; 8 | import org.bukkit.event.EventPriority; 9 | 10 | import com.github.sirblobman.combatlogx.api.event.PlayerPreTagEvent; 11 | 12 | public final class SkyBlockListener extends SkyBlockExpansionListener { 13 | public SkyBlockListener(@NotNull SkyBlockExpansion expansion) { 14 | super(expansion); 15 | } 16 | 17 | @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 18 | public void beforeTag(PlayerPreTagEvent e) { 19 | Entity enemy = e.getEnemy(); 20 | if (!(enemy instanceof Player)) { 21 | return; 22 | } 23 | 24 | Player player = e.getPlayer(); 25 | Player enemyPlayer = (Player) enemy; 26 | SkyBlockHandler handler = getSkyBlockHandler(); 27 | if (handler.doesIslandMatch(player, enemyPlayer)) { 28 | e.setCancelled(true); 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/vanish/VanishHandler.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.vanish; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | public abstract class VanishHandler { 8 | private final VE expansion; 9 | 10 | public VanishHandler(@NotNull VE expansion) { 11 | this.expansion = expansion; 12 | } 13 | 14 | protected final VE getExpansion() { 15 | return this.expansion; 16 | } 17 | 18 | public abstract boolean isVanished(@NotNull Player player); 19 | } 20 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/expansion/vanish/VanishListener.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.expansion.vanish; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Entity; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.event.EventHandler; 8 | import org.bukkit.event.EventPriority; 9 | 10 | import com.github.sirblobman.combatlogx.api.event.PlayerPreTagEvent; 11 | 12 | public final class VanishListener extends VanishExpansionListener { 13 | public VanishListener(@NotNull VanishExpansion expansion) { 14 | super(expansion); 15 | } 16 | 17 | @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 18 | public void beforeTag(PlayerPreTagEvent e) { 19 | Player player = e.getPlayer(); 20 | VanishHandler vanishHandler = getVanishHandler(); 21 | if (vanishHandler.isVanished(player) && isPreventSelfTag()) { 22 | e.setCancelled(true); 23 | return; 24 | } 25 | 26 | Entity enemy = e.getEnemy(); 27 | if (enemy instanceof Player) { 28 | Player other = (Player) enemy; 29 | if (vanishHandler.isVanished(other) && isPreventOtherTag()) { 30 | e.setCancelled(true); 31 | } 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/manager/ICrystalManager.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.manager; 2 | 3 | import java.util.UUID; 4 | 5 | import org.jetbrains.annotations.NotNull; 6 | import org.jetbrains.annotations.Nullable; 7 | 8 | import org.bukkit.entity.Entity; 9 | import org.bukkit.entity.Player; 10 | 11 | import com.github.sirblobman.combatlogx.api.ICombatLogXNeeded; 12 | 13 | public interface ICrystalManager extends ICombatLogXNeeded { 14 | @Nullable Player getPlacer(@NotNull Entity crystal); 15 | 16 | void setPlacer(@NotNull Entity crystal, @NotNull Player player); 17 | 18 | void remove(@NotNull UUID crystalId); 19 | } 20 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/manager/IForgiveManager.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.manager; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | import org.jetbrains.annotations.Nullable; 5 | 6 | import org.bukkit.OfflinePlayer; 7 | 8 | import com.github.sirblobman.combatlogx.api.ICombatLogXNeeded; 9 | import com.github.sirblobman.combatlogx.api.object.CombatTag; 10 | 11 | public interface IForgiveManager extends ICombatLogXNeeded { 12 | boolean getToggleValue(@NotNull OfflinePlayer player); 13 | 14 | void setToggle(@NotNull OfflinePlayer player, boolean value); 15 | 16 | @Nullable CombatTag getActiveRequest(@NotNull OfflinePlayer player); 17 | 18 | void setRequest(@NotNull OfflinePlayer player, @NotNull CombatTag request); 19 | 20 | void removeRequest(@NotNull OfflinePlayer player); 21 | } 22 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/manager/ITimerManager.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.manager; 2 | 3 | import java.util.Set; 4 | 5 | import org.jetbrains.annotations.NotNull; 6 | 7 | import org.bukkit.entity.Player; 8 | 9 | import com.github.sirblobman.combatlogx.api.ICombatLogXNeeded; 10 | import com.github.sirblobman.combatlogx.api.object.TimerUpdater; 11 | 12 | public interface ITimerManager extends ICombatLogXNeeded { 13 | /** 14 | * @return A {@link Set} of {@link TimerUpdater}s that are currently registered. 15 | */ 16 | @NotNull Set getTimerUpdaters(); 17 | 18 | /** 19 | * Register a {@link TimerUpdater} instance. 20 | * 21 | * @param task The instance to register. 22 | */ 23 | void addUpdaterTask(@NotNull TimerUpdater task); 24 | 25 | /** 26 | * Remove all timers in this manager from the player. 27 | * 28 | * @param player The {@link Player} to remove the timers from. 29 | */ 30 | void remove(@NotNull Player player); 31 | 32 | /** 33 | * Register the manager 34 | */ 35 | void register(); 36 | } 37 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/CitizensSlotType.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | import com.github.sirblobman.combatlogx.api.event.NPCDropItemEvent; 4 | 5 | /** 6 | * Citizens slot type, used for the {@link NPCDropItemEvent} 7 | * 8 | * @author SizzleMcGrizzle 9 | */ 10 | public enum CitizensSlotType { 11 | /** 12 | * Represents an item from the armor content of an inventory 13 | */ 14 | ARMOR, 15 | 16 | /** 17 | * Represents an item from the main container of an inventory (excludes offhand, includes mainhand) 18 | */ 19 | INVENTORY, 20 | 21 | /** 22 | * Represents an item from the off-hand of an inventory 23 | */ 24 | OFFHAND 25 | } 26 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/KillTime.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | import com.github.sirblobman.combatlogx.api.configuration.PunishConfiguration; 4 | 5 | /** 6 | * The time that CombatLogX will kill players. 7 | * 8 | * @see PunishConfiguration#getKillTime() 9 | */ 10 | public enum KillTime { 11 | /** 12 | * Kill the player the instant that they disconnect from the server. 13 | */ 14 | QUIT, 15 | 16 | /** 17 | * Kill the player as soon as they log back in to the server. 18 | */ 19 | JOIN, 20 | 21 | /** 22 | * Tell CombatLogX to not handle player killing. 23 | */ 24 | NEVER 25 | } 26 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/NoEntryMode.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | /** 4 | * No Entry Mode is used in region compatibility expansions. 5 | */ 6 | public enum NoEntryMode { 7 | /** 8 | * Tell the region expansion to not prevent entry. 9 | */ 10 | DISABLED, 11 | 12 | /** 13 | * The player will still take damage from their enemy even if they are in non-pvp areas. 14 | */ 15 | VULNERABLE, 16 | 17 | /** 18 | * The event will be cancelled. (e.g. undo move, prevent teleport) 19 | */ 20 | CANCEL_EVENT, 21 | 22 | /** 23 | * The player will be killed. 24 | */ 25 | KILL_PLAYER, 26 | 27 | /** 28 | * The player will be teleported to their enemy. 29 | */ 30 | TELEPORT_TO_ENEMY, 31 | 32 | /** 33 | * The player will be pushed away from the region with velocity. This option may trigger some anti-cheat plugins. 34 | */ 35 | KNOCKBACK_PLAYER 36 | } 37 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/TagReason.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | /** 4 | * The reason for putting a player into combat. 5 | */ 6 | public enum TagReason { 7 | /** 8 | * Unknown reason for being tagged. Usually occurs from the tag command. 9 | * This can also occur from the Damage Tagger expansion. 10 | */ 11 | UNKNOWN, 12 | 13 | /** 14 | * The player was damaged by an enemy. 15 | */ 16 | ATTACKED, 17 | 18 | /** 19 | * The player caused an enemy to take damage. 20 | */ 21 | ATTACKER; 22 | } 23 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/TagType.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | /** 4 | * The type of combat that a player was tagged with. 5 | */ 6 | public enum TagType { 7 | /** 8 | * Unknown type for being tagged. Usually occurs from the tag command. 9 | */ 10 | UNKNOWN, 11 | 12 | /** 13 | * CombatTag was caused by another player or themselves. 14 | */ 15 | PLAYER, 16 | 17 | /** 18 | * CombatTag was caused by a mob. 19 | */ 20 | MOB, 21 | 22 | /** 23 | * CombatTag was caused by the Damage Tagger expansion. 24 | */ 25 | DAMAGE, 26 | 27 | /** 28 | * CombatTag was caused by a custom mob from the MythicMobs plugin. 29 | */ 30 | MYTHIC_MOB; 31 | } 32 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/TimerType.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | /** 4 | * The type of timer that will be used by CombatLogX 5 | */ 6 | public enum TimerType { 7 | /** 8 | * Every player will be tagged for the same amount of time. 9 | */ 10 | GLOBAL, 11 | 12 | /** 13 | * Some players will have special combat times based on their permissions, others will use the global time. 14 | */ 15 | PERMISSION 16 | } 17 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/TimerUpdater.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import com.github.sirblobman.combatlogx.api.manager.ITimerManager; 8 | 9 | /** 10 | * If you are going to implement this class, don't forget to register your instance with the timer manager. 11 | * 12 | * @see ITimerManager 13 | * @see ITimerManager#addUpdaterTask(TimerUpdater) 14 | */ 15 | public interface TimerUpdater { 16 | /** 17 | * This method is executed every tick while a player is in combat. 18 | * 19 | * @param player The player for this update. 20 | * @param timeLeftMillis The amount of time left in combat for this player. 21 | */ 22 | void update(@NotNull Player player, long timeLeftMillis); 23 | 24 | /** 25 | * This method is executed whenever a player is untagged. 26 | * 27 | * @param player The player for this removal. 28 | */ 29 | void remove(@NotNull Player player); 30 | } 31 | -------------------------------------------------------------------------------- /api/src/main/java/com/github/sirblobman/combatlogx/api/object/UntagReason.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.api.object; 2 | 3 | /** 4 | * The reason for removing a player from combat. 5 | */ 6 | public enum UntagReason { 7 | /** 8 | * The player waited patiently until they were no longer in combat 9 | */ 10 | EXPIRE(true), 11 | 12 | /** 13 | * The player died and the config option was enabled to untag them 14 | */ 15 | SELF_DEATH(true), 16 | 17 | /** 18 | * The player's enemy died and the config option was enabled to untag them 19 | */ 20 | ENEMY_DEATH(true), 21 | 22 | /** 23 | * The enemy of the player forgave them. 24 | */ 25 | ENEMY_FORGIVE(true), 26 | 27 | /** 28 | * The player disconnected from the server 29 | */ 30 | QUIT, 31 | 32 | /** 33 | * The player was kicked by a plugin or timed out 34 | */ 35 | KICK; 36 | 37 | private final boolean expire; 38 | 39 | UntagReason() { 40 | this(false); 41 | } 42 | 43 | UntagReason(boolean expire) { 44 | this.expire = expire; 45 | } 46 | 47 | public boolean isExpire() { 48 | return this.expire; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /crowdin.yml: -------------------------------------------------------------------------------- 1 | project_id: '459244' 2 | pull_request_title: 'Automatic Crowdin Translation Updates' 3 | files: 4 | - source: "/plugin/src/main/resources/language/en_us.lang.yml" 5 | translation: "/plugin/src/main/resources/language/%locale_with_underscore%.lang.yml" 6 | -------------------------------------------------------------------------------- /expansion/action-bar/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Action Bar 2 | 3 | The action bar expansion shows an action bar to every player that is in combat. 4 | 5 | ## Features 6 | 7 | - Customizable action bar message and progress bar. 8 | - Progress bar changes as timer goes down. 9 | 10 | ## Commands 11 | 12 | - **/combatlogx toggle:** 13 | - **/combatlogx toggle actionbar:** Enable or disable your action bar display. 14 | -------------------------------------------------------------------------------- /expansion/action-bar/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=ActionBar 2 | expansion.prefix=Action Bar 3 | -------------------------------------------------------------------------------- /expansion/action-bar/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.action.bar.ActionBarExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/boss-bar/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Boss Bar 2 | 3 | The boss bar expansion shows a boss bar to every player that is in combat. 4 | 5 | ## Features 6 | 7 | - Customizable bar color and style. 8 | - Customizable boss bar message. 9 | - Boss Bar health changes as timer goes down. 10 | 11 | ## Commands 12 | 13 | - **/combatlogx toggle:** 14 | - **/combatlogx toggle bossbar:** Enable or disable your boss bar display. 15 | -------------------------------------------------------------------------------- /expansion/boss-bar/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=BossBar 2 | expansion.prefix=Boss Bar 3 | -------------------------------------------------------------------------------- /expansion/boss-bar/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.boss.bar.BossBarExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/build.gradle.kts: -------------------------------------------------------------------------------- 1 | tasks.named("jar") { 2 | enabled = false 3 | } 4 | 5 | subprojects { 6 | val expansionName = findProperty("expansion.name") ?: "invalid" 7 | val expansionPrefix = findProperty("expansion.prefix") ?: expansionName 8 | 9 | dependencies { 10 | compileOnly(project(":api")) 11 | } 12 | 13 | tasks { 14 | named("jar") { 15 | archiveFileName.set("$expansionPrefix.jar") 16 | } 17 | 18 | processResources { 19 | val expansionDescription = findProperty("expansion.description") ?: "" 20 | 21 | filesMatching("expansion.yml") { 22 | expand( 23 | mapOf( 24 | "expansionName" to expansionName, 25 | "expansionPrefix" to expansionPrefix, 26 | "expansionDescription" to expansionDescription 27 | ) 28 | ) 29 | } 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IBlockConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.api.configuration.IConfigurable; 6 | import com.github.sirblobman.api.shaded.xseries.XMaterial; 7 | 8 | public interface IBlockConfiguration extends IConfigurable { 9 | boolean isPreventInteraction(); 10 | 11 | boolean isPreventBreaking(); 12 | 13 | boolean isPreventPlacing(); 14 | 15 | boolean isPreventPortalCreation(); 16 | 17 | boolean isPreventInteraction(@NotNull XMaterial blockType); 18 | 19 | boolean isPreventBreaking(@NotNull XMaterial blockType); 20 | 21 | boolean isPreventPlacing(@NotNull XMaterial blockType); 22 | } 23 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IBucketConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.api.configuration.IConfigurable; 6 | import com.github.sirblobman.api.shaded.xseries.XMaterial; 7 | 8 | public interface IBucketConfiguration extends IConfigurable { 9 | boolean isPreventBucketEmpty(); 10 | 11 | boolean isPreventBucketFill(); 12 | 13 | boolean isPreventEmpty(@NotNull XMaterial material); 14 | 15 | boolean isPreventFill(@NotNull XMaterial material); 16 | } 17 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IChatConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import com.github.sirblobman.api.configuration.IConfigurable; 4 | 5 | public interface IChatConfiguration extends IConfigurable { 6 | boolean isDisableChat(); 7 | } 8 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/ICommandConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | import org.jetbrains.annotations.Nullable; 5 | 6 | import org.bukkit.permissions.Permission; 7 | 8 | import com.github.sirblobman.api.configuration.IConfigurable; 9 | 10 | public interface ICommandConfiguration extends IConfigurable { 11 | int getDelayAfterCombat(); 12 | 13 | boolean isBlocked(@NotNull String command); 14 | 15 | boolean isAllowed(@NotNull String command); 16 | 17 | @Nullable Permission getBypassPermission(); 18 | } 19 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import com.github.sirblobman.api.configuration.IConfigurable; 4 | 5 | public interface IConfiguration extends IConfigurable { 6 | int getMessageCooldown(); 7 | } 8 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IEntityConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import com.github.sirblobman.api.configuration.IConfigurable; 4 | 5 | public interface IEntityConfiguration extends IConfigurable { 6 | boolean isPreventInteraction(); 7 | } 8 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IFlightConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import com.github.sirblobman.api.configuration.IConfigurable; 4 | 5 | public interface IFlightConfiguration extends IConfigurable { 6 | boolean isPreventFlying(); 7 | 8 | boolean isPreventFallDamage(); 9 | 10 | boolean isForceDisableFlight(); 11 | 12 | boolean isFlightRetag(); 13 | } 14 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IGameModeConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.bukkit.GameMode; 4 | 5 | import com.github.sirblobman.api.configuration.IConfigurable; 6 | 7 | public interface IGameModeConfiguration extends IConfigurable { 8 | boolean isPreventSwitching(); 9 | 10 | boolean isUntagOnSwitch(); 11 | 12 | boolean isForceSwitch(); 13 | 14 | GameMode getForceMode(); 15 | } 16 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IInventoryConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.event.inventory.InventoryType; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public interface IInventoryConfiguration extends IConfigurable { 10 | boolean isClose(); 11 | 12 | boolean isCloseOnRetag(); 13 | 14 | boolean isPreventOpening(); 15 | 16 | boolean isNoMessage(@NotNull InventoryType type); 17 | } 18 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IItemConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import com.github.sirblobman.api.configuration.IConfigurable; 4 | 5 | public interface IItemConfiguration extends IConfigurable { 6 | boolean isPreventDrop(); 7 | 8 | boolean isPreventPickup(); 9 | 10 | boolean isPreventElytra(); 11 | 12 | boolean isForcePreventElytra(); 13 | 14 | boolean isElytraRetag(); 15 | 16 | boolean isPreventTotem(); 17 | 18 | boolean isPreventRiptide(); 19 | 20 | boolean isRiptideRetag(); 21 | } 22 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/IPotionConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.potion.PotionEffectType; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public interface IPotionConfiguration extends IConfigurable { 10 | boolean isBlocked(@NotNull PotionEffectType effectType); 11 | } 12 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/abstract/src/main/java/combatlogx/expansion/cheat/prevention/configuration/ITeleportConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public interface ITeleportConfiguration extends IConfigurable { 10 | boolean isPreventPortals(); 11 | 12 | boolean isPreventTeleportation(); 13 | 14 | boolean isEnderPearlRetag(); 15 | 16 | boolean isUntag(); 17 | 18 | boolean isAllowed(@NotNull TeleportCause cause); 19 | } 20 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/build.gradle.kts: -------------------------------------------------------------------------------- 1 | import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar 2 | 3 | plugins { 4 | id("com.gradleup.shadow") version "8.3.6" 5 | } 6 | 7 | dependencies { 8 | implementation(project(":expansion:cheat-prevention:abstract")) 9 | implementation(project(":expansion:cheat-prevention:legacy")) 10 | implementation(project(":expansion:cheat-prevention:paper")) 11 | implementation(project(path = ":expansion:cheat-prevention:modern", configuration = "default")) 12 | } 13 | 14 | tasks { 15 | named("jar") { 16 | enabled = false 17 | } 18 | 19 | named("shadowJar") { 20 | val expansionName = findProperty("expansion.name") ?: "invalid" 21 | val expansionPrefix = findProperty("expansion.prefix") ?: expansionName 22 | archiveFileName.set("$expansionPrefix.jar") 23 | archiveClassifier.set(null as String?) 24 | } 25 | 26 | named("build") { 27 | dependsOn("shadowJar") 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.16.5-R0.1-SNAPSHOT 2 | expansion.name=CheatPrevention 3 | expansion.prefix=Cheat Prevention 4 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/legacy/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly(project(":expansion:cheat-prevention:abstract")) 3 | } 4 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/legacy/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.8.8-R0.1-SNAPSHOT 2 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/modern/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.papermc.io/repository/maven-public/") 3 | } 4 | 5 | dependencies { 6 | compileOnly(project(":expansion:cheat-prevention:abstract")) 7 | compileOnly("io.papermc.paper:paper-api:1.21.1-R0.1-SNAPSHOT") 8 | } 9 | 10 | java { 11 | sourceCompatibility = JavaVersion.VERSION_21 12 | targetCompatibility = JavaVersion.VERSION_21 13 | toolchain.languageVersion.set(JavaLanguageVersion.of(21)) 14 | } 15 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/modern/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.21.1-R0.1-SNAPSHOT 2 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/paper/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.papermc.io/repository/maven-public/") 3 | } 4 | 5 | dependencies { 6 | val spigotVersion = property("version.spigot") as String 7 | compileOnly("com.destroystokyo.paper:paper-api:$spigotVersion") 8 | compileOnly(project(":expansion:cheat-prevention:abstract")) 9 | } 10 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/paper/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.16.5-R0.1-SNAPSHOT 2 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/java/combatlogx/expansion/cheat/prevention/configuration/ChatConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.bukkit.configuration.ConfigurationSection; 4 | 5 | public final class ChatConfiguration implements IChatConfiguration { 6 | private boolean disableChat; 7 | 8 | public ChatConfiguration() { 9 | this.disableChat = false; 10 | } 11 | 12 | @Override 13 | public void load(ConfigurationSection config) { 14 | setDisableChat(config.getBoolean("disable-chat", false)); 15 | } 16 | 17 | @Override 18 | public boolean isDisableChat() { 19 | return this.disableChat; 20 | } 21 | 22 | public void setDisableChat(boolean disableChat) { 23 | this.disableChat = disableChat; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/java/combatlogx/expansion/cheat/prevention/configuration/CheatPreventionConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.bukkit.configuration.ConfigurationSection; 4 | 5 | public final class CheatPreventionConfiguration implements IConfiguration { 6 | private int messageCooldown; 7 | 8 | public CheatPreventionConfiguration() { 9 | this.messageCooldown = 30; 10 | } 11 | 12 | @Override 13 | public void load(ConfigurationSection config) { 14 | setMessageCooldown(config.getInt("message-cooldown", 30)); 15 | } 16 | 17 | @Override 18 | public int getMessageCooldown() { 19 | return this.messageCooldown; 20 | } 21 | 22 | public void setMessageCooldown(int messageCooldown) { 23 | this.messageCooldown = messageCooldown; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/java/combatlogx/expansion/cheat/prevention/configuration/EntityConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.cheat.prevention.configuration; 2 | 3 | import org.bukkit.configuration.ConfigurationSection; 4 | 5 | public final class EntityConfiguration implements IEntityConfiguration { 6 | private boolean preventInteraction; 7 | 8 | public EntityConfiguration() { 9 | this.preventInteraction = false; 10 | } 11 | 12 | @Override 13 | public void load(ConfigurationSection config) { 14 | setPreventInteraction(config.getBoolean("prevent-interaction", false)); 15 | } 16 | 17 | @Override 18 | public boolean isPreventInteraction() { 19 | return this.preventInteraction; 20 | } 21 | 22 | public void setPreventInteraction(boolean value) { 23 | this.preventInteraction = value; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/blocks.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from interacting with blocks during combat? 2 | # Default: false 3 | prevent-interaction: false 4 | 5 | # This is a list of blocks that players should not interact with during combat. 6 | # Spigot Material List: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html 7 | # This defaults to prevent all block interactions. 8 | prevent-interaction-list: 9 | - "*" 10 | 11 | # Should players be prevented from breaking blocks during combat? 12 | # Default: true 13 | prevent-breaking: true 14 | 15 | # This is a list of blocks that should be prevented from breaking 16 | # Spigot Material List: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html 17 | # This defaults to prevent all block breaking 18 | prevent-breaking-list: 19 | - "*" 20 | 21 | # Should players be prevented from placing blocks during combat? 22 | # Default: true 23 | prevent-placing: true 24 | 25 | # This is a list of blocks that should be prevented from placing 26 | # Spigot Material List: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Material.html 27 | # This defaults to prevent all block placing 28 | prevent-placing-list: 29 | - "*" 30 | 31 | # Should players be prevented from creating portals during combat? 32 | # This option only works in 1.14.4+ 33 | # Default: false 34 | prevent-portal-creation: false 35 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/buckets.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from emptying buckets during combat? 2 | # Default: false 3 | prevent-bucket-empty: false 4 | 5 | # Should players be prevented from filling buckets during combat? 6 | # Default: false 7 | prevent-bucket-fill: false 8 | 9 | # Which bucket types cannot be emptied during combat? 10 | # Requires 'prevent-bucket-empty: true' 11 | # Use '*' for all bucket types. 12 | # Use XMaterial names for custom types: 13 | # https://github.com/CryptoMorin/XSeries/blob/master/src/main/java/com/cryptomorin/xseries/XMaterial.java 14 | prevent-bucket-empty-list: 15 | - "*" 16 | 17 | # Which bucket types cannot be filled during combat? 18 | # Requires 'prevent-bucket-fill: true' 19 | # Use '*' for all bucket types. 20 | # Use XMaterial names for custom types: 21 | # https://github.com/CryptoMorin/XSeries/blob/master/src/main/java/com/cryptomorin/xseries/XMaterial.java 22 | prevent-bucket-fill-list: 23 | - "LAVA_BUCKET" 24 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/chat.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from typing in chat during combat? 2 | # Default: false 3 | disable-chat: false 4 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/commands.yml: -------------------------------------------------------------------------------- 1 | # How much time do players have to wait to run commands AFTER the combat timer has ended? 2 | # The time is in seconds 3 | # Default: 0 4 | delay-after-combat: 0 5 | 6 | # Which commands are blocked during combat? 7 | # DO NOT forget the `/` in front of the commands. 8 | # You can add "*" to the list to block ALL commands. 9 | blocked-command-list: 10 | - "/tp" 11 | - "/fly" 12 | - "/gamemode" 13 | - "/gm" 14 | - "//wand" 15 | - "/spawn" 16 | - "/home" 17 | - "/sethome" 18 | - "/msg" 19 | 20 | # Which commands are allowed during combat? 21 | # This list is used if you want to un-block a command that is blocked the the other list. 22 | # You can add "*" to the list to allow ALL commands. 23 | # 24 | # Extra Information: This list overrides the blocked command list 25 | allowed-command-list: 26 | - "/msg SirBlobman" 27 | 28 | # Players with this permission will have every command unblocked. 29 | # The permission is not given to OPs by default, you must set it manually. 30 | bypass-permission: "combatlogx.bypass.cheat.prevention.commands" 31 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # How long should the expansion wait before sending the same message again? 2 | # Default: 30 (seconds) 3 | message-cooldown: 30 4 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/entities.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from right-clicking entities during combat? 2 | # Default: false 3 | prevent-interaction: false 4 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.cheat.prevention.CheatPreventionExpansion" 6 | version: "17.8" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/flight.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from flying during combat? 2 | # Default: true 3 | prevent-flying: true 4 | 5 | # If a players flight is deactivated by CombatLogX, should the plugin prevent them from taking fall damage? 6 | # The fall damage prevention only works once after flight is disabled. 7 | # Default: true 8 | prevent-fall-damage: true 9 | 10 | # Should the 'allow-flight' flag be set to false on a player? 11 | # This may prevent toggle spam but players won't be able to fly after combat ends. 12 | # Default: false 13 | force-disable-flight: false 14 | 15 | # Should flying cause a player's timer to reset during combat? 16 | # This option is not useful unless you set 'prevent-flying' and 'force-disable-flight' to 'false'. 17 | # Default: false 18 | flight-retag: false 19 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/game-mode.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from changing game modes during combat? 2 | # Default: true 3 | prevent-switching: true 4 | 5 | # If 'prevent-switching' is false, should players be untagged when they change modes? 6 | # Default: false 7 | untag-on-switch: false 8 | 9 | # Should players be forced into a specific game mode when they get into combat? 10 | # Default: false 11 | force-switch: false 12 | 13 | # If 'force-switch' is enabled, which mode should be used? 14 | # Valid options can be found in the link below: 15 | # https://hub.spigotmc.org/javadocs/spigot/org/bukkit/GameMode.html 16 | force-mode: SURVIVAL 17 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/inventories.yml: -------------------------------------------------------------------------------- 1 | # Should CombatLogX close a player's inventory when they are first tagged into combat? 2 | # Default: true 3 | close: true 4 | 5 | # Should CombatLogX close a player's inventory when they are tagged while already in combat? 6 | close-on-retag: true 7 | 8 | # Which inventory types should not trigger an inventory closed message? 9 | # To the server, a player always has an inventory open, even if its just the hotbar. 10 | no-close-message-type-list: 11 | - CREATIVE 12 | - CRAFTING 13 | 14 | # Should CombatLogX prevent players from opening new inventories while they are tagged? 15 | # This does not affect client-side-only inventories. 16 | # Default: true 17 | prevent-opening: true 18 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/items.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from dropping items during combat? 2 | # Default: true 3 | prevent-drop: true 4 | 5 | # Should players be prevented from picking up items during combat? 6 | # Default: false 7 | prevent-pickup: true 8 | 9 | # Should players be prevented from using Elytra during combat? 10 | # Default: true 11 | prevent-elytra: true 12 | 13 | # Should player's that are gliding have their elytra forcefully disabled when tagged? 14 | force-prevent-elytra: false 15 | 16 | # Should gliding cause a player's timer to reset during combat? 17 | # This option is not useful unless you set 'prevent-elytra' and 'force-prevent-elytra' to 'false'. 18 | # Default: false 19 | elytra-retag: false 20 | 21 | # Should players be prevented from using Totems of Undying during combat? 22 | # Default: false 23 | prevent-totem: false 24 | 25 | # Should players be prevented from using tridents with the riptide enchantment during combat? 26 | # Default: false 27 | prevent-riptide: false 28 | 29 | # Should players that use tridents and the riptide effect increase the combat timer? 30 | # May conflict if both 'prevent-riptide' and 'riptide-retag' are enabled. 31 | # Default: false 32 | riptide-retag: false 33 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/potions.yml: -------------------------------------------------------------------------------- 1 | # This is a list of potion effects that will be removed when a player is tagged. 2 | # You can find a list of valid potion types in the link below: 3 | # https://hub.spigotmc.org/javadocs/spigot/org/bukkit/potion/PotionEffectType.html 4 | # You can unblock all potion effects by setting the value of this list to [] 5 | # Example: 'blocked-potion-type-list: []' 6 | blocked-potion-type-list: 7 | - INCREASE_DAMAGE 8 | - INVISIBILITY 9 | 10 | # Set this to 'true' to turn the 'blocked' list to an 'allowed' list. 11 | blocked-potion-type-list-inverted: false 12 | -------------------------------------------------------------------------------- /expansion/cheat-prevention/src/main/resources/teleportation.yml: -------------------------------------------------------------------------------- 1 | # Should players be prevented from using nether/end portals during combat? 2 | # Default: true 3 | prevent-portals: true 4 | 5 | # Should players be prevented from teleporting away during combat? 6 | # Default: true 7 | prevent-teleportation: true 8 | 9 | # Are there any reasons that a teleport should not be cancelled? 10 | # You can find a list of valid values in the link below: 11 | # https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/event/player/PlayerTeleportEvent.TeleportCause.html 12 | allowed-teleport-cause-list: 13 | - PLUGIN # Some plugins don't like when CombatLogX cancels their teleports 14 | - UNKNOWN # Allowing 'UNKNOWN' may fix some glitches with region protection plugins 15 | - ENDER_PEARL # Most servers think that ender pearls are fair game during combat. 16 | 17 | # Should ender pearls cause a player's timer to reset during combat? 18 | # Default: false 19 | ender-pearl-retag: false 20 | 21 | # If a player teleports away, should their tag be removed? 22 | # Default: false 23 | untag: false 24 | -------------------------------------------------------------------------------- /expansion/compatibility/ASkyBlock/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.codemc.io/repository/maven-public/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.wasteofplastic:askyblock:3.0.9.4") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/ASkyBlock/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatASkyBlock 2 | expansion.prefix=ASkyBlock Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/ASkyBlock/src/main/java/combatlogx/expansion/compatibility/askyblock/ASkyBlockExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.askyblock; 2 | 3 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 4 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 5 | 6 | import combatlogx.expansion.compatibility.askyblock.listener.ListenerASkyBlock; 7 | 8 | public final class ASkyBlockExpansion extends Expansion { 9 | public ASkyBlockExpansion(ICombatLogX plugin) { 10 | super(plugin); 11 | } 12 | 13 | @Override 14 | public void onLoad() { 15 | // Do Nothing 16 | } 17 | 18 | @Override 19 | public void onEnable() { 20 | if (!checkDependency("ASkyBlock", true)) { 21 | selfDisable(); 22 | } 23 | 24 | new ListenerASkyBlock(this).register(); 25 | } 26 | 27 | @Override 28 | public void onDisable() { 29 | // Do Nothing 30 | } 31 | 32 | @Override 33 | public void reloadConfig() { 34 | // Do Nothing 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /expansion/compatibility/ASkyBlock/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.askyblock.ASkyBlockExpansion" 6 | version: "17.0" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "ASkyBlock" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/AngelChest/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.jeff-media.com/public/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("de.jeff_media:AngelChestAPI:13.6.1") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/AngelChest/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatAngelChest 2 | expansion.prefix=AngelChest Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/AngelChest/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should CombatLogX prevent players from breaking AngelChests during combat? 2 | # Default: true 3 | prevent-breaking: true 4 | 5 | # Should CombatLogX prevent players from opening AngelChests during combat? 6 | # Default: true 7 | prevent-opening: true 8 | 9 | # Should CombatLogX prevent players from fast looting AngelChests during combat? 10 | # Default: true 11 | prevent-fast-looting: true 12 | -------------------------------------------------------------------------------- /expansion/compatibility/AngelChest/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.angelchest.AngelChestExpansion" 6 | version: "17.2" 7 | author: "olivolja3" 8 | 9 | plugin-depend: 10 | - "AngelChest" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/BSkyBlock/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.codemc.io/repository/bentoboxworld/") 3 | maven("https://repo.codemc.io/repository/maven-snapshots/") 4 | maven("https://repo.codemc.io/repository/maven-public/") 5 | } 6 | 7 | dependencies { 8 | compileOnly("world.bentobox:bentobox:3.3.5-SNAPSHOT") // BentoBox 9 | compileOnly("world.bentobox:bskyblock:1.19.1-SNAPSHOT") // BSkyBlock 10 | } 11 | -------------------------------------------------------------------------------- /expansion/compatibility/BSkyBlock/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatBSkyBlock 2 | expansion.prefix=BSkyBlock Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/BSkyBlock/src/main/java/combatlogx/expansion/compatibility/bskyblock/BSkyBlockExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.bskyblock; 2 | 3 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 4 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 5 | 6 | import combatlogx.expansion.compatibility.bskyblock.hook.HookBentoBox; 7 | import combatlogx.expansion.compatibility.bskyblock.listener.ListenerBSkyBlock; 8 | 9 | public final class BSkyBlockExpansion extends Expansion { 10 | public BSkyBlockExpansion(ICombatLogX plugin) { 11 | super(plugin); 12 | } 13 | 14 | @Override 15 | public void onLoad() { 16 | // Do Nothing 17 | } 18 | 19 | @Override 20 | public void onEnable() { 21 | if (!checkDependency("BentoBox", true)) { 22 | selfDisable(); 23 | return; 24 | } 25 | 26 | if (!HookBentoBox.findBSkyBlock(this)) { 27 | selfDisable(); 28 | return; 29 | } 30 | 31 | new ListenerBSkyBlock(this).register(); 32 | } 33 | 34 | @Override 35 | public void onDisable() { 36 | // Do Nothing 37 | } 38 | 39 | @Override 40 | public void reloadConfig() { 41 | // Do Nothing 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /expansion/compatibility/BSkyBlock/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.bskyblock.BSkyBlockExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "BentoBox" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/CMI/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("net.zrips:CMI-API:9.7.4.1") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/CMI/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatCMI 2 | expansion.prefix=CMI Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/CMI/src/main/java/combatlogx/expansion/compatibility/cmi/CMIExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.cmi; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishHandler; 8 | 9 | public final class CMIExpansion extends VanishExpansion { 10 | private VanishHandler vanishHandler; 11 | 12 | public CMIExpansion(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.vanishHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("CMI", true, "9"); 20 | } 21 | 22 | @Override 23 | public @NotNull VanishHandler getVanishHandler() { 24 | if (this.vanishHandler == null) { 25 | this.vanishHandler = new VanishHandlerCMI(this); 26 | } 27 | 28 | return this.vanishHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/CMI/src/main/java/combatlogx/expansion/compatibility/cmi/VanishHandlerCMI.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.cmi; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | import org.jetbrains.annotations.Nullable; 5 | 6 | import org.bukkit.entity.Player; 7 | 8 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishHandler; 9 | 10 | import com.Zrips.CMI.CMI; 11 | import com.Zrips.CMI.Containers.CMIUser; 12 | import com.Zrips.CMI.PlayerManager; 13 | 14 | public final class VanishHandlerCMI extends VanishHandler { 15 | public VanishHandlerCMI(@NotNull CMIExpansion expansion) { 16 | super(expansion); 17 | } 18 | 19 | @Override 20 | public boolean isVanished(@NotNull Player player) { 21 | CMIUser user = getUser(player); 22 | return (user != null && user.isVanished()); 23 | } 24 | 25 | private @NotNull CMI getCMI() { 26 | return CMI.getInstance(); 27 | } 28 | 29 | private @NotNull PlayerManager getPlayerManager() { 30 | CMI cmi = getCMI(); 31 | return cmi.getPlayerManager(); 32 | } 33 | 34 | private @Nullable CMIUser getUser(@NotNull Player player) { 35 | PlayerManager playerManager = getPlayerManager(); 36 | return playerManager.getUser(player); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /expansion/compatibility/CMI/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should players in vanish be preventing from going into combat? 2 | prevent-vanish-tagging-self: true 3 | 4 | # Should players in vanish be unable to tag other players? 5 | prevent-vanish-tagging-other: true 6 | -------------------------------------------------------------------------------- /expansion/compatibility/CMI/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.cmi.CMIExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "CMI" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/Citizens/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-citizens/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("net.citizensnpcs:citizensapi:2.0.38-SNAPSHOT") 7 | compileOnly("org.mcmonkey:sentinel:2.9.0-SNAPSHOT") 8 | } 9 | -------------------------------------------------------------------------------- /expansion/compatibility/Citizens/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.13.2-R0.1-SNAPSHOT 2 | expansion.name=CompatCitizens 3 | expansion.prefix=Citizens Compatibility 4 | -------------------------------------------------------------------------------- /expansion/compatibility/Citizens/src/main/java/combatlogx/expansion/compatibility/citizens/configuration/Configuration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.citizens.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class Configuration implements IConfigurable { 10 | private boolean npcTagging; 11 | private boolean enableSentinel; 12 | 13 | public Configuration() { 14 | this.npcTagging = false; 15 | this.enableSentinel = true; 16 | } 17 | 18 | @Override 19 | public void load(@NotNull ConfigurationSection config) { 20 | setNpcTagging(config.getBoolean("npc-tagging", false)); 21 | setEnableSentinel(config.getBoolean("enable-sentinel", true)); 22 | } 23 | 24 | public boolean isNpcTagging() { 25 | return this.npcTagging; 26 | } 27 | 28 | public void setNpcTagging(boolean npcTagging) { 29 | this.npcTagging = npcTagging; 30 | } 31 | 32 | public boolean isEnableSentinel() { 33 | return this.enableSentinel; 34 | } 35 | 36 | public void setEnableSentinel(boolean enableSentinel) { 37 | this.enableSentinel = enableSentinel; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /expansion/compatibility/Citizens/src/main/java/combatlogx/expansion/compatibility/citizens/listener/ListenerConvert.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.citizens.listener; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Entity; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.EventPriority; 8 | import org.bukkit.event.entity.EntityTransformEvent; 9 | 10 | import com.github.sirblobman.combatlogx.api.utility.EntityHelper; 11 | 12 | import combatlogx.expansion.compatibility.citizens.CitizensExpansion; 13 | import combatlogx.expansion.compatibility.citizens.object.CombatNPC; 14 | import net.citizensnpcs.api.npc.NPC; 15 | 16 | public final class ListenerConvert extends CitizensExpansionListener { 17 | public ListenerConvert(@NotNull CitizensExpansion expansion) { 18 | super(expansion); 19 | } 20 | 21 | @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 22 | public void onConvert(EntityTransformEvent e) { 23 | Entity entity = e.getEntity(); 24 | if (!EntityHelper.isNPC(entity)) { 25 | return; 26 | } 27 | 28 | NPC npc = getNPC(entity); 29 | if (npc == null) { 30 | return; 31 | } 32 | 33 | CombatNPC combatNPC = getCombatNPC(npc); 34 | if (combatNPC != null) { 35 | e.setCancelled(true); 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /expansion/compatibility/Citizens/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should players be tagged by NPCs? 2 | # Default: false 3 | npc-tagging: false 4 | 5 | # Should we use the Sentinel plugin to create combat NPCs? 6 | # Requires Sentinel, which can be found at the link below: 7 | # https://www.spigotmc.org/resources/22017/ 8 | # Default: true 9 | enable-sentinel: true 10 | -------------------------------------------------------------------------------- /expansion/compatibility/Citizens/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.citizens.CitizensExpansion" 6 | version: "17.16" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "Citizens" 11 | 12 | plugin-soft-depend: 13 | - "Sentinel" 14 | -------------------------------------------------------------------------------- /expansion/compatibility/Citizens/src/main/resources/sentinel.yml: -------------------------------------------------------------------------------- 1 | # true: Combat NPCs will attack their enemy first. 2 | # false: Combat NPCs will only attack if they are attacked first. 3 | # Default: false 4 | attack-first: false 5 | -------------------------------------------------------------------------------- /expansion/compatibility/CrackShot/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("dev.bukkit.shampaggon:CrackShot:0.98.11") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/CrackShot/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatCrackShot 2 | expansion.prefix=CrackShot Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/CrackShot/src/main/java/combatlogx/expansion/compatibility/crackshot/CrackShotExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.crackshot; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 7 | 8 | import combatlogx.expansion.compatibility.crackshot.listener.ListenerCrackShot; 9 | 10 | public final class CrackShotExpansion extends Expansion { 11 | public CrackShotExpansion(@NotNull ICombatLogX plugin) { 12 | super(plugin); 13 | } 14 | 15 | @Override 16 | public void onLoad() { 17 | // Do Nothing 18 | } 19 | 20 | @Override 21 | public void onEnable() { 22 | if (!checkDependency("CrackShot", true)) { 23 | selfDisable(); 24 | return; 25 | } 26 | 27 | new ListenerCrackShot(this).register(); 28 | } 29 | 30 | @Override 31 | public void onDisable() { 32 | // Do Nothing 33 | } 34 | 35 | @Override 36 | public void reloadConfig() { 37 | // Do Nothing 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /expansion/compatibility/CrackShot/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.crackshot.CrackShotExpansion" 6 | version: "17.0" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "CrackShot" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/CrashClaim/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-jitpack/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.github.WhipDevelopment:CrashClaim:344ef20be5") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/CrashClaim/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatCrashClaim 2 | expansion.prefix=CrashClaim Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/CrashClaim/src/main/java/combatlogx/expansion/compatibility/region/crash/claim/CrashClaimExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.crash.claim; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class CrashClaimExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public CrashClaimExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("CrashClaim", true, "1.0"); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new CrashClaimRegionHandler(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/CrashClaim/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.crash.claim.CrashClaimExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "CrashClaim" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/EssentialsX/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.essentialsx.net/releases/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("net.essentialsx:EssentialsX:2.21.0") { 7 | exclude("io.papermc") 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /expansion/compatibility/EssentialsX/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatEssentialsX 2 | expansion.prefix=EssentialsX Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/EssentialsX/src/main/java/combatlogx/expansion/compatibility/essentials/EssentialsExpansionConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.essentials; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class EssentialsExpansionConfiguration implements IConfigurable { 10 | private boolean preventTeleportRequest; 11 | 12 | public EssentialsExpansionConfiguration() { 13 | this.preventTeleportRequest = true; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection config) { 18 | setPreventTeleportRequest(config.getBoolean("prevent-teleport-request", true)); 19 | } 20 | 21 | public boolean isPreventTeleportRequest() { 22 | return this.preventTeleportRequest; 23 | } 24 | 25 | public void setPreventTeleportRequest(boolean preventTeleportRequest) { 26 | this.preventTeleportRequest = preventTeleportRequest; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/EssentialsX/src/main/java/combatlogx/expansion/compatibility/essentials/VanishHandlerEssentialsX.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.essentials; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.plugin.java.JavaPlugin; 7 | 8 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishHandler; 9 | 10 | import com.earth2me.essentials.Essentials; 11 | import com.earth2me.essentials.User; 12 | 13 | public final class VanishHandlerEssentialsX extends VanishHandler { 14 | public VanishHandlerEssentialsX(@NotNull EssentialsExpansion expansion) { 15 | super(expansion); 16 | } 17 | 18 | @Override 19 | public boolean isVanished(@NotNull Player player) { 20 | User user = getUser(player); 21 | return user.isVanished(); 22 | } 23 | 24 | private @NotNull Essentials getEssentials() { 25 | return JavaPlugin.getPlugin(Essentials.class); 26 | } 27 | 28 | private @NotNull User getUser(@NotNull Player player) { 29 | Essentials essentials = getEssentials(); 30 | return essentials.getUser(player); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /expansion/compatibility/EssentialsX/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should players in vanish be preventing from going into combat? 2 | prevent-vanish-tagging-self: true 3 | 4 | # Should players in vanish be unable to tag other players? 5 | prevent-vanish-tagging-other: true 6 | 7 | # Should teleport requests be disabled during combat? 8 | prevent-teleport-request: true 9 | -------------------------------------------------------------------------------- /expansion/compatibility/EssentialsX/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.essentials.EssentialsExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "Essentials" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/FabledSkyBlock/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/private/") { 3 | credentials { 4 | username = rootProject.ext.get("mavenUsername") as String 5 | password = rootProject.ext.get("mavenPassword") as String 6 | } 7 | } 8 | } 9 | 10 | dependencies { 11 | compileOnly("com.songoda:FabledSkyBlock:4.2.0") 12 | } 13 | -------------------------------------------------------------------------------- /expansion/compatibility/FabledSkyBlock/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatFabledSkyBlock 2 | expansion.prefix=FabledSkyBlock Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/FabledSkyBlock/src/main/java/combatlogx/expansion/compatibility/fabled/skyblock/FabledSkyBlockExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.fabled.skyblock; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockHandler; 8 | 9 | public final class FabledSkyBlockExpansion extends SkyBlockExpansion { 10 | private SkyBlockHandler skyBlockHandler; 11 | 12 | public FabledSkyBlockExpansion(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.skyBlockHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("FabledSkyBlock", true, "4"); 20 | } 21 | 22 | @Override 23 | public @NotNull SkyBlockHandler getSkyBlockHandler() { 24 | if (this.skyBlockHandler == null) { 25 | this.skyBlockHandler = new SkyBlockHandlerFabled(this); 26 | } 27 | 28 | return this.skyBlockHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/FabledSkyBlock/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.fabled.skyblock.FabledSkyBlockExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "FabledSkyBlock" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/Factions/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatFactions 2 | expansion.prefix=Factions Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/Factions/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # How should CombatLogX prevent players from entering non-pvp areas? 2 | # Valid Modes: 3 | # DISABLED - Don't do anything, just let them in 4 | # KNOCKBACK_PLAYER - Add some opposite velocity to the player so they are pushed backwards 5 | # CANCEL_EVENT - Cancel the player's move event 6 | # VULNERABLE - Let the player in, but remove their pvp protection 7 | # KILL_PLAYER - Set the player's health to 0 8 | # TELEPORT_TO_ENEMY - Teleport the player to their enemy if they have one, or CANCEL if they don't have one. 9 | # Default: KNOCKBACK_PLAYER 10 | no-entry-mode: "KNOCKBACK_PLAYER" 11 | 12 | # This value is only used if 'no-entry-mode' is KNOCKBACK_PLAYER 13 | # How much should the backwards velocity be multiplied by? 14 | # Default: 1.5 15 | knockback-strength: 1.5 16 | 17 | # How much time (in seconds) should the plugin wait before sending another 'no-entry' message? 18 | # Default: 30 19 | message-cooldown: 30 20 | -------------------------------------------------------------------------------- /expansion/compatibility/Factions/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.factions.FactionsExpansion" 6 | version: "17.0" 7 | author: "SirBlobman" 8 | 9 | plugin-soft-depend: 10 | - "Factions" 11 | - "FactionsX" 12 | - "LegacyFactions" 13 | -------------------------------------------------------------------------------- /expansion/compatibility/FeatherBoard/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/private/") { 3 | credentials { 4 | username = rootProject.ext.get("mavenUsername") as String 5 | password = rootProject.ext.get("mavenPassword") as String 6 | } 7 | } 8 | } 9 | 10 | dependencies { 11 | compileOnly("com.mvdw-software:FeatherBoard:6.0.7") 12 | } 13 | -------------------------------------------------------------------------------- /expansion/compatibility/FeatherBoard/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatFeatherBoard 2 | expansion.prefix=FeatherBoard Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/FeatherBoard/src/main/java/combatlogx/expansion/compatibility/featherboard/FeatherBoardConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.featherboard; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public class FeatherBoardConfiguration implements IConfigurable { 10 | private String triggerName; 11 | 12 | public FeatherBoardConfiguration() { 13 | this.triggerName = "combatlogx"; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection config) { 18 | setTriggerName(config.getString("trigger-name", "combatlogx")); 19 | } 20 | 21 | public @NotNull String getTriggerName() { 22 | return this.triggerName; 23 | } 24 | 25 | public void setTriggerName(@NotNull String triggerName) { 26 | this.triggerName = triggerName; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/FeatherBoard/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Which trigger name should be sent to FeatherBoard whenever a player is tagged? 2 | trigger-name: "combatlogx" 3 | -------------------------------------------------------------------------------- /expansion/compatibility/FeatherBoard/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.featherboard.FeatherBoardExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "FeatherBoard" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefDefender/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.glaremasters.me/repository/bloodshot/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.griefdefender:api:2.1.1-SNAPSHOT") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefDefender/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatGriefDefender 2 | expansion.prefix=GriefDefender Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefDefender/src/main/java/combatlogx/expansion/compatibility/region/grief/defender/GriefDefenderExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.grief.defender; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class GriefDefenderExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public GriefDefenderExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("GriefDefender", true); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerGriefDefender(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefDefender/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.grief.defender.GriefDefenderExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "GriefDefender" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefPrevention/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-jitpack/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.github.GriefPrevention:GriefPrevention:17.0.0") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefPrevention/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatGriefPrevention 2 | expansion.prefix=GriefPrevention Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefPrevention/src/main/java/combatlogx/expansion/compatibility/region/grief/prevention/GriefPreventionExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.grief.prevention; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class GriefPreventionExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public GriefPreventionExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("GriefPrevention", true); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerGriefPrevention(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/GriefPrevention/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.grief.prevention.GriefPreventionExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | late-load: true 10 | plugin-depend: 11 | - "GriefPrevention" 12 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskHomes/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.william278.net/releases/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("net.william278:huskhomes:4.5.5") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskHomes/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatHuskHomes 2 | expansion.prefix=HuskHomes Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskHomes/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should teleports be prevented during combat? 2 | prevent-teleport: true 3 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskHomes/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.huskhomes.HuskHomesExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "HuskHomes" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskSync/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.william278.net/releases/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("net.william278.husksync:husksync-bukkit:3.6.8") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskSync/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatHuskSync 2 | expansion.name=HuskSync Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskSync/src/main/java/combatlogx/expansion/compatibility/husksync/DropItemsTask.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.husksync; 2 | 3 | import java.util.Collection; 4 | 5 | import org.jetbrains.annotations.NotNull; 6 | 7 | import org.bukkit.Location; 8 | import org.bukkit.World; 9 | import org.bukkit.inventory.ItemStack; 10 | import org.bukkit.plugin.Plugin; 11 | 12 | import com.github.sirblobman.api.folia.details.LocationTaskDetails; 13 | import com.github.sirblobman.api.utility.ItemUtility; 14 | 15 | public final class DropItemsTask extends LocationTaskDetails { 16 | private final Collection dropList; 17 | 18 | public DropItemsTask(@NotNull Plugin plugin, @NotNull Location location, @NotNull Collection drops) { 19 | super(plugin, location); 20 | this.dropList = drops; 21 | setDelay(1L); 22 | } 23 | 24 | @Override 25 | public void run() { 26 | Location location = getLocation(); 27 | World world = location.getWorld(); 28 | for (ItemStack stack : this.dropList) { 29 | if (ItemUtility.isAir(stack)) { 30 | continue; 31 | } 32 | 33 | world.dropItemNaturally(location, stack); 34 | } 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskSync/src/main/java/combatlogx/expansion/compatibility/husksync/HuskSyncExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.husksync; 2 | 3 | import com.github.sirblobman.api.configuration.ConfigurationManager; 4 | import org.jetbrains.annotations.NotNull; 5 | 6 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 7 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 8 | 9 | import java.util.HashSet; 10 | import java.util.Set; 11 | 12 | public final class HuskSyncExpansion extends Expansion { 13 | public HuskSyncExpansion(@NotNull ICombatLogX plugin) { 14 | super(plugin); 15 | } 16 | 17 | @Override 18 | public void onLoad() { 19 | // Do Nothing 20 | } 21 | 22 | @Override 23 | public void onEnable() { 24 | if (!checkDependency("HuskSync", true, "3.7")) { 25 | selfDisable(); 26 | return; 27 | } 28 | 29 | new ListenerHuskSync(this).register(); 30 | } 31 | 32 | @Override 33 | public void onDisable() { 34 | // Do Nothing 35 | } 36 | 37 | 38 | @Override 39 | public void reloadConfig() { 40 | // Do Nothing 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskSync/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.husksync.HuskSyncExpansion" 6 | version: "17.6" 7 | author: "olivolja3" 8 | 9 | plugin-depend: 10 | - "HuskSync" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskTowns/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: HuskTowns Compatibility 2 | 3 | The HuskTowns compatibility expansion adds support for HuskTowns claims 4 | 5 | ## Requirements 6 | 7 | - [HuskTowns](https://github.com/WiIIiam278/HuskTowns) 8 | 9 | ## How to use? 10 | 11 | This expansion can prevent players from entering claimed areas. 12 | If a player is fighting another player, set the PVP flag to deny. 13 | If a player is fighting mobs, set the PVE flag to deny. 14 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskTowns/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.william278.net/releases/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("net.william278:husktowns:2.6.1") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskTowns/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatHuskTowns 2 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskTowns/src/main/java/combatlogx/expansion/compatibility/region/husktowns/HuskTownsExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.husktowns; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class HuskTownsExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public HuskTownsExpansion(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("HuskTowns", true, "2.6"); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerHuskTowns(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskTowns/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # How should CombatLogX prevent players from entering non-pvp areas? 2 | # Valid Modes: 3 | # DISABLED - Don't do anything, just let them in 4 | # KNOCKBACK_PLAYER - Add some opposite velocity to the player so they are pushed backwards 5 | # CANCEL_EVENT - Cancel the player's move event 6 | # VULNERABLE - Let the player in, but remove their pvp protection 7 | # KILL_PLAYER - Set the player's health to 0 8 | # TELEPORT_TO_ENEMY - Teleport the player to their enemy if they have one, or CANCEL if they don't have one. 9 | # Default: KNOCKBACK_PLAYER 10 | no-entry-mode: "KNOCKBACK_PLAYER" 11 | 12 | # This value is only used if 'no-entry-mode' is KNOCKBACK_PLAYER 13 | # How much should the backwards velocity be multiplied by? 14 | # Default: 1.5 15 | knockback-strength: 1.5 16 | 17 | # How much time (in seconds) should the plugin wait before sending another 'no-entry' message? 18 | # Default: 30 19 | message-cooldown: 30 20 | -------------------------------------------------------------------------------- /expansion/compatibility/HuskTowns/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.husktowns.HuskTownsExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "HuskTowns" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/IridiumSkyblock/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("net.iridiumdevelopment:IridiumSkyblock:4.1.0") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/IridiumSkyblock/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatIridiumSkyblock 2 | expansion.prefix=IridiumSkyblock Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/IridiumSkyblock/src/main/java/combatlogx/expansion/compatibility/iridium/skyblock/IridiumSkyblockExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.iridium.skyblock; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockHandler; 8 | 9 | public final class IridiumSkyblockExpansion extends SkyBlockExpansion { 10 | private SkyBlockHandler skyBlockHandler; 11 | 12 | public IridiumSkyblockExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.skyBlockHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("IridiumSkyblock", true, "4"); 20 | } 21 | 22 | @Override 23 | public @NotNull SkyBlockHandler getSkyBlockHandler() { 24 | if (this.skyBlockHandler == null) { 25 | this.skyBlockHandler = new SkyBlockHandlerIridium(this); 26 | } 27 | 28 | return this.skyBlockHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/IridiumSkyblock/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.iridium.skyblock.IridiumSkyblockExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "IridiumSkyblock" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/KingdomsX/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("com.github.cryptomorin:kingdoms:1.16.20.5") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/KingdomsX/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatKingdomsX 2 | expansion.prefix=KingdomsX Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/KingdomsX/src/main/java/combatlogx/expansion/compatibility/region/kingdomsx/ExpansionKingdomsX.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.kingdomsx; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class ExpansionKingdomsX extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public ExpansionKingdomsX(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("Kingdoms", true, "1."); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerKingdomsX(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/KingdomsX/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.kingdomsx.ExpansionKingdomsX" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "Kingdoms" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/Konquest/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("com.github.rumsfield:Konquest:1.9.0") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/Konquest/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatKonquest 2 | expansion.prefix=Konquest Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/Konquest/src/main/java/combatlogx/expansion/compatibility/region/konquest/KonquestExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.konquest; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class KonquestExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public KonquestExpansion(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("Konquest", true, "1"); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerKonquest(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/Konquest/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.konquest.KonquestExpansion" 6 | version: "17.5" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "Konquest" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/Lands/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-jitpack/") 3 | } 4 | 5 | dependencies { 6 | compileOnly(project(":expansion:newbie-helper")) 7 | compileOnly("com.github.angeschossen:LandsAPI:7.15.4") 8 | } 9 | -------------------------------------------------------------------------------- /expansion/compatibility/Lands/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatLands 2 | expansion.prefix=Lands Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/Lands/src/main/java/combatlogx/expansion/compatibility/region/lands/LandsConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.lands; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class LandsConfiguration implements IConfigurable { 10 | private boolean preventAllLandEntries; 11 | 12 | public LandsConfiguration() { 13 | this.preventAllLandEntries = false; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection section) { 18 | setPreventAllLandEntries(section.getBoolean("prevent-all-land-entries", false)); 19 | } 20 | 21 | public boolean isPreventAllLandEntries() { 22 | return this.preventAllLandEntries; 23 | } 24 | 25 | public void setPreventAllLandEntries(boolean preventAllLandEntries) { 26 | this.preventAllLandEntries = preventAllLandEntries; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/Lands/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.lands.LandsExpansion" 6 | version: "17.6" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "Lands" 11 | 12 | expansion-soft-depend: 13 | - "NewbieHelper" 14 | -------------------------------------------------------------------------------- /expansion/compatibility/Lands/src/main/resources/lands.yml: -------------------------------------------------------------------------------- 1 | # This option will prevent entry to ANY lands location owned by the player, regardless of PVP status 2 | # Default: false 3 | prevent-all-land-entries: false 4 | -------------------------------------------------------------------------------- /expansion/compatibility/LibsDisguises/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.md-5.net/content/groups/public/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("me.libraryaddict.disguises:libsdisguises:11.0.5") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/LibsDisguises/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatLibsDisguises 2 | expansion.prefix=LibsDisguises Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/LibsDisguises/src/main/java/combatlogx/expansion/compatibility/libsdisguises/DisguiseHandlerLibsDisguises.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.libsdisguises; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import com.github.sirblobman.combatlogx.api.expansion.disguise.DisguiseHandler; 8 | 9 | import me.libraryaddict.disguise.DisguiseAPI; 10 | 11 | public class DisguiseHandlerLibsDisguises extends DisguiseHandler { 12 | public DisguiseHandlerLibsDisguises(@NotNull LibsDisguisesExpansion expansion) { 13 | super(expansion); 14 | } 15 | 16 | @Override 17 | public boolean hasDisguise(@NotNull Player player) { 18 | return DisguiseAPI.isDisguised(player); 19 | } 20 | 21 | @Override 22 | public void removeDisguise(@NotNull Player player) { 23 | DisguiseAPI.undisguiseToAll(player); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /expansion/compatibility/LibsDisguises/src/main/java/combatlogx/expansion/compatibility/libsdisguises/LibsDisguisesExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.libsdisguises; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.disguise.DisguiseExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.disguise.DisguiseHandler; 8 | 9 | public final class LibsDisguisesExpansion extends DisguiseExpansion { 10 | private DisguiseHandler disguiseHandler; 11 | 12 | public LibsDisguisesExpansion(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.disguiseHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("LibsDisguises", true, "11"); 20 | } 21 | 22 | @Override 23 | public @NotNull DisguiseHandler getDisguiseHandler() { 24 | if (this.disguiseHandler == null) { 25 | this.disguiseHandler = new DisguiseHandlerLibsDisguises(this); 26 | } 27 | 28 | return this.disguiseHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/LibsDisguises/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.libsdisguises.LibsDisguisesExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "LibsDisguises" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/LuckPerms/README.MD: -------------------------------------------------------------------------------- 1 | # LuckPerms Compatibility Expansion 2 | 3 | This expansion adds custom contexts to LuckPerms. 4 | 5 | ## Contexts 6 | 7 | | Name | Type | Description | 8 | |-----------------------------|---------|--------------------------------------------------| 9 | | combatlogx-in-combat | boolean | true if the player is in combat. | 10 | | newbie-helper-pvp-protected | boolean | true if the player is protected as a new player. | 11 | | newbie-helper-pvp-status | boolean | true if the player has pvp enabled. | 12 | -------------------------------------------------------------------------------- /expansion/compatibility/LuckPerms/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("net.luckperms:api:5.4"); 3 | compileOnly(project(":expansion:newbie-helper")) 4 | } 5 | -------------------------------------------------------------------------------- /expansion/compatibility/LuckPerms/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatLuckPerms 2 | expansion.prefix=LuckPerms Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/LuckPerms/src/main/java/combatlogx/expansion/compatibility/luckperms/LuckPermsExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.luckperms; 2 | 3 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 4 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 5 | 6 | import combatlogx.expansion.compatibility.luckperms.context.ContextInCombat; 7 | import combatlogx.expansion.compatibility.luckperms.hook.HookNewbieHelper; 8 | 9 | public final class LuckPermsExpansion extends Expansion { 10 | public LuckPermsExpansion(ICombatLogX plugin) { 11 | super(plugin); 12 | } 13 | 14 | @Override 15 | public void onLoad() { 16 | // Do Nothing 17 | } 18 | 19 | @Override 20 | public void onEnable() { 21 | if (!checkDependency("LuckPerms", true, "5.4")) { 22 | selfDisable(); 23 | return; 24 | } 25 | 26 | registerContexts(); 27 | } 28 | 29 | @Override 30 | public void onDisable() { 31 | // Do Nothing 32 | } 33 | 34 | @Override 35 | public void reloadConfig() { 36 | // Do Nothing 37 | } 38 | 39 | private void registerContexts() { 40 | new ContextInCombat(this).register(); 41 | HookNewbieHelper.registerContexts(this); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /expansion/compatibility/LuckPerms/src/main/java/combatlogx/expansion/compatibility/luckperms/context/AbstractContext.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.luckperms.context; 2 | 3 | import com.github.sirblobman.api.utility.Validate; 4 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 5 | 6 | import combatlogx.expansion.compatibility.luckperms.LuckPermsExpansion; 7 | import net.luckperms.api.LuckPerms; 8 | import net.luckperms.api.LuckPermsProvider; 9 | import net.luckperms.api.context.ContextCalculator; 10 | import net.luckperms.api.context.ContextManager; 11 | 12 | public abstract class AbstractContext implements ContextCalculator { 13 | private final LuckPermsExpansion expansion; 14 | 15 | public AbstractContext(LuckPermsExpansion expansion) { 16 | this.expansion = Validate.notNull(expansion, "expansion must not be null!"); 17 | } 18 | 19 | protected final LuckPermsExpansion getExpansion() { 20 | return this.expansion; 21 | } 22 | 23 | protected final ICombatLogX getCombatLogX() { 24 | LuckPermsExpansion expansion = getExpansion(); 25 | return expansion.getPlugin(); 26 | } 27 | 28 | public final void register() { 29 | LuckPerms luckPerms = LuckPermsProvider.get(); 30 | ContextManager contextManager = luckPerms.getContextManager(); 31 | contextManager.registerCalculator(this); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /expansion/compatibility/LuckPerms/src/main/java/combatlogx/expansion/compatibility/luckperms/context/ContextInCombat.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.luckperms.context; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 8 | import com.github.sirblobman.combatlogx.api.manager.ICombatManager; 9 | 10 | import combatlogx.expansion.compatibility.luckperms.LuckPermsExpansion; 11 | import net.luckperms.api.context.ContextConsumer; 12 | 13 | public final class ContextInCombat extends AbstractContext { 14 | public ContextInCombat(LuckPermsExpansion expansion) { 15 | super(expansion); 16 | } 17 | 18 | @Override 19 | public void calculate(@NotNull Player target, ContextConsumer consumer) { 20 | ICombatLogX combatLogX = getCombatLogX(); 21 | ICombatManager combatManager = combatLogX.getCombatManager(); 22 | boolean combat = combatManager.isInCombat(target); 23 | consumer.accept("combatlogx-in-combat", Boolean.toString(combat)); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /expansion/compatibility/LuckPerms/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.luckperms.LuckPermsExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "LuckPerms" 11 | 12 | expansion-soft-depend: 13 | - "NewbieHelper" 14 | -------------------------------------------------------------------------------- /expansion/compatibility/MCPets/README.md: -------------------------------------------------------------------------------- 1 | # CombatLogX Compatibility Expansion: MCPets 2 | 3 | ## Requirements 4 | 5 | - [MythicMobs](https://www.spigotmc.org/resources/5702/) 6 | - [MCPets](https://www.spigotmc.org/resources/97628/) 7 | 8 | 9 | ## Features 10 | 11 | - Prevent players from spawning pets during combat. 12 | - Triggers active pet to despawn when a player is tagged. 13 | -------------------------------------------------------------------------------- /expansion/compatibility/MCPets/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("fr.nocsy:mcpets:4.1.4") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/MCPets/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatMCPets 2 | expansion.prefix=MCPets Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/MCPets/src/main/java/combatlogx/expansion/compatibility/mcpets/McPetsExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.mcpets; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 7 | 8 | public final class McPetsExpansion extends Expansion { 9 | public McPetsExpansion(@NotNull ICombatLogX plugin) { 10 | super(plugin); 11 | } 12 | 13 | @Override 14 | public void onLoad() { 15 | // Do Nothing 16 | } 17 | 18 | @Override 19 | public void onEnable() { 20 | if (!checkDependency("MCPets", true)) { 21 | selfDisable(); 22 | return; 23 | } 24 | 25 | new ListenerMcPets(this).register(); 26 | } 27 | 28 | @Override 29 | public void onDisable() { 30 | // Do Nothing 31 | } 32 | 33 | @Override 34 | public void reloadConfig() { 35 | // Do Nothing 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /expansion/compatibility/MCPets/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.mcpets.McPetsExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "MCPets" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/MarriageMaster/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("at.pcgamingfreaks:MarriageMaster:2.7.9") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/MarriageMaster/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatMarriageMaster 2 | expansion.prefix=MarriageMaster Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/MarriageMaster/src/main/java/combatlogx/expansion/compatibility/marriagemaster/MarriageMasterExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.marriagemaster; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 7 | 8 | import combatlogx.expansion.compatibility.marriagemaster.listener.ListenerMarriageMaster; 9 | 10 | public final class MarriageMasterExpansion extends Expansion { 11 | public MarriageMasterExpansion(@NotNull ICombatLogX plugin) { 12 | super(plugin); 13 | } 14 | 15 | @Override 16 | public void onLoad() { 17 | // Do Nothing 18 | } 19 | 20 | @Override 21 | public void onEnable() { 22 | if (!checkDependency("MarriageMaster", true)) { 23 | selfDisable(); 24 | return; 25 | } 26 | 27 | new ListenerMarriageMaster(this).register(); 28 | } 29 | 30 | @Override 31 | public void onDisable() { 32 | // Do Nothing 33 | } 34 | 35 | @Override 36 | public void reloadConfig() { 37 | // Do Nothing 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /expansion/compatibility/MarriageMaster/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.marriagemaster.MarriageMasterExpansion" 6 | version: "17.4" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "MarriageMaster" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/MythicMobs/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-lumine/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("io.lumine:Mythic-Dist:5.8.2") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/MythicMobs/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatMythicMobs 2 | expansion.prefix=MythicMobs Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/MythicMobs/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # This uses the internal name of the MythicMob 2 | # Add mobs to this list to prevent them from tagging players 3 | no-tag-mob-type-list: 4 | - "Example1" 5 | 6 | # This uses the internal name of the MythicMob 7 | # Add mobs to this list to force them to tag players. 8 | force-tag-mob-type-list: 9 | - "Example2" 10 | -------------------------------------------------------------------------------- /expansion/compatibility/MythicMobs/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.mythicmobs.MythicMobsExpansion" 6 | version: "17.6" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "MythicMobs" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/PlaceholderAPI/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.helpch.at/releases/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("me.clip:placeholderapi:2.11.6") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/PlaceholderAPI/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatPlaceholderAPI 2 | expansion.prefix=PlaceholderAPI Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/PlaceholderAPI/src/main/java/combatlogx/expansion/compatibility/placeholderapi/PlaceholderAPIExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.placeholderapi; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.Expansion; 7 | 8 | public final class PlaceholderAPIExpansion extends Expansion { 9 | public PlaceholderAPIExpansion(@NotNull ICombatLogX plugin) { 10 | super(plugin); 11 | } 12 | 13 | @Override 14 | public void onLoad() { 15 | // Do Nothing 16 | } 17 | 18 | @Override 19 | public void onEnable() { 20 | if (!checkDependency("PlaceholderAPI", true)) { 21 | selfDisable(); 22 | return; 23 | } 24 | 25 | new HookPlaceholderAPI(this).register(); 26 | } 27 | 28 | @Override 29 | public void onDisable() { 30 | // Do Nothing 31 | } 32 | 33 | @Override 34 | public void reloadConfig() { 35 | // Do Nothing 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /expansion/compatibility/PlaceholderAPI/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.placeholderapi.PlaceholderAPIExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "PlaceholderAPI" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/PlayerParticles/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.rosewooddev.io/repository/public-releases/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("dev.esophose:playerparticles:8.9") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/PlayerParticles/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatPlayerParticles 2 | expansion.prefix=PlayerParticles Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/PlayerParticles/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should CombatLogX disable player particles when a player is tagged? 2 | tag-disables-particles: true 3 | 4 | # Should CombatLogX enable player particles once combat is over? 5 | untag-enables-particles: false 6 | -------------------------------------------------------------------------------- /expansion/compatibility/PlayerParticles/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.player.particles.PlayerParticlesExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "PlayerParticles" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/PreciousStones/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://maven.elmakers.com/repository/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("net.sacredlabyrinth.Phaed:PreciousStones:15.0") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/PreciousStones/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatPreciousStones 2 | expansion.prefix=PreciousStones Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/PreciousStones/src/main/java/combatlogx/expansion/compatibility/region/preciousstones/PreciousStonesConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.preciousstones; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class PreciousStonesConfiguration implements IConfigurable { 10 | private boolean preventFieldCreation; 11 | 12 | public PreciousStonesConfiguration() { 13 | this.preventFieldCreation = true; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection config) { 18 | setPreventFieldCreation(config.getBoolean("prevent-field-creation", true)); 19 | } 20 | 21 | public boolean isPreventFieldCreation() { 22 | return this.preventFieldCreation; 23 | } 24 | 25 | public void setPreventFieldCreation(boolean preventFieldCreation) { 26 | this.preventFieldCreation = preventFieldCreation; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/PreciousStones/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.preciousstones.PreciousStonesExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "PreciousStones" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/ProtectionStones/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://maven.enginehub.org/repo/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("dev.espi:protectionstones:2.10.5") 7 | compileOnly("com.sk89q.worldguard:worldguard-core:7.1.0-SNAPSHOT") 8 | } 9 | -------------------------------------------------------------------------------- /expansion/compatibility/ProtectionStones/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatProtectionStones 2 | expansion.prefix=ProtectionStones Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/ProtectionStones/src/main/java/combatlogx/expansion/compatibility/region/protectionstones/ProtectionStonesConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.protectionstones; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class ProtectionStonesConfiguration implements IConfigurable { 10 | private boolean preventAreaCreation; 11 | 12 | public ProtectionStonesConfiguration() { 13 | this.preventAreaCreation = true; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection config) { 18 | setPreventAreaCreation(config.getBoolean("prevent-area-creation", true)); 19 | } 20 | 21 | public boolean isPreventAreaCreation() { 22 | return this.preventAreaCreation; 23 | } 24 | 25 | public void setPreventAreaCreation(boolean preventAreaCreation) { 26 | this.preventAreaCreation = preventAreaCreation; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/ProtectionStones/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.protectionstones.ProtectionStonesExpansion" 6 | version: "17.3" 7 | author: "olivolja3 (Olivo#3313)" 8 | 9 | plugin-depend: 10 | - "ProtectionStones" 11 | - "WorldGuard" 12 | -------------------------------------------------------------------------------- /expansion/compatibility/RedProtect/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("br.net.fabiozumbi12.RedProtect:RedProtect-Spigot:8.1.2") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/RedProtect/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatRedProtection 2 | expansion.prefix=RedProtect Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/RedProtect/src/main/java/combatlogx/expansion/compatibility/region/redprotect/RedProtectExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.redprotect; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class RedProtectExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public RedProtectExpansion(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("RedProtect", true); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerRedProtect(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/RedProtect/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.redprotect.RedProtectExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "RedProtect" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/Residence/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("net.zrips:Residence:5.1.7.5") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/Residence/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatResidence 2 | expansion.prefix=Residence Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/Residence/src/main/java/combatlogx/expansion/compatibility/region/residence/ResidenceExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.residence; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class ResidenceExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public ResidenceExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("Residence", false, "5.1"); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerResidence(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/Residence/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.residence.ResidenceExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "Residence" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperVanish/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-jitpack/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.github.LeonMangler:SuperVanish:6.2.20") { 7 | exclude("*", "*") 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperVanish/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatSuperVanish 2 | expansion.prefix=SuperVanish Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperVanish/src/main/java/combatlogx/expansion/compatibility/supervanish/SuperVanishExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.supervanish; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishHandler; 8 | 9 | public final class SuperVanishExpansion extends VanishExpansion { 10 | private VanishHandler vanishHandler; 11 | 12 | public SuperVanishExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.vanishHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | if (checkDependency("PremiumVanish", true)) { 20 | return true; 21 | } 22 | 23 | getLogger().info("Missing PremiumVanish, checking for regular SuperVanish..."); 24 | return checkDependency("SuperVanish", true); 25 | } 26 | 27 | @Override 28 | public @NotNull VanishHandler getVanishHandler() { 29 | if (this.vanishHandler == null) { 30 | this.vanishHandler = new VanishHandlerSuper(this); 31 | } 32 | 33 | return this.vanishHandler; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperVanish/src/main/java/combatlogx/expansion/compatibility/supervanish/VanishHandlerSuper.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.supervanish; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishHandler; 8 | 9 | import de.myzelyam.api.vanish.VanishAPI; 10 | 11 | public final class VanishHandlerSuper extends VanishHandler { 12 | public VanishHandlerSuper(@NotNull SuperVanishExpansion expansion) { 13 | super(expansion); 14 | } 15 | 16 | @Override 17 | public boolean isVanished(@NotNull Player player) { 18 | return VanishAPI.isInvisible(player); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperVanish/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should players in vanish be preventing from going into combat? 2 | prevent-vanish-tagging-self: true 3 | 4 | # Should players in vanish be unable to tag other players? 5 | prevent-vanish-tagging-other: true 6 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperVanish/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.supervanish.SuperVanishExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-soft-depend: 10 | - "PremiumVanish" 11 | - "SuperVanish" 12 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperiorSkyblock/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.bg-software.com/repository/api/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.bgsoftware:SuperiorSkyblockAPI:2025.1") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperiorSkyblock/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatSuperiorSkyblock 2 | expansion.prefix=SuperiorSkyblock Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperiorSkyblock/src/main/java/combatlogx/expansion/compatibility/superior/skyblock/SuperiorSkyblockExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.superior.skyblock; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockHandler; 8 | 9 | public final class SuperiorSkyblockExpansion extends SkyBlockExpansion { 10 | private SkyBlockHandler skyBlockHandler; 11 | 12 | public SuperiorSkyblockExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.skyBlockHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("SuperiorSkyblock2", true); 20 | } 21 | 22 | @Override 23 | public @NotNull SkyBlockHandler getSkyBlockHandler() { 24 | if (this.skyBlockHandler == null) { 25 | this.skyBlockHandler = new SkyBlockHandlerSuperior(this); 26 | } 27 | 28 | return this.skyBlockHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/SuperiorSkyblock/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.superior.skyblock.SuperiorSkyblockExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "SuperiorSkyblock2" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/Towny/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.glaremasters.me/repository/towny/") 3 | maven("https://nexus.sirblobman.xyz/proxy-jitpack/") 4 | } 5 | 6 | dependencies { 7 | compileOnly("com.palmergames.bukkit.towny:towny:0.101.1.0") 8 | compileOnly("com.github.TownyAdvanced:FlagWar:0.7.0") 9 | } 10 | -------------------------------------------------------------------------------- /expansion/compatibility/Towny/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatTowny 2 | expansion.prefix=Towny Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/Towny/src/main/java/combatlogx/expansion/compatibility/region/towny/TownyConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.towny; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class TownyConfiguration implements IConfigurable { 10 | private boolean preventAllTownEntries; 11 | 12 | public TownyConfiguration() { 13 | this.preventAllTownEntries = false; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection section) { 18 | setPreventAllTownEntries(section.getBoolean("prevent-all-town-entries", false)); 19 | } 20 | 21 | public boolean isPreventAllTownEntries() { 22 | return this.preventAllTownEntries; 23 | } 24 | 25 | public void setPreventAllTownEntries(boolean preventAllTownEntries) { 26 | this.preventAllTownEntries = preventAllTownEntries; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/Towny/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.towny.TownyExpansion" 6 | version: "17.7" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "Towny" 11 | 12 | plugin-soft-depend: 13 | - "FlagWar" 14 | -------------------------------------------------------------------------------- /expansion/compatibility/Towny/src/main/resources/towny.yml: -------------------------------------------------------------------------------- 1 | # This option will prevent entry to ANY town location owned by the player, regardless of PVP status 2 | # Default: false 3 | prevent-all-town-entries: false 4 | -------------------------------------------------------------------------------- /expansion/compatibility/UltimateClaims/build.gradle.kts: -------------------------------------------------------------------------------- 1 | dependencies { 2 | compileOnly("com.songoda:UltimateClaims:3.1.0") 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/UltimateClaims/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatUltimateClaims 2 | expansion.prefix=UltimateClaims Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/UltimateClaims/src/main/java/combatlogx/expansion/compatibility/region/ultimateclaims/UltimateClaimsExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.ultimateclaims; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.region.RegionHandler; 8 | 9 | public final class UltimateClaimsExpansion extends RegionExpansion { 10 | private RegionHandler regionHandler; 11 | 12 | public UltimateClaimsExpansion(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.regionHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("UltimateClaims", true, "3"); 20 | } 21 | 22 | @Override 23 | public @NotNull RegionHandler getRegionHandler() { 24 | if (this.regionHandler == null) { 25 | this.regionHandler = new RegionHandlerUltimateClaims(this); 26 | } 27 | 28 | return this.regionHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/UltimateClaims/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.ultimateclaims.UltimateClaimsExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "UltimateClaims" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/VanishNoPacket/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-jitpack/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.github.mbax:VanishNoPacket:3.22") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/VanishNoPacket/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatVanishNoPacket 2 | expansion.prefix=VanishNoPacket Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/VanishNoPacket/src/main/java/combatlogx/expansion/compatibility/vnp/VanishHandlerNoPacket.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.vnp; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.plugin.java.JavaPlugin; 7 | 8 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishHandler; 9 | 10 | import org.kitteh.vanish.VanishManager; 11 | import org.kitteh.vanish.VanishPlugin; 12 | 13 | public final class VanishHandlerNoPacket extends VanishHandler { 14 | public VanishHandlerNoPacket(@NotNull VanishNoPacketExpansion expansion) { 15 | super(expansion); 16 | } 17 | 18 | @Override 19 | public boolean isVanished(@NotNull Player player) { 20 | VanishManager vanishManager = getVanishManager(); 21 | return vanishManager.isVanished(player); 22 | } 23 | 24 | private @NotNull VanishPlugin getVanish() { 25 | return JavaPlugin.getPlugin(VanishPlugin.class); 26 | } 27 | 28 | private @NotNull VanishManager getVanishManager() { 29 | VanishPlugin plugin = getVanish(); 30 | return plugin.getManager(); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /expansion/compatibility/VanishNoPacket/src/main/java/combatlogx/expansion/compatibility/vnp/VanishNoPacketExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.vnp; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.vanish.VanishHandler; 8 | 9 | public final class VanishNoPacketExpansion extends VanishExpansion { 10 | private VanishHandler vanishHandler; 11 | 12 | public VanishNoPacketExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.vanishHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("VanishNoPacket", true, "3"); 20 | } 21 | 22 | @Override 23 | public @NotNull VanishHandler getVanishHandler() { 24 | if (this.vanishHandler == null) { 25 | this.vanishHandler = new VanishHandlerNoPacket(this); 26 | } 27 | 28 | return this.vanishHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/VanishNoPacket/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should players in vanish be preventing from going into combat? 2 | prevent-vanish-tagging-self: true 3 | 4 | # Should players in vanish be unable to tag other players? 5 | prevent-vanish-tagging-other: true 6 | -------------------------------------------------------------------------------- /expansion/compatibility/VanishNoPacket/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.vnp.VanishNoPacketExpansion" 6 | version: "17.0" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "VanishNoPacket" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/WorldGuard/build.gradle.kts: -------------------------------------------------------------------------------- 1 | import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar 2 | 3 | plugins { 4 | id("com.gradleup.shadow") version "8.3.6" 5 | } 6 | 7 | repositories { 8 | maven("https://repo.codemc.io/repository/maven-public/") 9 | } 10 | 11 | dependencies { 12 | // https://github.com/CodeMC/WorldGuardWrapper 13 | implementation("org.codemc.worldguardwrapper:worldguardwrapper:1.2.1-SNAPSHOT") 14 | } 15 | 16 | tasks { 17 | named("jar") { 18 | enabled = false 19 | } 20 | 21 | named("shadowJar") { 22 | val expansionName = findProperty("expansion.name") ?: "invalid" 23 | val expansionPrefix = findProperty("expansion.prefix") ?: expansionName 24 | archiveFileName.set("$expansionPrefix.jar") 25 | archiveClassifier.set(null as String?) 26 | 27 | val basePath = "combatlogx.expansion.compatibility.region.world.guard" 28 | relocate("org.codemc.worldguardwrapper", "$basePath.wrapper") 29 | } 30 | 31 | named("build") { 32 | dependsOn("shadowJar") 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /expansion/compatibility/WorldGuard/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=CompatWorldGuard 2 | expansion.prefix=WorldGuard Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/WorldGuard/src/main/java/combatlogx/expansion/compatibility/region/world/guard/WorldGuardConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.region.world.guard; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class WorldGuardConfiguration implements IConfigurable { 10 | private boolean usePvpFlag; 11 | 12 | public WorldGuardConfiguration() { 13 | this.usePvpFlag = false; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection section) { 18 | setUsePvpFlag(section.getBoolean("use-pvp-flag", true)); 19 | } 20 | 21 | public boolean isUsePvpFlag() { 22 | return usePvpFlag; 23 | } 24 | 25 | public void setUsePvpFlag(boolean usePvpFlag) { 26 | this.usePvpFlag = usePvpFlag; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/WorldGuard/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.region.world.guard.WorldGuardExpansion" 6 | version: "17.4" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "WorldGuard" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/WorldGuard/src/main/resources/worldguard.yml: -------------------------------------------------------------------------------- 1 | # CombatLogX adds its own flag to prevent entry (player-combat: DENY) 2 | # Set this option to true if 'pvp: DENY` flag should also prevent entry. 3 | use-pvp-flag: true 4 | -------------------------------------------------------------------------------- /expansion/compatibility/ZNPCsPlus/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.pyr.lol/snapshots") 3 | } 4 | 5 | dependencies { 6 | compileOnly("lol.pyr:znpcsplus-api:2.0.0-SNAPSHOT") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/ZNPCsPlus/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.8.8-R0.1-SNAPSHOT 2 | expansion.name=CompatZNPCsPlus 3 | expansion.prefix=ZNPCsPlus Compatibility 4 | -------------------------------------------------------------------------------- /expansion/compatibility/ZNPCsPlus/src/main/java/combatlogx/expansion/compatibility/znpc/configuration/Configuration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.znpc.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class Configuration implements IConfigurable { 10 | private boolean npcTagging; 11 | 12 | public Configuration() { 13 | this.npcTagging = false; 14 | } 15 | 16 | @Override 17 | public void load(@NotNull ConfigurationSection config) { 18 | setNpcTagging(config.getBoolean("npc-tagging", false)); 19 | } 20 | 21 | public boolean isNpcTagging() { 22 | return npcTagging; 23 | } 24 | 25 | public void setNpcTagging(boolean npcTagging) { 26 | this.npcTagging = npcTagging; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/ZNPCsPlus/src/main/java/combatlogx/expansion/compatibility/znpc/task/NpcRemoveTask.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.znpc.task; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.api.folia.details.TaskDetails; 6 | 7 | import combatlogx.expansion.compatibility.znpc.ZNPCExpansion; 8 | import lol.pyr.znpcsplus.api.NpcApiProvider; 9 | import lol.pyr.znpcsplus.api.npc.Npc; 10 | import lol.pyr.znpcsplus.api.npc.NpcRegistry; 11 | 12 | public final class NpcRemoveTask extends TaskDetails { 13 | private final Npc npc; 14 | 15 | public NpcRemoveTask(@NotNull ZNPCExpansion expansion, @NotNull Npc npc) { 16 | super(expansion.getPlugin().getPlugin()); 17 | this.npc = npc; 18 | } 19 | 20 | @Override 21 | public void run() { 22 | this.npc.setEnabled(false); 23 | 24 | NpcRegistry npcRegistry = NpcApiProvider.get().getNpcRegistry(); 25 | String npcId = npcRegistry.getByUuid(this.npc.getUuid()).getId(); 26 | npcRegistry.delete(npcId); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/compatibility/ZNPCsPlus/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should players be tagged by NPCs? 2 | # Default: false 3 | npc-tagging: false 4 | -------------------------------------------------------------------------------- /expansion/compatibility/ZNPCsPlus/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.znpc.ZNPCExpansion" 6 | version: "17.0.alpha.test" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "ZNPCsPlus" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/build.gradle.kts: -------------------------------------------------------------------------------- 1 | tasks.named("jar") { 2 | enabled = false 3 | } 4 | -------------------------------------------------------------------------------- /expansion/compatibility/iDisguise/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://www.robingrether.de/mc/repo/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("de.robingrether.idisguise:idisguise-core:5.8.2") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/iDisguise/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=Compat_iDisguise 2 | expansion.prefix=iDisguise Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/iDisguise/src/main/java/combatlogx/expansion/compatibility/idisguise/DisguiseHandler_iDisguise.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.idisguise; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import com.github.sirblobman.combatlogx.api.expansion.disguise.DisguiseHandler; 8 | 9 | import de.robingrether.idisguise.api.DisguiseAPI; 10 | import de.robingrether.idisguise.iDisguise; 11 | 12 | public final class DisguiseHandler_iDisguise extends DisguiseHandler { 13 | public DisguiseHandler_iDisguise(@NotNull Expansion_iDisguise expansion) { 14 | super(expansion); 15 | } 16 | 17 | @Override 18 | public boolean hasDisguise(@NotNull Player player) { 19 | DisguiseAPI api = getAPI(); 20 | return api.isDisguised(player); 21 | } 22 | 23 | @Override 24 | public void removeDisguise(@NotNull Player player) { 25 | DisguiseAPI api = getAPI(); 26 | api.undisguise(player); 27 | } 28 | 29 | private @NotNull DisguiseAPI getAPI() { 30 | iDisguise plugin = iDisguise.getInstance(); 31 | return plugin.getAPI(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /expansion/compatibility/iDisguise/src/main/java/combatlogx/expansion/compatibility/idisguise/Expansion_iDisguise.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.idisguise; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.disguise.DisguiseExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.disguise.DisguiseHandler; 8 | 9 | public final class Expansion_iDisguise extends DisguiseExpansion { 10 | private DisguiseHandler disguiseHandler; 11 | 12 | public Expansion_iDisguise(@NotNull ICombatLogX plugin) { 13 | super(plugin); 14 | this.disguiseHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("iDisguise", true, "5.8"); 20 | } 21 | 22 | @Override 23 | public @NotNull DisguiseHandler getDisguiseHandler() { 24 | if (this.disguiseHandler == null) { 25 | this.disguiseHandler = new DisguiseHandler_iDisguise(this); 26 | } 27 | 28 | return this.disguiseHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/iDisguise/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.idisguise.Expansion_iDisguise" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "iDisguise" 11 | -------------------------------------------------------------------------------- /expansion/compatibility/uSkyBlock/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-uskyblock/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.github.rlf:uSkyBlock-API:3.1.0") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/compatibility/uSkyBlock/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=Compat_uSkyBlock 2 | expansion.prefix=uSkyBlock Compatibility 3 | -------------------------------------------------------------------------------- /expansion/compatibility/uSkyBlock/src/main/java/combatlogx/expansion/compatibility/uskyblock/uSkyBlockExpansion.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.compatibility.uskyblock; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockExpansion; 7 | import com.github.sirblobman.combatlogx.api.expansion.skyblock.SkyBlockHandler; 8 | 9 | public final class uSkyBlockExpansion extends SkyBlockExpansion { 10 | private SkyBlockHandler skyBlockHandler; 11 | 12 | public uSkyBlockExpansion(ICombatLogX plugin) { 13 | super(plugin); 14 | this.skyBlockHandler = null; 15 | } 16 | 17 | @Override 18 | public boolean checkDependencies() { 19 | return checkDependency("uSkyBlock", true, "3"); 20 | } 21 | 22 | @Override 23 | public @NotNull SkyBlockHandler getSkyBlockHandler() { 24 | if (this.skyBlockHandler == null) { 25 | this.skyBlockHandler = new SkyBlockHandler_uSkyBlock(this); 26 | } 27 | 28 | return this.skyBlockHandler; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/compatibility/uSkyBlock/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.compatibility.uskyblock.uSkyBlockExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | 9 | plugin-depend: 10 | - "uSkyBlock" 11 | -------------------------------------------------------------------------------- /expansion/damage-effects/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Damage Effects 2 | 3 | The damage effects expansion creates particles every time a player is damaged. 4 | -------------------------------------------------------------------------------- /expansion/damage-effects/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.13.2-R0.1-SNAPSHOT 2 | expansion.name=DamageEffects 3 | expansion.prefix=Damage Effects 4 | -------------------------------------------------------------------------------- /expansion/damage-effects/src/main/java/combatlogx/expansion/damage/effects/DamageEffectsConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.damage.effects; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | import combatlogx.expansion.damage.effects.effect.Blood; 10 | 11 | public final class DamageEffectsConfiguration implements IConfigurable { 12 | private final Blood blood; 13 | private boolean allDamage; 14 | 15 | public DamageEffectsConfiguration() { 16 | this.allDamage = false; 17 | this.blood = new Blood(); 18 | } 19 | 20 | @Override 21 | public void load(@NotNull ConfigurationSection config) { 22 | setAllDamage(config.getBoolean("all-damage", false)); 23 | getBlood().load(getOrCreateSection(config, "blood")); 24 | } 25 | 26 | public boolean isAllDamage() { 27 | return this.allDamage; 28 | } 29 | 30 | public void setAllDamage(boolean allDamage) { 31 | this.allDamage = allDamage; 32 | } 33 | 34 | public @NotNull Blood getBlood() { 35 | return this.blood; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /expansion/damage-effects/src/main/java/combatlogx/expansion/damage/effects/effect/DamageEffect.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.damage.effects.effect; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | public interface DamageEffect { 8 | boolean isEnabled(); 9 | 10 | void play(@NotNull Player player); 11 | } 12 | -------------------------------------------------------------------------------- /expansion/damage-effects/src/main/java/combatlogx/expansion/damage/effects/effect/Offset.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.damage.effects.effect; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class Offset implements IConfigurable { 10 | private double x; 11 | private double y; 12 | private double z; 13 | 14 | public Offset() { 15 | this.x = 0.0D; 16 | this.y = 0.0D; 17 | this.z = 0.0D; 18 | } 19 | 20 | @Override 21 | public void load(@NotNull ConfigurationSection section) { 22 | setX(section.getDouble("x", 0.0D)); 23 | setY(section.getDouble("y", 0.0D)); 24 | setZ(section.getDouble("z", 0.0D)); 25 | } 26 | 27 | public double getX() { 28 | return this.x; 29 | } 30 | 31 | public void setX(double x) { 32 | this.x = x; 33 | } 34 | 35 | public double getY() { 36 | return this.y; 37 | } 38 | 39 | public void setY(double y) { 40 | this.y = y; 41 | } 42 | 43 | public double getZ() { 44 | return this.z; 45 | } 46 | 47 | public void setZ(double z) { 48 | this.z = z; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /expansion/damage-effects/src/main/resources/effects.yml: -------------------------------------------------------------------------------- 1 | # Set this to 'false' to only show for pvp damage. 2 | # Set this to 'true' to show particles for all entity damage. 3 | # Default: false 4 | all-damage: false 5 | 6 | blood: 7 | # Set this to 'true' to show the blood particles. 8 | # Default: true 9 | enabled: true 10 | 11 | # This is the location offset from the player's feet 12 | # Default: 0,0,0 13 | offset: 14 | x: 0 15 | y: 1.5 16 | z: 0 17 | 18 | # This is the color of the blood particles 19 | # Default: Full red (255, 0, 0) / #FF0000 20 | color: 21 | red: 255 22 | green: 0 23 | blue: 0 24 | 25 | # Particle size 26 | # Default: 1.0 27 | size: 1.0 28 | 29 | # Blood ring rate. 30 | # Default: 1.0 31 | ring-rate: 1.0 32 | 33 | # Blood ring radius. 34 | # Default: 1.0 35 | ring-radius: 1.0 36 | 37 | # Blood ring tube radius. 38 | # Default: 0.5 39 | ring-tube-radius: 0.5 40 | -------------------------------------------------------------------------------- /expansion/damage-effects/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.damage.effects.DamageEffectsExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/damage-tagger/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=DamageTagger 2 | expansion.prefix=Damage Tagger 3 | -------------------------------------------------------------------------------- /expansion/damage-tagger/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Set this to true if players should be tagged by all types of damage. 2 | # If this is true, damage-type settings will be ignored. 3 | # Default: true 4 | all-damage: true 5 | 6 | # Should CombatLogX tag players when they are blown up by end crystals? 7 | end-crystals: true 8 | 9 | # Should CombatLogX only use Damage Tagger when a player is already tagged by something else? 10 | retag-only: false 11 | 12 | # See the SpigotMC Documentation for descriptions. 13 | # https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/EntityDamageEvent.DamageCause.html 14 | damage-type: 15 | block-explosion: false 16 | contact: false 17 | cramming: false 18 | custom: false 19 | drowning: false 20 | dryout: false 21 | entity-explosion: false # Only triggered by end crystals. 22 | fall: false 23 | falling-block: false 24 | fire: false 25 | fire-tick: false 26 | fly-into-wall: false 27 | freeze: false 28 | hot-floor: false 29 | lava: false 30 | lightning: false 31 | magic: false 32 | melting: false 33 | poison: false 34 | starvation: false 35 | suffocation: false 36 | void: false 37 | wither: false 38 | world-border: false 39 | -------------------------------------------------------------------------------- /expansion/damage-tagger/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.damage.tagger.DamageTaggerExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/death-effects/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Death Effects 2 | 3 | The death effects expansion creates different effects when players die. You can configure these effects to trigger for 4 | combat-log deaths or for all deaths. 5 | 6 | ## Available Death Effects: 7 | 8 | | Effect | Description | 9 | |-----------------|----------------------------------------------------------------------------| 10 | | **LIGHTNING** | Spawn a lightning bolt. Configurable silence and effect-only values. | 11 | | **BLOOD** | Spawn redstone particles and a fake redstone dust block. Not configurable. | 12 | | **BLOOD_ITEMS** | Spawn items that can't be picked up. Configurable type and amount. | 13 | -------------------------------------------------------------------------------- /expansion/death-effects/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.13.2-R0.1-SNAPSHOT 2 | expansion.name=DeathEffects 3 | expansion.prefix=Death Effects 4 | -------------------------------------------------------------------------------- /expansion/death-effects/src/main/java/combatlogx/expansion/death/effects/task/ItemRemoveTask.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.death.effects.task; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Item; 6 | 7 | import com.github.sirblobman.api.folia.details.EntityTaskDetails; 8 | import com.github.sirblobman.api.plugin.ConfigurablePlugin; 9 | 10 | public final class ItemRemoveTask extends EntityTaskDetails { 11 | public ItemRemoveTask(@NotNull ConfigurablePlugin plugin, @NotNull Item entity) { 12 | super(plugin, entity); 13 | } 14 | 15 | @Override 16 | public void run() { 17 | Item entity = getEntity(); 18 | if (entity != null) { 19 | entity.remove(); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /expansion/death-effects/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should these effects apply only to logging out during combat, or to all deaths? 2 | # Default: true 3 | combat-death-only: true 4 | 5 | # Which death effects are enabled? 6 | # Available Effects can be found on the README page. 7 | # https://github.com/SirBlobman/CombatLogX/blob/main/expansion/death-effects/README.MD 8 | # Default: ALL 9 | death-effect-list: 10 | - BLOOD 11 | - LIGHTNING 12 | - BLOOD_ITEMS 13 | 14 | lightning: 15 | # Should the lightning only be a visual effect (no damage to nearby players or blocks)? 16 | # Default: true 17 | effect-only: true 18 | 19 | # Should the lightning be silent? 20 | # Lightning can be annoying to some players. 21 | # Default: true 22 | silent: true 23 | 24 | blood-items: 25 | # This is the type of item that will be dropped on the ground. 26 | # Use XMaterial names. 27 | # Default: RED_DYE 28 | material: RED_DYE 29 | 30 | # This is the amount of items that will be dropped on the ground. 31 | # Default: 10 32 | amount: 10 33 | 34 | # This is the amount of ticks that the items will exist. 35 | # Default: 100 (5 seconds) 36 | stay-ticks: 100 37 | -------------------------------------------------------------------------------- /expansion/death-effects/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.death.effects.DeathEffectsExpansion" 6 | version: "17.0" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/end-crystal/build.gradle.kts: -------------------------------------------------------------------------------- 1 | import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar 2 | 3 | plugins { 4 | id("com.gradleup.shadow") version "8.3.6" 5 | } 6 | 7 | dependencies { 8 | implementation(project(":expansion:end-crystal:legacy")) 9 | implementation(project(":expansion:end-crystal:modern")) 10 | implementation(project(":expansion:end-crystal:moderner")) 11 | } 12 | 13 | tasks { 14 | named("jar") { 15 | enabled = false 16 | } 17 | 18 | named("shadowJar") { 19 | val expansionName = findProperty("expansion.name") ?: "invalid" 20 | val expansionPrefix = findProperty("expansion.prefix") ?: expansionName 21 | archiveFileName.set("$expansionPrefix.jar") 22 | archiveClassifier.set(null as String?) 23 | } 24 | 25 | named("build") { 26 | dependsOn("shadowJar") 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /expansion/end-crystal/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=EndCrystalHelper 2 | expansion.prefix=End Crystal Helper 3 | version.spigot=1.8.8-R0.1-SNAPSHOT 4 | -------------------------------------------------------------------------------- /expansion/end-crystal/legacy/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.9.4-R0.1-SNAPSHOT 2 | -------------------------------------------------------------------------------- /expansion/end-crystal/modern/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.13.2-R0.1-SNAPSHOT 2 | -------------------------------------------------------------------------------- /expansion/end-crystal/moderner/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.20.6-R0.1-SNAPSHOT 2 | -------------------------------------------------------------------------------- /expansion/end-crystal/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.endcrystals.EndCrystalExpansion" 6 | version: "17.2" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/force-field/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Force Field 2 | 3 | The force field expansion shows a border around protected non-pvp areas. You must have at least one compatibility 4 | expansion to use the force field. 5 | 6 | ## Disclaimers: 7 | 8 | - The force field is a nice visual effect that shows players areas they cannot enter. 9 | - The force field should not be used as entry prevention, as players can just ignore the fake block packets that are 10 | sent to them. 11 | - For the actual entry prevention options, please check the configuration for your region expansion (e.g. WorldGuard 12 | Compatibility). 13 | - If your server has weak hardware, or you have a lot of players online, we recommend disabling the force field effect. 14 | - You can try unsafe mode and see if performance improves, but the most recommended option is to disable the force 15 | field. 16 | -------------------------------------------------------------------------------- /expansion/force-field/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-dmulloy2/") 3 | } 4 | 5 | dependencies { 6 | compileOnly("com.comphenix.protocol:ProtocolLib:5.3.0-SNAPSHOT") 7 | } 8 | -------------------------------------------------------------------------------- /expansion/force-field/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.13.2-R0.1-SNAPSHOT 2 | expansion.name=ForceField 3 | expansion.prefix=Force Field 4 | -------------------------------------------------------------------------------- /expansion/force-field/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.force.field.ForceFieldExpansion" 6 | version: "17.6" 7 | authors: 8 | - "olivolja3 (Olivo#3313)" 9 | - "SirBlobman" 10 | 11 | plugin-depend: 12 | - "ProtocolLib" 13 | -------------------------------------------------------------------------------- /expansion/glowing/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Glowing 2 | 3 | The glowing expansion makes players glow while they are in combat. 4 | 5 | ## Requirements 6 | 7 | - Spigot 1.9 and above. 8 | 9 | ## Features 10 | 11 | - Players will have a glowing effect during combat. 12 | - The glow effect will be removed once the player escapes. 13 | -------------------------------------------------------------------------------- /expansion/glowing/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.9.4-R0.1-SNAPSHOT 2 | expansion.name=Glowing 3 | -------------------------------------------------------------------------------- /expansion/glowing/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.glowing.GlowingExpansion" 6 | version: "17.0" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/logger/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Logger 2 | 3 | The logger expansion saves details about different combat events to files. 4 | 5 | ## Features 6 | 7 | - Change the name and format of the log files. 8 | - Configurable log message and date format. 9 | - Option to log every CombatLogX event and the EntityDamageByEntityEvent. 10 | -------------------------------------------------------------------------------- /expansion/logger/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=Logger 2 | -------------------------------------------------------------------------------- /expansion/logger/src/main/java/combatlogx/expansion/logger/configuration/LoggerConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.logger.configuration; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class LoggerConfiguration implements IConfigurable { 10 | private final LogFileInfo logFileInfo; 11 | private final LogOptions logOptions; 12 | private final LogEntryOptions logEntryOptions; 13 | 14 | public LoggerConfiguration() { 15 | this.logFileInfo = new LogFileInfo(); 16 | this.logOptions = new LogOptions(); 17 | this.logEntryOptions = new LogEntryOptions(); 18 | } 19 | 20 | @Override 21 | public void load(@NotNull ConfigurationSection config) { 22 | getLogFileInfo().load(getOrCreateSection(config, "log-file-info")); 23 | getLogOptions().load(getOrCreateSection(config, "log-options")); 24 | getLogEntryOptions().load(getOrCreateSection(config, "log-entry-options")); 25 | } 26 | 27 | public LogFileInfo getLogFileInfo() { 28 | return this.logFileInfo; 29 | } 30 | 31 | public LogOptions getLogOptions() { 32 | return this.logOptions; 33 | } 34 | 35 | public LogEntryOptions getLogEntryOptions() { 36 | return this.logEntryOptions; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /expansion/logger/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.logger.LoggerExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/loot-protection/build.gradle.kts: -------------------------------------------------------------------------------- 1 | import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar 2 | 3 | plugins { 4 | id("com.gradleup.shadow") version "8.3.6" 5 | } 6 | 7 | dependencies { 8 | implementation("net.jodah:expiringmap:0.5.11") 9 | } 10 | 11 | tasks { 12 | named("jar") { 13 | enabled = false 14 | } 15 | 16 | named("shadowJar") { 17 | val expansionName = findProperty("expansion.name") ?: project.name 18 | archiveFileName.set("$expansionName.jar") 19 | archiveClassifier.set(null as String?) 20 | 21 | relocate("net.jodah.expiringmap", "combatlogx.expansion.loot.protection.expiringmap") 22 | } 23 | 24 | named("build") { 25 | dependsOn("shadowJar") 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /expansion/loot-protection/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.16.5-R0.1-SNAPSHOT 2 | expansion.name=LootProtection 3 | expansion.prefix=Loot Protection 4 | -------------------------------------------------------------------------------- /expansion/loot-protection/src/main/java/combatlogx/expansion/loot/protection/event/QueryPickupEvent.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.loot.protection.event; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | import org.bukkit.event.HandlerList; 7 | 8 | import com.github.sirblobman.combatlogx.api.event.CustomPlayerEventCancellable; 9 | 10 | import combatlogx.expansion.loot.protection.object.ProtectedItem; 11 | 12 | public final class QueryPickupEvent extends CustomPlayerEventCancellable { 13 | private static final HandlerList HANDLER_LIST; 14 | 15 | static { 16 | HANDLER_LIST = new HandlerList(); 17 | } 18 | 19 | private final ProtectedItem protectedItem; 20 | 21 | public QueryPickupEvent(@NotNull Player player, @NotNull ProtectedItem protectedItem) { 22 | super(player); 23 | this.protectedItem = protectedItem; 24 | } 25 | 26 | public static @NotNull HandlerList getHandlerList() { 27 | return HANDLER_LIST; 28 | } 29 | 30 | @Override 31 | public @NotNull HandlerList getHandlers() { 32 | return getHandlerList(); 33 | } 34 | 35 | public @NotNull ProtectedItem getProtectedItem() { 36 | return protectedItem; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /expansion/loot-protection/src/main/java/combatlogx/expansion/loot/protection/object/ProtectedItem.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.loot.protection.object; 2 | 3 | import java.util.UUID; 4 | 5 | import org.bukkit.Location; 6 | import org.bukkit.inventory.ItemStack; 7 | 8 | import com.github.sirblobman.api.location.BlockLocation; 9 | import com.github.sirblobman.api.utility.Validate; 10 | 11 | public class ProtectedItem { 12 | private final BlockLocation location; 13 | private final ItemStack item; 14 | private UUID ownerUUID; 15 | private UUID itemUUID; 16 | 17 | public ProtectedItem(BlockLocation location, ItemStack item) { 18 | this.location = Validate.notNull(location, "location must not be null!"); 19 | this.item = Validate.notNull(item, "item must not be null!"); 20 | } 21 | 22 | public ProtectedItem(Location location, ItemStack item) { 23 | this(BlockLocation.from(location), item); 24 | } 25 | 26 | public ItemStack getItemStack() { 27 | return this.item; 28 | } 29 | 30 | public UUID getItemUUID() { 31 | return this.itemUUID; 32 | } 33 | 34 | public void setItemUUID(UUID itemUUID) { 35 | this.itemUUID = itemUUID; 36 | } 37 | 38 | public UUID getOwnerUUID() { 39 | return this.ownerUUID; 40 | } 41 | 42 | public void setOwnerUUID(UUID ownerUUID) { 43 | this.ownerUUID = ownerUUID; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /expansion/loot-protection/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # How long should items be protected after death? 2 | # Default: 30 (seconds) 3 | loot-protection-time: 30 4 | 5 | # How long should the expansion wait before sending the same message again? 6 | # Default: 30 (seconds) 7 | message-cooldown: 30 8 | 9 | # Should the expansion only protect items from people that have logged out during combat? 10 | # Default: false 11 | only-protect-after-log: false 12 | 13 | # Should the expansion add items to the killers inventory if the player dies in the void? 14 | # Default: true 15 | return-void-items: true 16 | -------------------------------------------------------------------------------- /expansion/loot-protection/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.loot.protection.LootProtectionExpansion" 6 | version: "17.1-debug2" 7 | author: "olivolja3 (Olivo#3313)" 8 | -------------------------------------------------------------------------------- /expansion/mob-tagger/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Mob Tagger 2 | 3 | The mob tagger expansion causes players to be tagged when they hit a mob or when a mob attacks them. 4 | 5 | ## Features 6 | 7 | - Allow mobs to tag players into combat. 8 | - Configurable list of mobs that can tag players. 9 | - Prevent certain types of mobs from tagging players. 10 | - Prevent mobs spawned for certain reasons from tagging players. (e.g. spawners) 11 | -------------------------------------------------------------------------------- /expansion/mob-tagger/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.14.4-R0.1-SNAPSHOT 2 | expansion.name=MobTagger 3 | expansion.prefix=Mob Tagger 4 | -------------------------------------------------------------------------------- /expansion/mob-tagger/src/main/java/combatlogx/expansion/mob/tagger/manager/ISpawnReasonManager.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.mob.tagger.manager; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Entity; 6 | import org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason; 7 | 8 | import combatlogx.expansion.mob.tagger.MobTaggerExpansion; 9 | 10 | public interface ISpawnReasonManager { 11 | @NotNull MobTaggerExpansion getExpansion(); 12 | 13 | @NotNull SpawnReason getSpawnReason(@NotNull Entity entity); 14 | 15 | void setSpawnReason(@NotNull Entity entity, @NotNull SpawnReason spawnReason); 16 | 17 | void clear(); 18 | } 19 | -------------------------------------------------------------------------------- /expansion/mob-tagger/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Information: 2 | # If you don't want mobs to tag players, remove this expansion 3 | 4 | # This is a list of mobs that should tag players. 5 | # Use "*" to allow all mob types 6 | # You can find a list of valid mob types on the Spigot javadocs: 7 | # https://hub.spigotmc.org/javadocs/spigot/org/bukkit/entity/EntityType.html 8 | mob-list: 9 | - "*" 10 | 11 | # Which spawn reasons prevent mobs from tagging players? 12 | # You can find a list of spawn reasons on the Spigot javadocs: 13 | # https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/CreatureSpawnEvent.SpawnReason.html 14 | spawn-reason-list: 15 | - SPAWNER 16 | 17 | # Players with this permission will not be tagged by any mobs. 18 | # Other forms of combat will still tag players. 19 | # The permission is not given to OPs by default, you must set it manually. 20 | bypass-permission: "combatlogx.bypass.mobs" -------------------------------------------------------------------------------- /expansion/mob-tagger/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.mob.tagger.MobTaggerExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/newbie-helper/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Newbie Helper 2 | 3 | The newbie helper expansion helps new players. 4 | 5 | ## Features 6 | 7 | - Prevent new players from being attacked for a configurable amount of time. 8 | - Remove protection from newbies when they attack someone. 9 | - Toggle your own ability to PVP. 10 | - (Admin Only) Force a certain player to have pvp enabled/disabled. 11 | 12 | ## Commands 13 | 14 | - **/togglepvp:** 15 | - **Aliases:** `pvptoggle`, `pvp` 16 | - **/togglepvp check \:** Check the PVP status of a player. 17 | - **/togglepvp on/off:** Enable or disable your ability to pvp. 18 | - **/togglepvp admin on/off \:** Enable or disable the pvp of another player by force. 19 | 20 | ## Permissions 21 | 22 | - **combatlogx.command.togglepvp:** Allows access to the `/togglepvp` command. 23 | - **combatlogx.command.togglepvp.admin:** Allows access to the `/togglepvp admin` command. 24 | -------------------------------------------------------------------------------- /expansion/newbie-helper/build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | id("maven-publish") 3 | } 4 | 5 | java { 6 | withSourcesJar() 7 | withJavadocJar() 8 | } 9 | 10 | publishing { 11 | repositories { 12 | maven("https://nexus.sirblobman.xyz/public/") { 13 | credentials { 14 | username = rootProject.ext.get("mavenUsername") as String 15 | password = rootProject.ext.get("mavenPassword") as String 16 | } 17 | } 18 | } 19 | 20 | publications { 21 | create("maven") { 22 | groupId = "com.github.sirblobman.combatlogx.expansion" 23 | artifactId = "newbie-helper" 24 | version = rootProject.ext.get("apiVersion") as String 25 | from(components["java"]) 26 | } 27 | } 28 | } 29 | 30 | tasks.withType { 31 | val standardOptions = (options as StandardJavadocDocletOptions) 32 | standardOptions.addStringOption("Xdoclint:none", "-quiet") 33 | } 34 | -------------------------------------------------------------------------------- /expansion/newbie-helper/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=NewbieHelper 2 | expansion.prefix=Newbie Helper 3 | -------------------------------------------------------------------------------- /expansion/newbie-helper/src/main/java/combatlogx/expansion/newbie/helper/command/admin/SubCommandAdmin.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.newbie.helper.command.admin; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.command.CombatLogCommand; 6 | 7 | import combatlogx.expansion.newbie.helper.NewbieHelperExpansion; 8 | 9 | public final class SubCommandAdmin extends CombatLogCommand { 10 | public SubCommandAdmin(@NotNull NewbieHelperExpansion expansion) { 11 | super(expansion.getPlugin(), "admin"); 12 | setPermissionName("combatlogx.command.togglepvp.admin"); 13 | addSubCommand(new SubCommandAdminOn(expansion)); 14 | addSubCommand(new SubCommandAdminOff(expansion)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /expansion/newbie-helper/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # Should new players be protected from attacks by other players? 2 | # Default: true 3 | new-player-protection: true 4 | 5 | # Should new player protection be removed from a player if they attack someone? 6 | # Default: true 7 | remove-protection-on-attack: true 8 | 9 | # How long does protection last on a player (in milliseconds)? 10 | # Default: 30,000 (30 seconds) 11 | protection-time: 30000 12 | 13 | # Should new players also be protected from mob attacks? 14 | # Default: true 15 | mob-protection: false 16 | 17 | # (This is for the `/togglepvp` command, protection options are above.) 18 | # What is the default PVP status for players? 19 | # Default: true (PVP allowed) 20 | pvp-toggle-default-status: true 21 | 22 | # How long (in seconds) must players wait before using the pvp toggle command again? 23 | # Default: 0 (no cooldown) 24 | pvp-toggle-cooldown: 0 25 | 26 | # What permission is required to bypass the pvp toggle cooldown? 27 | # Set this to "" to disable the bypass permission. 28 | # Default: "combatlogx.bypass.pvp-toggle.cooldown" 29 | pvp-toggle-cooldown-bypass-permission: "combatlogx.bypass.pvp-toggle.cooldown" 30 | 31 | # Should the expansion prevent non-admin pvp-toggle from being used 32 | # in worlds that are disabled in the main config? 33 | # Default: true 34 | prevent-pvp-toggle-in-disabled-worlds: true 35 | -------------------------------------------------------------------------------- /expansion/newbie-helper/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.newbie.helper.NewbieHelperExpansion" 6 | version: "17.3" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/newbie-helper/src/main/resources/worlds.yml: -------------------------------------------------------------------------------- 1 | # This is a list of worlds that will ignore the pvp toggle and newbie protection 2 | # and allow PVP at all times. 3 | forced-pvp-world-list: 4 | - "pvp" 5 | - "arena" 6 | 7 | # This is a list of worlds that will ignore the pvp toggle and newbie protection 8 | # and deny PVP at all times; 9 | no-pvp-world-list: 10 | - "no_pvp" 11 | - "peaceful" 12 | -------------------------------------------------------------------------------- /expansion/rewards/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Rewards 2 | 3 | The rewards expansion runs commands whenever a player kills a mob or another player. 4 | 5 | ## Features 6 | 7 | - Custom rewards 8 | - Enabled/Disabled worlds per reward. 9 | - Specific entity types per reward. 10 | - Chance based rewards. 11 | - Rewards with custom requirements: 12 | - Vault Economy Balance 13 | - *More coming soon...* 14 | -------------------------------------------------------------------------------- /expansion/rewards/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://nexus.sirblobman.xyz/proxy-jitpack/") 3 | maven("https://repo.helpch.at/releases/") 4 | } 5 | 6 | dependencies { 7 | compileOnly("com.github.MilkBowl:VaultAPI:1.7.1") 8 | compileOnly("me.clip:placeholderapi:2.11.6") 9 | } 10 | -------------------------------------------------------------------------------- /expansion/rewards/gradle.properties: -------------------------------------------------------------------------------- 1 | expansion.name=Rewards 2 | -------------------------------------------------------------------------------- /expansion/rewards/src/main/java/combatlogx/expansion/rewards/configuration/requirement/EconomyRequirement.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.rewards.configuration.requirement; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import combatlogx.expansion.rewards.RewardExpansion; 8 | import combatlogx.expansion.rewards.hook.HookVault; 9 | import net.milkbowl.vault.economy.Economy; 10 | 11 | public final class EconomyRequirement extends Requirement { 12 | private double amount; 13 | 14 | public EconomyRequirement(@NotNull RewardExpansion expansion, @NotNull String id) { 15 | super(expansion, id); 16 | this.amount = 1.0D; 17 | } 18 | 19 | public double getAmount() { 20 | return this.amount; 21 | } 22 | 23 | public void setAmount(double amount) { 24 | this.amount = amount; 25 | } 26 | 27 | @Override 28 | public boolean meetsRequirement(@NotNull Player player) { 29 | RewardExpansion expansion = getExpansion(); 30 | HookVault vaultHook = expansion.getVaultHook(); 31 | Economy economyHandler = vaultHook.getEconomyHandler(); 32 | if (economyHandler == null) { 33 | return false; 34 | } 35 | 36 | double balance = economyHandler.getBalance(player); 37 | double amount = getAmount(); 38 | return (balance >= amount); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /expansion/rewards/src/main/java/combatlogx/expansion/rewards/configuration/requirement/ExperienceRequirement.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.rewards.configuration.requirement; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | import org.bukkit.entity.Player; 7 | 8 | import com.github.sirblobman.api.utility.ExperienceUtility; 9 | 10 | import combatlogx.expansion.rewards.RewardExpansion; 11 | 12 | public final class ExperienceRequirement extends Requirement { 13 | private int amount; 14 | 15 | public ExperienceRequirement(@NotNull RewardExpansion expansion, @NotNull String id) { 16 | super(expansion, id); 17 | this.amount = 1; 18 | } 19 | 20 | @Override 21 | public void load(@NotNull ConfigurationSection section) { 22 | super.load(section); 23 | setAmount(section.getInt("amount", 1)); 24 | } 25 | 26 | public int getAmount() { 27 | return this.amount; 28 | } 29 | 30 | public void setAmount(int amount) { 31 | this.amount = amount; 32 | } 33 | 34 | @Override 35 | public boolean meetsRequirement(@NotNull Player player) { 36 | int amount = getAmount(); 37 | int balance = ExperienceUtility.getExp(player); 38 | return (balance >= amount); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /expansion/rewards/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.rewards.RewardExpansion" 6 | version: "17.6" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /expansion/scoreboard/README.MD: -------------------------------------------------------------------------------- 1 | # CombatLogX Expansion: Scoreboard 2 | 3 | The scoreboard expansion shows a scoreboard to every player that is in combat. 4 | 5 | ## Features 6 | 7 | - Customizable title and lines 8 | - Lines update without flickering 9 | 10 | ## Commands 11 | 12 | - **/combatlogx toggle:** 13 | - **/combatlogx toggle scoreboard:** Enable or disable your scoreboard display. 14 | -------------------------------------------------------------------------------- /expansion/scoreboard/build.gradle.kts: -------------------------------------------------------------------------------- 1 | repositories { 2 | maven("https://repo.papermc.io/repository/maven-public/") 3 | } 4 | 5 | dependencies { 6 | val spigotVersion = property("version.spigot") as String 7 | compileOnly("com.destroystokyo.paper:paper-api:$spigotVersion") 8 | } 9 | -------------------------------------------------------------------------------- /expansion/scoreboard/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.16.5-R0.1-SNAPSHOT 2 | expansion.name=Scoreboard 3 | -------------------------------------------------------------------------------- /expansion/scoreboard/src/main/java/combatlogx/expansion/scoreboard/ScoreboardConfiguration.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.scoreboard; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.configuration.ConfigurationSection; 6 | 7 | import com.github.sirblobman.api.configuration.IConfigurable; 8 | 9 | public final class ScoreboardConfiguration implements IConfigurable { 10 | private boolean enabled; 11 | private boolean savePrevious; 12 | 13 | public ScoreboardConfiguration() { 14 | setEnabled(true); 15 | setSavePrevious(true); 16 | } 17 | 18 | @Override 19 | public void load(@NotNull ConfigurationSection config) { 20 | setEnabled(config.getBoolean("enabled", true)); 21 | setSavePrevious(config.getBoolean("save-previous", true)); 22 | } 23 | 24 | public boolean isEnabled() { 25 | return enabled; 26 | } 27 | 28 | public void setEnabled(boolean enabled) { 29 | this.enabled = enabled; 30 | } 31 | 32 | public boolean isSavePrevious() { 33 | return savePrevious; 34 | } 35 | 36 | public void setSavePrevious(boolean savePrevious) { 37 | this.savePrevious = savePrevious; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /expansion/scoreboard/src/main/java/combatlogx/expansion/scoreboard/ScoreboardUpdater.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.scoreboard; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import com.github.sirblobman.combatlogx.api.object.TimerUpdater; 8 | 9 | import combatlogx.expansion.scoreboard.manager.CustomScoreboardManager; 10 | 11 | public final class ScoreboardUpdater implements TimerUpdater { 12 | private final ScoreboardExpansion expansion; 13 | 14 | public ScoreboardUpdater(@NotNull ScoreboardExpansion expansion) { 15 | this.expansion = expansion; 16 | } 17 | 18 | @Override 19 | public void update(@NotNull Player player, long timeLeftMillis) { 20 | CustomScoreboardManager scoreboardManager = getScoreboardManager(); 21 | scoreboardManager.updateScoreboard(player); 22 | } 23 | 24 | @Override 25 | public void remove(@NotNull Player player) { 26 | CustomScoreboardManager scoreboardManager = getScoreboardManager(); 27 | scoreboardManager.removeScoreboard(player); 28 | } 29 | 30 | private @NotNull CustomScoreboardManager getScoreboardManager() { 31 | return this.expansion.getScoreboardManager(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /expansion/scoreboard/src/main/java/combatlogx/expansion/scoreboard/scoreboard/CustomLine.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.scoreboard.scoreboard; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.ChatColor; 6 | import org.bukkit.scoreboard.Team; 7 | 8 | public final class CustomLine { 9 | private final ChatColor color; 10 | private final Team team; 11 | private final int line; 12 | 13 | public CustomLine(@NotNull ChatColor color, @NotNull Team team, int line) { 14 | this.color = color; 15 | this.team = team; 16 | this.line = line; 17 | } 18 | 19 | public @NotNull ChatColor getColor() { 20 | return this.color; 21 | } 22 | 23 | public @NotNull Team getTeam() { 24 | return this.team; 25 | } 26 | 27 | public int getLine() { 28 | return this.line; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /expansion/scoreboard/src/main/java/combatlogx/expansion/scoreboard/scoreboard/PaperScoreboard.java: -------------------------------------------------------------------------------- 1 | package combatlogx.expansion.scoreboard.scoreboard; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.scoreboard.Objective; 6 | import org.bukkit.scoreboard.Team; 7 | 8 | import com.github.sirblobman.api.utility.paper.ComponentConverter; 9 | import com.github.sirblobman.api.shaded.adventure.text.Component; 10 | 11 | public final class PaperScoreboard { 12 | public static void setTitle(@NotNull Objective objective, @NotNull Component shadedComponent) { 13 | net.kyori.adventure.text.Component normalComponent = ComponentConverter.shadedToNormal(shadedComponent); 14 | objective.displayName(normalComponent); 15 | } 16 | 17 | public static void setLine(@NotNull CustomLine customLine, @NotNull Component shadedComponent) { 18 | net.kyori.adventure.text.Component prefix = ComponentConverter.shadedToNormal(shadedComponent); 19 | net.kyori.adventure.text.Component suffix = net.kyori.adventure.text.Component.empty(); 20 | 21 | Team team = customLine.getTeam(); 22 | team.prefix(prefix); 23 | team.suffix(suffix); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /expansion/scoreboard/src/main/resources/config.yml: -------------------------------------------------------------------------------- 1 | # This option is here to quickly toggle this expansion on a live server that must stay online. 2 | # We recommend that you remove the Scoreboard expansion jar if you will not use the feature. 3 | enabled: true 4 | 5 | # Set this to true to save the scoreboard the player had before combat. 6 | # Otherwise, the main server scoreboard will be restored instead. 7 | save-previous: true 8 | 9 | ## Reminder: 10 | ## The scoreboard title format and list of lines are in your selected language file 11 | ## (Default: en_us.lang.yml) 12 | -------------------------------------------------------------------------------- /expansion/scoreboard/src/main/resources/expansion.yml: -------------------------------------------------------------------------------- 1 | name: "${expansionName}" 2 | prefix: "${expansionPrefix}" 3 | description: "${expansionDescription}" 4 | 5 | main: "combatlogx.expansion.scoreboard.ScoreboardExpansion" 6 | version: "17.1" 7 | author: "SirBlobman" 8 | -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | org.gradle.java.installations.fromEnv=JDK17 2 | org.gradle.parallel=true 3 | org.gradle.caching=true 4 | version.spigot=1.8.8-R0.1-SNAPSHOT 5 | version.core=2.9-SNAPSHOT 6 | version.api=11.6-SNAPSHOT 7 | version.base=11.6.0.0 8 | version.beta=false 9 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SirBlobman/CombatLogX/109541c72cdcfabae2a000e2b1a4a869ade8a78e/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip 4 | networkTimeout=10000 5 | validateDistributionUrl=true 6 | zipStoreBase=GRADLE_USER_HOME 7 | zipStorePath=wrapper/dists 8 | -------------------------------------------------------------------------------- /plugin/gradle.properties: -------------------------------------------------------------------------------- 1 | version.spigot=1.13.2-R0.1-SNAPSHOT 2 | bukkit.plugin.name=CombatLogX 3 | bukkit.plugin.prefix=CombatLogX 4 | bukkit.plugin.description=A modular combat tagging plugin. 5 | bukkit.plugin.website=https://www.spigotmc.org/resources/31689/ 6 | bukkit.plugin.main=com.github.sirblobman.combatlogx.CombatPlugin 7 | -------------------------------------------------------------------------------- /plugin/src/main/java/com/github/sirblobman/combatlogx/command/CommandTogglePVP.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.command; 2 | 3 | import java.util.Collections; 4 | import java.util.List; 5 | 6 | import org.jetbrains.annotations.NotNull; 7 | 8 | import org.bukkit.command.CommandSender; 9 | 10 | import com.github.sirblobman.api.language.replacer.Replacer; 11 | import com.github.sirblobman.api.language.replacer.StringReplacer; 12 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 13 | import com.github.sirblobman.combatlogx.api.command.CombatLogCommand; 14 | 15 | public final class CommandTogglePVP extends CombatLogCommand { 16 | public CommandTogglePVP(@NotNull ICombatLogX plugin) { 17 | super(plugin, "togglepvp"); 18 | setPermissionName("combatlogx.command.togglepvp"); 19 | } 20 | 21 | @Override 22 | protected @NotNull List onTabComplete(@NotNull CommandSender sender, String @NotNull [] args) { 23 | return Collections.emptyList(); 24 | } 25 | 26 | @Override 27 | protected boolean execute(@NotNull CommandSender sender, String @NotNull [] args) { 28 | Replacer replacer = new StringReplacer("{value}", "Newbie Helper"); 29 | sendMessageWithPrefix(sender, "error.unknown-expansion", replacer); 30 | return true; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /plugin/src/main/java/com/github/sirblobman/combatlogx/command/combatlogx/CommandCombatLogX.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.command.combatlogx; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.command.CombatLogCommand; 7 | import com.github.sirblobman.combatlogx.command.combatlogx.forgive.SubCommandForgive; 8 | 9 | public final class CommandCombatLogX extends CombatLogCommand { 10 | public CommandCombatLogX(@NotNull ICombatLogX plugin) { 11 | super(plugin, "combatlogx"); 12 | setPermissionName("combatlogx.command.combatlogx"); 13 | 14 | addSubCommand(new SubCommandAbout(plugin)); 15 | addSubCommand(new SubCommandForgive(plugin)); 16 | addSubCommand(new SubCommandHelp(plugin)); 17 | addSubCommand(new SubCommandReload(plugin)); 18 | addSubCommand(new SubCommandTag(plugin)); 19 | addSubCommand(new SubCommandToggle(plugin)); 20 | addSubCommand(new SubCommandUntag(plugin)); 21 | addSubCommand(new SubCommandVersion(plugin)); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /plugin/src/main/java/com/github/sirblobman/combatlogx/command/combatlogx/SubCommandHelp.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.command.combatlogx; 2 | 3 | import java.util.List; 4 | 5 | import org.jetbrains.annotations.NotNull; 6 | 7 | import org.bukkit.command.CommandSender; 8 | 9 | import com.github.sirblobman.api.language.LanguageManager; 10 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 11 | import com.github.sirblobman.combatlogx.api.command.CombatLogCommand; 12 | import com.github.sirblobman.api.shaded.adventure.text.Component; 13 | 14 | public final class SubCommandHelp extends CombatLogCommand { 15 | public SubCommandHelp(@NotNull ICombatLogX plugin) { 16 | super(plugin, "help"); 17 | setPermissionName("combatlogx.command.combatlogx.help"); 18 | } 19 | 20 | @Override 21 | protected boolean execute(@NotNull CommandSender sender, String @NotNull [] args) { 22 | LanguageManager languageManager = getLanguageManager(); 23 | String messageKey = "command.combatlogx.help-message-list"; 24 | 25 | List messageList = languageManager.getMessageList(sender, messageKey); 26 | for (Component message : messageList) { 27 | languageManager.sendMessage(sender, message); 28 | } 29 | 30 | return true; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /plugin/src/main/java/com/github/sirblobman/combatlogx/command/combatlogx/SubCommandReload.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.command.combatlogx; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.command.CommandSender; 6 | 7 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 8 | import com.github.sirblobman.combatlogx.api.command.CombatLogCommand; 9 | 10 | public final class SubCommandReload extends CombatLogCommand { 11 | public SubCommandReload(@NotNull ICombatLogX plugin) { 12 | super(plugin, "reload"); 13 | setPermissionName("combatlogx.command.combatlogx.reload"); 14 | } 15 | 16 | @Override 17 | protected boolean execute(@NotNull CommandSender sender, String @NotNull [] args) { 18 | try { 19 | ICombatLogX plugin = getCombatLogX(); 20 | plugin.onReload(); 21 | 22 | sendMessageWithPrefix(sender, "command.combatlogx.reload-success"); 23 | return true; 24 | } catch (Exception ex) { 25 | ex.printStackTrace(); 26 | sendMessageWithPrefix(sender, "command.combatlogx.reload-failure"); 27 | return true; 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /plugin/src/main/java/com/github/sirblobman/combatlogx/command/combatlogx/forgive/SubCommandForgive.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.command.combatlogx.forgive; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 6 | import com.github.sirblobman.combatlogx.api.command.CombatLogPlayerCommand; 7 | 8 | public final class SubCommandForgive extends CombatLogPlayerCommand { 9 | public SubCommandForgive(@NotNull ICombatLogX plugin) { 10 | super(plugin, "forgive"); 11 | setPermissionName("combatlogx.command.combatlogx.forgive"); 12 | addSubCommand(new SubCommandForgiveAccept(plugin)); 13 | addSubCommand(new SubCommandForgiveReject(plugin)); 14 | addSubCommand(new SubCommandForgiveRequest(plugin)); 15 | addSubCommand(new SubCommandForgiveToggle(plugin)); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /plugin/src/main/java/com/github/sirblobman/combatlogx/manager/Manager.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.manager; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import com.github.sirblobman.api.configuration.PlayerDataManager; 6 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 7 | import com.github.sirblobman.combatlogx.api.ICombatLogXNeeded; 8 | 9 | public abstract class Manager implements ICombatLogXNeeded { 10 | private final ICombatLogX plugin; 11 | 12 | public Manager(@NotNull ICombatLogX plugin) { 13 | this.plugin = plugin; 14 | } 15 | 16 | @Override 17 | public final @NotNull ICombatLogX getCombatLogX() { 18 | return this.plugin; 19 | } 20 | 21 | protected final @NotNull PlayerDataManager getPlayerDataManager() { 22 | ICombatLogX plugin = getCombatLogX(); 23 | return plugin.getPlayerDataManager(); 24 | } 25 | 26 | protected final void printDebug(String @NotNull ... messages) { 27 | ICombatLogX plugin = getCombatLogX(); 28 | plugin.printDebug(messages); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /plugin/src/main/java/com/github/sirblobman/combatlogx/task/PlayerVulnerableTask.java: -------------------------------------------------------------------------------- 1 | package com.github.sirblobman.combatlogx.task; 2 | 3 | import org.jetbrains.annotations.NotNull; 4 | 5 | import org.bukkit.entity.Player; 6 | 7 | import com.github.sirblobman.api.folia.details.EntityTaskDetails; 8 | import com.github.sirblobman.combatlogx.api.ICombatLogX; 9 | 10 | public final class PlayerVulnerableTask extends EntityTaskDetails { 11 | public PlayerVulnerableTask(@NotNull ICombatLogX plugin, @NotNull Player entity) { 12 | super(plugin.getPlugin(), entity); 13 | } 14 | 15 | @Override 16 | public void run() { 17 | Player entity = getEntity(); 18 | if (entity != null) { 19 | entity.setNoDamageTicks(0); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /plugin/src/main/resources/language.yml: -------------------------------------------------------------------------------- 1 | # CombatLogX Language Configuration 2 | # This plugin supports per-player language messages in 1.12.2+ 3 | 4 | # Force all players to use the 'default-locale', even when they have set a different language in their client. 5 | # This option also makes the 'console-locale' option useless. 6 | enforce-default-locale: false 7 | 8 | # This is the default language that will be shown to players when their language is not detected. 9 | # Player language can fail to detect if the file does not exist or if your Spigot jar does not support locales. 10 | default-locale: "en_us" 11 | 12 | # This is the language that will be used for messages sent to the server console. 13 | console-locale: "en_us" 14 | 15 | # Set this to true if you want language messages to include PlaceholderAPI placeholders. 16 | # The placeholder will be replaced relative to the player that the message is sent to. 17 | # If the message is sent to a non-player, the placeholders will not be replaced. 18 | use-placeholder-api: false 19 | --------------------------------------------------------------------------------