Update all dependencies

.gitattributes

@@ -4,5 +4,4 @@
 gradlew text eol=lf
 *.bat text eol=crlf
 
-*.jar binary
-.gitea/CODEOWNERS linguist-detectable=false
+*.jar binary

.gitea/CODEOWNERS

@@ -1,3 +0,0 @@
-# Pull requests request review from the eligible staff team(s).
-# One approval from either an Admin or Developer satisfies branch protection.
-*   @trueog/Admins @trueog/Developers

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+* @EternalCodeTeam/eternalcodeteam-maintainers
+/.github/CODEOWNERS @EternalCodeTeam/eternalcodeteam-maintainers

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+https://discord.gg/FQ7jmGBd6c.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

.github/CONTRIBUTING.md

@@ -0,0 +1,36 @@
+# Contributing to EternalCombat
+
+We welcome all contributions to the EternalCombat project!
+
+### How to Contribute
+
+1. Fork the repository.
+2. Create a new branch for your feature or bug fix.
+3. Make your changes, and test them thoroughly.
+4. Commit your changes and push them to your fork.
+5. Submit a pull request to the main repository.
+
+### Code of Conduct
+
+We expect all contributors to follow our [code of conduct](CODE_OF_CONDUCT.md).
+
+### Reporting Issues
+
+If you find an issue with the plugin, please report it in
+the [Issues tab](https://github.com/EternalCodeTeam/EternalCombat/issues). Please provide as much information as
+possible, including the version of Minecraft and the plugin you are using, as well as any error messages or logs.
+
+### Compatibility
+
+CombatLog has been tested on versions 1.17.1 - 1.19.3, but probably works on most versions of Minecraft. If you find
+compatibility issues, please report them in the Issues tab. CombatLog uses java 11+, so you need to have it installed on
+your server.
+
+### Submitting a Pull Request
+
+When submitting a pull request, please make sure to follow these guidelines:
+
+- Make sure that your code adheres to the plugin's existing coding style.
+- Test your changes thoroughly before submitting the pull request.
+- If your pull request is related to an existing issue, please reference the issue in your pull request.
+- Thank you for your contributions to the EternalCombat project!

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,33 @@
+---
+name: Bug report
+about: Create a bug report to help us improve EternalCombat <3
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Platform (please complete the following information):**
+
+- Java Version: [e.g. JDK Temurin 17]
+- Server software, ex. PaperMC 1.19.3 build #1
+
+**Additional notes**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for EternalCombat <3
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1 @@
+**Please describe the changes made by this PR and why they need to be merged:**

.github/workflows/gradle.yml

@@ -0,0 +1,43 @@
+name: Java CI with Gradle
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout 
+        uses: actions/checkout@v4
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+      - name: Cache Gradle
+        uses: actions/cache@v4.0.2
+        with:
+          path: ~/.gradle/caches
+          key: >-
+            ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*',
+            '**/gradle-wrapper.properties') }}
+          restore-keys: '${{ runner.os }}-gradle-'    
+      - name: Make gradlew executable
+        run: chmod +x gradlew
+      - name: Build with Gradle
+        uses: gradle/gradle-build-action@66535aaf56f831b35e3a8481c9c99b665b84dd45
+        with:
+          arguments: shadowJar
+      - name: Upload a Build Artifact
+        uses: actions/upload-artifact@v4.3.3
+        with:
+          name: 'Successfully build EternalCombat'
+          path: eternalcombat-plugin/build/libs/*.jar

.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish EternalCombat API
+on:
+  release:
+    branches: [ master ]
+    types: [ published ]
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: deployment
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'gradle'
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      - name: Publish with Gradle
+        run: ./gradlew clean build eternalcombat-api:publish
+        env:
+          ETERNAL_CODE_MAVEN_USERNAME: ${{ secrets.ETERNAL_CODE_MAVEN_USERNAME }}
+          ETERNAL_CODE_MAVEN_PASSWORD: ${{ secrets.ETERNAL_CODE_MAVEN_PASSWORD }}

.gitignore

@@ -5,5 +5,4 @@
 .settings
 bin
 build
-buildSrc/.kotlin/
 run

.whitesource

@@ -0,0 +1,14 @@
+{
+  "scanSettings": {
+    "baseBranches": []
+  },
+  "checkRunSettings": {
+    "vulnerableCheckRunConclusionLevel": "failure",
+    "displayMode": "diff",
+    "useMendCheckNames": true
+  },
+  "issueSettings": {
+    "minSeverityLevel": "LOW",
+    "issueType": "DEPENDENCY"
+  }
+}

README.md

@@ -1,31 +1,84 @@
-# EternalCombat-OG
+<div align="center">
 
-A [TrueOG Network](https://true-og.net) fork of [EternalCombat](https://github.com/EternalCodeTeam/EternalCombat)
-by the EternalCode Team — a combat-tag / combat-logging plugin for Paper.
+![](/assets/readme-banner.png)
 
-## License & attribution
+[![Supports Paper](https://raw.githubusercontent.com/intergrav/devins-badges/v3/assets/cozy/supported/paper_vector.svg)](https://papermc.io)
+[![Supports Spigot](https://raw.githubusercontent.com/intergrav/devins-badges/v3/assets/cozy/supported/spigot_vector.svg)](https://spigotmc.org)
 
-EternalCombat-OG is a derivative work of **EternalCombat** by the **EternalCode Team**, distributed
-under the **Apache License 2.0**. The original copyright and license are retained; see the
-[`LICENSE`](LICENSE) file. Upstream project: https://github.com/EternalCodeTeam/EternalCombat
+[![Patreon](https://raw.githubusercontent.com/intergrav/devins-badges/v3/assets/cozy/donate/patreon-plural_vector.svg)](https://www.patreon.com/eternalcode)
+[![Website](https://raw.githubusercontent.com/intergrav/devins-badges/v3/assets/cozy/documentation/website_vector.svg)](https://eternalcode.pl/)
+[![Discord](https://raw.githubusercontent.com/intergrav/devins-badges/v3/assets/cozy/social/discord-plural_vector.svg)](https://discord.gg/FQ7jmGBd6c)
 
-## Changes from upstream
+[![Gradle](https://raw.githubusercontent.com/intergrav/devins-badges/v3/assets/cozy/built-with/gradle_vector.svg)](https://gradle.org/)
+[![Java](https://raw.githubusercontent.com/intergrav/devins-badges/v3/assets/cozy/built-with/java17_vector.svg)](https://www.java.com/)
+</div>
 
-This fork diverges from upstream EternalCombat in the following ways:
+### Information
 
-- Renamed the project and plugin to `EternalCombat-OG`.
-- Fixed combat knockback flinging players across the map or into the sky near safe zones.
-- Players in combat can move between the warzone and wilderness, but not into safe areas.
-- Render the glass combat border on the true safe/unsafe boundary (e.g. between the warzone and spawn or the market) instead of a region's bounding box, so no wall shows between the warzone and wilderness or on the outer face of a large enclosing region.
-- Mounted players are pushed along with their mount instead of being thrown off.
-- Closed gaps that let combat-tagged players slip into shops and the market.
-- Removed chat gradients.
-- Added a command whitelist for "The Herobrine" minigames.
-- Dropped Lands support.
-- Removed the upstream GitHub Actions, plus build and dependency cleanup.
+EternalCombat has been tested on Minecraft versions 1.17.1 to 1.20.6, but it should work on most other versions. If you
+encounter any compatibility issues, please report them in the
+[Issues tab](https://github.com/EternalCodeTeam/EternalCombat/issues). The plugin requires Java 17 or later, so please
+make sure it is installed on your server.
 
-## Requirements
+## Building
+Build EternalCombat using:
 
-- Paper (Java 17+ toolchain)
-- [PacketEvents](https://modrinth.com/plugin/packetevents) (required)
-- WorldGuard (optional, for region-based combat restrictions)
+`./gradlew shadowJar`
+
+### Permissions for EternalCombat
+
+- `eternalcombat.status` - Allows to check if the player is in combat `/combatlog status <player>`
+- `eternalcombat.tag` - Allows to create fights between two
+  players  `/combatlog tag <first_player> <optional_second_player>`
+- `eternalcombat.untag` - Allows to remove player from fight `/combatlog untag <player>`
+- `eternalcombat.reload` - Allows to reload plugin `/combatlog reload`
+- `eternalcombat.receiveupdates` - Allows you to receive notifications about the new version of the plugin when
+  attaching
+
+### Developer API
+
+#### 1. Add repository:
+
+with Gradle:
+```kts
+maven {
+    url = uri("https://repo.eternalcode.pl/releases")
+}
+```
+
+with Maven:
+```xml
+<repository>
+  <id>eternalcode-reposilite-releases</id>
+  <name>EternalCode Repository</name>
+  <url>https://repo.eternalcode.pl/releases</url>
+</repository>
+```
+
+#### 2. Add dependency:
+
+with Gradle:
+```kts
+compileOnly("com.eternalcode:eternalcombat-api:1.2.2")
+```
+
+with Maven:
+```xml
+<dependency>
+  <groupId>com.eternalcode</groupId>
+  <artifactId>eternalcombat-api</artifactId>
+  <version>1.2.2</version>
+  <scope>provided</scope>
+</dependency>
+```
+
+### Contributing
+
+We welcome all contributions to the EternalCombat project! Please check out [contributing](.github/CONTRIBUTING.md) for
+more information on how to contribute and our [code of conduct](./.github/CODE_OF_CONDUCT.md)
+
+### Reporting Issues
+
+If you find an issue with the plugin, please report it in
+the [Issues tab](https://github.com/EternalCodeTeam/EternalCombat/issues). Please provide as much information as
+possible, including the version of Minecraft and the plugin you are using, as well as any error messages or logs

build.gradle.kts

@@ -1,48 +0,0 @@
-plugins {
-    java
-    eclipse
-}
-
-tasks.jar {
-    enabled = false
-}
-
-val pluginProject = project(":eternalcombat-plugin")
-val pluginJar by tasks.registering(Copy::class) {
-    dependsOn(":eternalcombat-plugin:shadowJar")
-    from(pluginProject.provider {
-        pluginProject.layout.buildDirectory.file("libs/EternalCombat-OG-${pluginProject.version}.jar").get().asFile
-    })
-    into(layout.buildDirectory.dir("libs"))
-}
-
-tasks.assemble {
-    dependsOn(pluginJar)
-}
-
-allprojects {
-    group = "com.eternalcode"
-    version = "2.2.0"
-
-    repositories {
-        mavenCentral()
-        maven("https://repo.papermc.io/repository/maven-public/")
-        maven("https://repo.eternalcode.pl/releases")
-        maven("https://storehouse.okaeri.eu/repository/maven-releases/")
-        maven("https://maven.reposilite.com/releases")
-        maven("https://repo.extendedclip.com/content/repositories/placeholderapi/")
-        maven("https://repo.codemc.org/repository/maven-public/")
-        maven("https://maven.enginehub.org/repo/")
-        maven("https://jitpack.io")
-    }
-}
-
-subprojects {
-    apply(plugin = "java")
-    apply(plugin = "eclipse")
-    java { toolchain { languageVersion.set(JavaLanguageVersion.of(17)) } }
-    tasks.withType<JavaCompile>().configureEach {
-        options.encoding = "UTF-8"
-        options.release.set(17)
-    }
-}

buildSrc/build.gradle.kts

@@ -1,9 +1,6 @@
 plugins {
     `kotlin-dsl`
-    eclipse
 }
-repositories { gradlePluginPortal(); mavenCentral() }
-kotlin { jvmToolchain(17) }
 
 repositories {
     mavenCentral()
@@ -11,10 +8,10 @@ repositories {
 }
 
 dependencies {
-    implementation("com.gradleup.shadow:com.gradleup.shadow.gradle.plugin:9.4.1")
-    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:2.3.20")
+    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.24")
+    implementation("com.github.johnrengelman:shadow:8.1.1")
     implementation("net.minecrell:plugin-yml:0.6.0")
-    implementation("xyz.jpenilla:run-task:3.0.2")
+    implementation("xyz.jpenilla:run-task:2.3.0")
 }
 
 sourceSets {

buildSrc/src/main/kotlin/Versions.kt

@@ -2,36 +2,33 @@ object Versions {
 
     const val SPIGOT_API = "1.17.1-R0.1-SNAPSHOT"
 
-    const val JUNIT_JUPITER_API = "6.0.3"
-    const val JUNIT_JUPITER_PARAMS = "6.0.3"
-    const val JUNIT_JUPITER_ENGINE = "6.0.3"
+    const val JUNIT_JUPITER_API = "5.10.2"
+    const val JUNIT_JUPITER_PARAMS = "5.10.2"
+    const val JUNIT_JUPITER_ENGINE = "5.10.2"
 
-    const val JETBRAINS_ANNOTATIONS = "26.1.0"
+    const val ETERNALCODE_COMMONS = "1.1.3"
+    // TODO: Multification.
 
-    const val ETERNALCODE_COMMONS = "1.3.4"
-    const val MULTIFICATION = "1.2.4"
-    const val PACKETEVENTS = "2.11.2"
+    const val ADVENTURE_PLATFORM_BUKKIT = "4.3.3"
+    const val ADVENTURE_TEXT_MINIMESSAGE = "4.17.0"
 
-    const val ADVENTURE_PLATFORM_BUKKIT = "4.4.1"
-    const val ADVENTURE_API = "4.26.1"
+    const val LITE_COMMANDS = "2.8.9"
+    const val OKAERI_CONFIGS_YAML_BUKKIT = "5.0.2"
+    const val OKAERI_CONFIGS_SERDES_COMMONS = "5.0.2"
+    const val OKAERI_CONFIGS_SERDES_BUKKIT = "5.0.2"
 
-    const val LITE_COMMANDS = "3.10.9"
-    const val OKAERI_CONFIGS_SERDES_COMMONS = "5.0.13"
-    const val OKAERI_CONFIGS_SERDES_BUKKIT = "5.0.13"
+    const val PANDA_UTILITIES = "0.5.2-alpha"
+    const val GIT_CHECK = "1.0.0"
+    const val APACHE_COMMONS = "2.16.1"
 
-    const val XSERIES = "13.6.0"
+    const val CAFFEINE = "3.1.8"
 
-    const val CAFFEINE = "3.2.3"
-
-    const val WORLD_GUARD_BUKKIT = "7.0.8"
-
-    const val PLACEHOLDER_API = "2.11.7"
-    const val PAPERLIB = "1.0.8"
-
-    const val WORLDEDIT = "3ISh7ADm" //cannot use numeric version bc of duplicated version on modrinth
-    const val WORLDGUARD = "7.0.8"
-    const val LUCKPERMS = "5.5.17"
+    const val B_STATS_BUKKIT = "3.0.2"
+    const val WORLD_GUARD_BUKKIT = "7.0.10"
 
 }
 
 
+
+
+

buildSrc/src/main/kotlin/eternalcombat-java.gradle.kts

@@ -1,16 +1,36 @@
 plugins {
     `java-library`
+    checkstyle
 }
 
 group = "com.eternalcode"
-version = "2.5.0-SNAPSHOT"
-
-tasks.compileJava {
-    options.compilerArgs = listOf("-Xlint:deprecation", "-parameters")
-    options.encoding = "UTF-8"
-    options.release = 17
-}
+version = "1.2.2"
 
 java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(17))
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+checkstyle {
+    toolVersion = "10.17.0"
+
+    configFile = file("${rootDir}/config/checkstyle/checkstyle.xml")
+
+    maxErrors = 0
+    maxWarnings = 0
+}
+
+// https://github.com/JabRef/jabref/pull/10812/files#diff-49a96e7eea8a94af862798a45174e6ac43eb4f8b4bd40759b5da63ba31ec3ef7R267
+configurations.named("checkstyle") {
+    resolutionStrategy {
+        capabilitiesResolution {
+            withCapability("com.google.collections:google-collections") {
+                select("com.google.guava:guava:33.2.1-jre")
+            }
+        }
+    }
+}
+
+tasks.compileJava {
+    options.encoding = "UTF-8"
 }

buildSrc/src/main/kotlin/eternalcombat-publish.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 group = "com.eternalcode"
-version = "2.5.0-SNAPSHOT"
+version = "1.2.2"
 
 java {
     withSourcesJar()

buildSrc/src/main/kotlin/eternalcombat-repositories.gradle.kts

@@ -3,17 +3,12 @@ plugins {
 }
 
 repositories {
-    maven("https://repo.eternalcode.pl/releases")
-    maven("https://repo.eternalcode.pl/snapshots")
-
     mavenCentral()
-    maven("https://hub.spigotmc.org/nexus/content/repositories/snapshots/")
-    maven("https://repo.papermc.io/repository/maven-public/")
-    maven("https://storehouse.okaeri.eu/repository/maven-public/")
-    maven("https://repo.panda-lang.org/releases")
-    maven("https://maven.enginehub.org/repo/")
-    maven("https://repo.extendedclip.com/content/repositories/placeholderapi/")
-    maven("https://repo.codemc.io/repository/maven-releases/")
-    maven("https://jitpack.io/")
-    maven(url = "https://s01.oss.sonatype.org/content/repositories/snapshots/")
+
+    maven { url = uri("https://hub.spigotmc.org/nexus/content/repositories/snapshots/") }
+    maven { url = uri("https://papermc.io/repo/repository/maven-public/") }
+    maven { url = uri("https://repo.eternalcode.pl/releases") }
+    maven { url = uri("https://storehouse.okaeri.eu/repository/maven-public/") }
+    maven { url = uri("https://repo.panda-lang.org/releases") }
+    maven { url = uri("https://maven.enginehub.org/repo/") }
 }

eternalcombat-api/build.gradle.kts

@@ -1,9 +1,45 @@
-plugins { `java-library` }
-
-java { toolchain { languageVersion.set(JavaLanguageVersion.of(17)) } }
-
-dependencies {
-    compileOnly("io.papermc.paper:paper-api:1.19.4-R0.1-SNAPSHOT")
-    compileOnly("org.jetbrains:annotations:26.0.2")
+plugins {
+    `eternalcombat-java`
+    `eternalcombat-repositories`
+    `eternalcombat-publish`
+    `eternalcombat-java-unit-test`
 }
 
+dependencies {
+    // Spigot api
+    compileOnlyApi("org.spigotmc:spigot-api:${Versions.SPIGOT_API}")
+
+    // kyori
+    api("net.kyori:adventure-platform-bukkit:${Versions.ADVENTURE_PLATFORM_BUKKIT}")
+    api("net.kyori:adventure-text-minimessage:${Versions.ADVENTURE_TEXT_MINIMESSAGE}")
+
+    // litecommands
+    api("dev.rollczi.litecommands:bukkit-adventure:${Versions.LITE_COMMANDS}")
+
+    // Okaeri configs
+    api("eu.okaeri:okaeri-configs-yaml-bukkit:${Versions.OKAERI_CONFIGS_YAML_BUKKIT}")
+    api("eu.okaeri:okaeri-configs-serdes-commons:${Versions.OKAERI_CONFIGS_SERDES_COMMONS}")
+    api("eu.okaeri:okaeri-configs-serdes-bukkit:${Versions.OKAERI_CONFIGS_SERDES_BUKKIT}")
+
+    // Panda utilities
+    api("org.panda-lang:panda-utilities:${Versions.PANDA_UTILITIES}")
+
+    // GitCheck
+    api("com.eternalcode:gitcheck:${Versions.GIT_CHECK}")
+
+    // commons
+    api("commons-io:commons-io:${Versions.APACHE_COMMONS}")
+
+    // bstats
+    api("org.bstats:bstats-bukkit:${Versions.B_STATS_BUKKIT}")
+
+    // caffeine
+    api("com.github.ben-manes.caffeine:caffeine:${Versions.CAFFEINE}")
+
+    api("com.eternalcode:eternalcode-commons-bukkit:${Versions.ETERNALCODE_COMMONS}")
+    api("com.eternalcode:eternalcode-commons-adventure:${Versions.ETERNALCODE_COMMONS}")
+
+    // worldguard
+    compileOnly("com.sk89q.worldguard:worldguard-bukkit:${Versions.WORLD_GUARD_BUKKIT}")
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/CombatCommand.java

@@ -0,0 +1,137 @@
+package com.eternalcode.combat;
+
+import com.eternalcode.combat.config.ConfigService;
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.fight.event.CauseOfTag;
+import com.eternalcode.combat.fight.event.CauseOfUnTag;
+import com.eternalcode.combat.fight.event.FightTagEvent;
+import com.eternalcode.combat.fight.event.FightUntagEvent;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import dev.rollczi.litecommands.argument.Arg;
+import dev.rollczi.litecommands.command.async.Async;
+import dev.rollczi.litecommands.command.execute.Execute;
+import dev.rollczi.litecommands.command.permission.Permission;
+import dev.rollczi.litecommands.command.route.Route;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import panda.utilities.text.Formatter;
+
+import java.time.Duration;
+import java.util.UUID;
+
+@Route(name = "combatlog", aliases = "combat")
+public class CombatCommand {
+
+    private final FightManager fightManager;
+    private final ConfigService configService;
+    private final NotificationAnnouncer announcer;
+    private final PluginConfig config;
+
+    public CombatCommand(FightManager fightManager, ConfigService configService, NotificationAnnouncer announcer, PluginConfig config) {
+        this.fightManager = fightManager;
+        this.configService = configService;
+        this.announcer = announcer;
+        this.config = config;
+    }
+
+    @Execute(route = "status", required = 1)
+    @Permission("eternalcombat.status")
+    void status(CommandSender sender, @Arg Player target) {
+        UUID targetUniqueId = target.getUniqueId();
+        PluginConfig.Messages messages = this.config.messages;
+
+        Formatter formatter = new Formatter()
+            .register("{PLAYER}", target.getName());
+
+        this.announcer.sendMessage(sender, this.fightManager.isInCombat(targetUniqueId)
+            ? formatter.format(messages.admin.playerInCombat)
+            : formatter.format(messages.admin.playerNotInCombat));
+    }
+
+    @Execute(route = "tag", required = 1)
+    @Permission("eternalcombat.tag")
+    void tag(CommandSender sender, @Arg Player target) {
+        UUID targetUniqueId = target.getUniqueId(); 
+        Duration time = this.config.settings.combatDuration;
+
+        Formatter formatter = new Formatter()
+            .register("{PLAYER}", target.getName());
+
+        FightTagEvent event = this.fightManager.tag(targetUniqueId, time, CauseOfTag.COMMAND);
+
+        if (event.isCancelled()) {
+            this.announcer.sendMessage(sender, event.getCancelMessage());
+            return;
+        }
+
+        String format = formatter.format(this.config.messages.admin.adminTagPlayer);
+        this.announcer.sendMessage(sender, format);
+    }
+
+    @Execute(route = "tag", required = 2)
+    @Permission("eternalcombat.tag")
+    void tagMultiple(CommandSender sender, @Arg Player firstTarget, @Arg Player secondTarget) {
+        Duration combatTime = this.config.settings.combatDuration;
+        PluginConfig.Messages messages = this.config.messages;
+        
+        if (sender.equals(firstTarget) || sender.equals(secondTarget)) {
+            this.announcer.sendMessage(sender, messages.admin.adminCannotTagSelf);
+            return;
+        }
+
+        FightTagEvent firstTagEvent = this.fightManager.tag(firstTarget.getUniqueId(), combatTime, CauseOfTag.COMMAND);
+        FightTagEvent secondTagEvent = this.fightManager.tag(secondTarget.getUniqueId(), combatTime, CauseOfTag.COMMAND);
+
+        Formatter formatter = new Formatter()
+            .register("{FIRST_PLAYER}", firstTarget.getName())
+            .register("{SECOND_PLAYER}", secondTarget.getName());
+
+        String format = formatter.format(messages.admin.adminTagMultiplePlayers);
+
+        if (firstTagEvent.isCancelled()) {
+            this.announcer.sendMessage(sender, firstTagEvent.getCancelMessage());
+        }
+
+        if (secondTagEvent.isCancelled()) {
+            this.announcer.sendMessage(sender, firstTagEvent.getCancelMessage());
+        }
+
+        if (firstTagEvent.isCancelled() && secondTagEvent.isCancelled()) {
+            return;
+        }
+
+        this.announcer.sendMessage(sender, format);
+    }
+
+    @Async
+    @Execute(route = "reload")
+    @Permission("eternalcombat.reload")
+    void execute(CommandSender player) {
+        this.configService.reload();
+        this.announcer.sendMessage(player, this.config.messages.admin.reload);
+    }
+
+    @Execute(route = "untag", required = 1)
+    @Permission("eternalcombat.untag")
+    void untag(Player sender, @Arg Player target) {
+        UUID targetUniqueId = target.getUniqueId();
+
+        if (!this.fightManager.isInCombat(targetUniqueId)) {
+            this.announcer.sendMessage(sender, this.config.messages.admin.adminPlayerNotInCombat);
+            return;
+        }
+
+        FightUntagEvent event = this.fightManager.untag(targetUniqueId, CauseOfUnTag.COMMAND);
+        if (event.isCancelled()) {
+            return;
+        }
+
+        Formatter formatter = new Formatter()
+            .register("{PLAYER}", target.getName());
+
+        String format = formatter.format(this.config.messages.admin.adminUntagPlayer);
+
+        this.announcer.sendMessage(sender, format);
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/EternalCombatApi.java

@@ -1,12 +1,13 @@
 package com.eternalcode.combat;
 
-import com.eternalcode.combat.fight.drop.DropKeepInventoryService;
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.drop.DropKeepInventoryManager;
+import com.eternalcode.combat.drop.DropManager;
 import com.eternalcode.combat.fight.FightManager;
-import com.eternalcode.combat.fight.drop.DropService;
 import com.eternalcode.combat.fight.effect.FightEffectService;
-import com.eternalcode.combat.fight.pearl.FightPearlService;
-import com.eternalcode.combat.region.RegionProvider;
+import com.eternalcode.combat.fight.pearl.FightPearlManager;
 import com.eternalcode.combat.fight.tagout.FightTagOutService;
+import com.eternalcode.combat.region.RegionProvider;
 
 public interface EternalCombatApi {
 
@@ -14,14 +15,16 @@ public interface EternalCombatApi {
 
     RegionProvider getRegionProvider();
 
-    FightPearlService getFightPearlService();
+    FightPearlManager getFightPearlManager();
 
     FightTagOutService getFightTagOutService();
 
     FightEffectService getFightEffectService();
 
-    DropService getDropService();
+    DropManager getDropManager();
 
-    DropKeepInventoryService getDropKeepInventoryService();
+    DropKeepInventoryManager getDropKeepInventoryManager();
+
+    PluginConfig getPluginConfig();
 
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/EternalCombatProvider.java

@@ -4,10 +4,6 @@ public final class EternalCombatProvider {
 
     private static EternalCombatApi ETERNAL_COMBAT_API;
 
-    static boolean isInitialized() {
-        return ETERNAL_COMBAT_API != null;
-    }
-
     public static EternalCombatApi provide() {
         if (ETERNAL_COMBAT_API == null) {
             throw new IllegalStateException("EternalCombatApi has not been initialized yet!");

eternalcombat-api/src/main/java/com/eternalcode/combat/bridge/BridgeService.java

@@ -0,0 +1,49 @@
+package com.eternalcode.combat.bridge;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.region.DefaultRegionProvider;
+import com.eternalcode.combat.region.RegionProvider;
+import com.eternalcode.combat.region.WorldGuardRegionProvider;
+import org.bukkit.plugin.PluginManager;
+
+import java.util.logging.Logger;
+
+public class BridgeService {
+
+    private final PluginConfig pluginConfig;
+    private final PluginManager pluginManager;
+    private final Logger logger;
+
+    private RegionProvider regionProvider;
+
+    public BridgeService(PluginConfig pluginConfig, PluginManager pluginManager, Logger logger) {
+        this.pluginConfig = pluginConfig;
+        this.pluginManager = pluginManager;
+        this.logger = logger;
+    }
+
+    public void init() {
+        this.initialize("WorldGuard",
+            () -> this.regionProvider = new WorldGuardRegionProvider(this.pluginConfig.settings.blockedRegions),
+            () -> {
+            this.regionProvider = new DefaultRegionProvider(this.pluginConfig.settings.blockedRegionRadius);
+
+            this.logger.warning("WorldGuard is not installed, set to default region provider.");
+        });
+    }
+
+    private void initialize(String pluginName, BridgeInitializer initializer, Runnable runnable) {
+        if (this.pluginManager.isPluginEnabled(pluginName)) {
+            initializer.initialize();
+
+            this.logger.info("Successfully initialized " + pluginName + " bridge.");
+        }
+        else {
+            runnable.run();
+        }
+    }
+
+    public RegionProvider getRegionProvider() {
+        return this.regionProvider;
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/command/InvalidUsage.java

@@ -0,0 +1,35 @@
+package com.eternalcode.combat.command;
+
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import dev.rollczi.litecommands.command.LiteInvocation;
+import dev.rollczi.litecommands.handle.InvalidUsageHandler;
+import dev.rollczi.litecommands.schematic.Schematic;
+import org.bukkit.command.CommandSender;
+import panda.utilities.text.Formatter;
+
+import java.util.List;
+
+public class InvalidUsage implements InvalidUsageHandler<CommandSender> {
+
+    private final PluginConfig config;
+    private final NotificationAnnouncer announcer;
+
+    public InvalidUsage(PluginConfig config, NotificationAnnouncer announcer) {
+        this.config = config;
+        this.announcer = announcer;
+    }
+
+    @Override
+    public void handle(CommandSender commandSender, LiteInvocation invocation, Schematic scheme) {
+        List<String> schematics = scheme.getSchematics();
+
+        for (String schematic : schematics) {
+            Formatter formatter = new Formatter()
+                .register("{USAGE}", schematic);
+
+            this.announcer.sendMessage(commandSender, formatter.format(this.config.messages.invalidCommandUsage));
+        }
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/command/PermissionMessage.java

@@ -0,0 +1,34 @@
+package com.eternalcode.combat.command;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import dev.rollczi.litecommands.command.LiteInvocation;
+import dev.rollczi.litecommands.command.permission.RequiredPermissions;
+import dev.rollczi.litecommands.handle.PermissionHandler;
+import org.bukkit.command.CommandSender;
+import panda.utilities.text.Formatter;
+import panda.utilities.text.Joiner;
+
+public class PermissionMessage implements PermissionHandler<CommandSender> {
+
+    private final PluginConfig config;
+    private final NotificationAnnouncer announcer;
+
+    public PermissionMessage(PluginConfig config, NotificationAnnouncer announcer) {
+        this.config = config;
+        this.announcer = announcer;
+    }
+
+    @Override
+    public void handle(CommandSender commandSender, LiteInvocation invocation, RequiredPermissions requiredPermissions) {
+        String value = Joiner.on(", ")
+            .join(requiredPermissions.getPermissions())
+            .toString();
+
+        Formatter formatter = new Formatter()
+            .register("{PERMISSION}", value);
+
+        this.announcer.sendMessage(commandSender, formatter.format(this.config.messages.noPermission));
+    }
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/config/ConfigService.java

@@ -0,0 +1,41 @@
+package com.eternalcode.combat.config;
+
+import com.eternalcode.combat.notification.serializer.NotificationSerializer;
+import eu.okaeri.configs.ConfigManager;
+import eu.okaeri.configs.OkaeriConfig;
+import eu.okaeri.configs.serdes.commons.SerdesCommons;
+import eu.okaeri.configs.yaml.bukkit.YamlBukkitConfigurer;
+import eu.okaeri.configs.yaml.bukkit.serdes.SerdesBukkit;
+
+import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ConfigService {
+
+    private final Set<OkaeriConfig> configs = new HashSet<>();
+
+    public <T extends OkaeriConfig> T create(Class<T> config, File file) {
+        T configFile = ConfigManager.create(config);
+
+        configFile.withConfigurer(new YamlBukkitConfigurer(), new SerdesCommons(), new SerdesBukkit());
+        configFile.withSerdesPack(registry -> {
+            registry.register(new NotificationSerializer());
+        });
+
+        configFile.withBindFile(file);
+        configFile.withRemoveOrphans(true);
+        configFile.saveDefaults();
+        configFile.load(true);
+
+        this.configs.add(configFile);
+
+        return configFile;
+    }
+
+    public void reload() {
+        for (OkaeriConfig config : this.configs) {
+            config.load();
+        }
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/config/implementation/PluginConfig.java

@@ -0,0 +1,230 @@
+package com.eternalcode.combat.config.implementation;
+
+import com.eternalcode.combat.WhitelistBlacklistMode;
+import com.eternalcode.combat.drop.DropSettings;
+import com.eternalcode.combat.fight.effect.FightEffectSettings;
+import com.eternalcode.combat.fight.pearl.FightPearlSettings;
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.implementation.ActionBarNotification;
+import eu.okaeri.configs.OkaeriConfig;
+import eu.okaeri.configs.annotation.Comment;
+import org.bukkit.Material;
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.entity.EntityDamageEvent;
+
+import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+
+public class PluginConfig extends OkaeriConfig {
+
+    @Comment("# Do you want to change the plugin settings?")
+    public Settings settings = new Settings();
+
+    @Comment({" ", "# Ender pearl settings"})
+    public FightPearlSettings pearl = new FightPearlSettings();
+
+    @Comment({" ", "# Custom effects settings"})
+    public FightEffectSettings effect = new FightEffectSettings();
+
+    @Comment({" ", "# Set a custom way for a player's items to drop on death (if in combat)"})
+    public DropSettings dropSettings = new DropSettings();
+
+    public static class Settings extends OkaeriConfig {
+
+        @Comment("# Whether the player should receive information about new plugin updates upon joining the server")
+        public boolean shouldReceivePluginUpdates = true;
+
+        @Comment("# The duration of combat in seconds")
+        public Duration combatDuration = Duration.ofSeconds(20);
+
+        @Comment("# List of worlds to ignore")
+        public List<String> worldsToIgnore = List.of(
+            "your_world"
+        );
+
+        @Comment("# List of regions to block")
+        public List<String> blockedRegions = Collections.singletonList("your_region");
+
+        @Comment("# Set the knock multiplier for the blocked region")
+        public double blockedRegionKnockMultiplier = 1.2;
+
+        @Comment("# Set the radius of the blocked region if you aren't using WorldGuard basen on default spawn region!")
+        public int blockedRegionRadius = 10;
+
+        @Comment("# Release attacker after victim dies?")
+        public boolean shouldReleaseAttacker = true;
+
+        @Comment("# If you want to exclude admins from combat, set this to true")
+        public boolean excludeAdminFromCombat = false;
+
+        @Comment("# Command blocking mode, available modes: WHITELIST, BLACKLIST")
+        public WhitelistBlacklistMode commandBlockingMode = WhitelistBlacklistMode.BLACKLIST;
+
+        @Comment({
+            "# List of commands based on the mode above",
+            "# Based on BLACKLIST mode, all commands in the list are blocked, and all others are allowed",
+            "# Based on WHITELIST mode, all commands in the list are allowed, and all others are blocked",
+        })
+        public List<String> blockedCommands = List.of(
+            "gamemode",
+            "spawn",
+            "tp"
+        );
+
+        @Comment("# Block the use of elytra?")
+        public boolean shouldPreventElytraUsage = true;
+
+        @Comment("# Block flying? (flying players will fall to the ground)")
+        public boolean shouldPreventFlying = true;
+
+        @Comment("# Disable the use of elytra on damage?")
+        public boolean shouldElytraDisableOnDamage = true;
+
+        @Comment("# Block the opening of inventory?")
+        public boolean shouldPreventInventoryOpening = true;
+
+        @Comment("# Whether to block the placement of blocks?")
+        public boolean shouldPreventBlockPlacing = true;
+
+        @Comment("# The minimum Y level at which block placing is blocked")
+        public int minBlockPlacingLevel = 40;
+
+        @Comment({
+            "# Disable placing specific blocks?",
+            "# If you want to block all blocks, enable shouldPreventBlockPlacing and make this list empty",
+            "# If you want to disable placing only specific blocks, enable shouldPreventBlockPlacing and add blocks to this list above",
+            "# If you want to disable this feature completely, disable shouldPreventBlockPlacing option above",
+        })
+        public List<Material> specificBlocksToPreventPlacing = List.of();
+
+        @Comment("# Do You want to enable combat log for non-player causes of damage? - Set to false to disable")
+        public boolean shouldEnableDamageCauses = false;
+
+        @Comment("# Select the mode for damage causes, available modes: WHITELIST, BLACKLIST")
+        public WhitelistBlacklistMode damageCausesMode = WhitelistBlacklistMode.WHITELIST;
+
+        @Comment({
+            "# After selecting the mode above, select the causes of damage to be logged",
+            "# You can find a list of all causes here: https://hub.spigotmc.org/javadocs/spigot/org/bukkit/event/entity/EntityDamageEvent.DamageCause.html",
+            "# While using Whitelist mode the player will get a combat log after the damage from the list below",
+            "# While using Blacklist mode the player will get a combat log after any damage non-listed below",
+        })
+        public List<EntityDamageEvent.DamageCause> damageCausesToLog = List.of(
+            EntityDamageEvent.DamageCause.LAVA,
+            EntityDamageEvent.DamageCause.CONTACT,
+            EntityDamageEvent.DamageCause.FIRE,
+            EntityDamageEvent.DamageCause.FIRE_TICK
+        );
+
+        @Comment({
+            "# After what type of projectile entity should not tag the player as fighter?",
+            "# You can find a list of all entity types here: https://hub.spigotmc.org/javadocs/bukkit/org/bukkit/entity/EntityType.html"
+        })
+        public List<EntityType> disabledProjectileEntities = List.of(
+            EntityType.ENDER_PEARL
+        );
+
+    }
+
+    @Comment({" ", "# Do you want to change the plugin messages?"})
+    public Messages messages = new Messages();
+
+    public static class Messages extends OkaeriConfig {
+
+        @Comment("# Do you want to change the admin messages?")
+        public AdminMessages admin = new AdminMessages();
+
+        @Comment({
+            " ",
+            "# Combat log notification",
+            "# You can use {TIME} variable to display the time left in combat",
+            "# Notification types: CHAT, ACTION_BAR, TITLE, SUB_TITLE, BOSS_BAR",
+            " ",
+            "# BossBar progress: This is the value of the progress bar. Set it to -1.0 to show the remaining combat time",
+            "# BossBar colors: https://javadoc.io/static/net.kyori/adventure-api/4.14.0/net/kyori/adventure/bossbar/BossBar.Color.html",
+            "# BossBar overlays: https://javadoc.io/static/net.kyori/adventure-api/4.14.0/net/kyori/adventure/bossbar/BossBar.Overlay.html"
+        })
+        public Notification combatNotification = new ActionBarNotification("&dCombat ends in: &f{TIME}");
+
+        @Comment("# Message sent when the player does not have permission to perform a command")
+        public String noPermission = "&cYou don't have permission to perform this command!";
+
+        @Comment("# Message sent when the specified player could not be found")
+        public String playerNotFound = "&cThe specified player could not be found!";
+
+        @Comment("# Message sent when the player enters combat")
+        public String playerTagged = "&cYou are in combat, do not leave the server!";
+
+        @Comment("# Message sent when the player leaves combat")
+        public String playerUntagged = "&aYou are no longer in combat! You can safely leave the server.";
+
+        @Comment("# This is broadcast when the player is in combat and logs out")
+        public String playerLoggedOutDuringCombat = "&c{PLAYER} logged off during the fight!";
+
+        @Comment({
+            "# Message sent when the player is in combat and tries to use a disabled command",
+            "# you can configure the list of disabled commands in the blockedCommands section of the config.yml file"
+        })
+        public String commandDisabledDuringCombat = "&cUsing this command during combat is prohibited!";
+
+        @Comment("# Message sent when player tries to use a command with invalid arguments")
+        public String invalidCommandUsage = "&7Correct usage: &e{USAGE}";
+
+        @Comment("# Message sent when player tries to open inventory, but the inventory open is blocked")
+        public String inventoryBlockedDuringCombat = "&cYou cannot open this inventory during combat!";
+
+        @Comment("# Message sent when player tries to place a block, but the block place is blocked")
+        public String blockPlacingBlockedDuringCombat = "&cYou cannot place above 40Y coordinate during combat!";
+
+        @Comment("# Message sent when player tries to enter a region")
+        public String cantEnterOnRegion = "&cYou can't enter on this region during combat!";
+
+        public static class AdminMessages extends OkaeriConfig {
+            @Comment("# Message sent when the configuration is reloaded")
+            public String reload = "&aConfiguration has been successfully reloaded!";
+
+            @Comment("# Message sent when console tries to use a command that is only for players")
+            public String onlyForPlayers = "&cThis command is only available to players!";
+
+            @Comment("# Message sent to admin when they tag a player")
+            public String adminTagPlayer = "&7You have tagged &e{PLAYER}";
+
+            @Comment("# Message sent when a player is tagged by an admin")
+            public String adminTagMultiplePlayers = "&7You have tagged &e{FIRST_PLAYER}&7 and &e{SECOND_PLAYER}&7.";
+
+            @Comment("# Message sent to admin when they remove a player from combat")
+            public String adminUntagPlayer = "&7You have removed &e{PLAYER}&7 from the fight.";
+
+            @Comment("# Message sent when the player is not in combat")
+            public String adminPlayerNotInCombat = "&cThis player is not in combat!";
+
+            @Comment("# Message sent when the player is in combat")
+            public String playerInCombat = "&c{PLAYER} is currently in combat!";
+
+            @Comment("# Message sent when a player is not in combat")
+            public String playerNotInCombat = "&a{PLAYER} is not currently in combat.";
+
+            @Comment("# Message sent when an admin tries to tag themselves")
+            public String adminCannotTagSelf = "&cYou cannot tag yourself!";
+
+            @Comment("# Message sent when an admin disables the ability to get tagged for some time")
+            public String adminTagOutSelf = "&7Successfully disabled tag for Yourself! You will be taggable after &e{TIME} ";
+
+            @Comment("# Message sent when an admin disables the ability to get tagged for some time for other player")
+            public String adminTagOut = "&7Successfully disabled tag for &e{PLAYER}! They will be taggable after &e{TIME} ";
+
+            @Comment("# Message sent to the player whom the ability to get tagged for some time has been disabled")
+            public String playerTagOut = "&7You will be taggable in &e{TIME} !";
+
+            @Comment("# Message sent when an admin reenables the ability to get tagged for the player")
+            public String adminTagOutOff = "&7Successfully enabled tag for &e{PLAYER}!";
+
+            @Comment("# Message sent to the player whom the ability to get tagged has been reenabled")
+            public String playerTagOutOff = "&7You are now taggable!";
+
+            @Comment("# Message sent when player cannot be tagged because they have enabled tag-out")
+            public String adminTagOutCanceled = "&cCannot tag this player due to tag-out!";
+        }
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/Drop.java

@@ -1,4 +1,4 @@
-package com.eternalcode.combat.fight.drop;
+package com.eternalcode.combat.drop;
 
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/DropController.java

@@ -0,0 +1,79 @@
+package com.eternalcode.combat.drop;
+
+import com.eternalcode.combat.fight.FightManager;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+
+import java.util.List;
+import java.util.UUID;
+
+public class DropController implements Listener {
+
+    private final DropManager dropManager;
+    private final DropKeepInventoryManager keepInventoryManager;
+    private final DropSettings dropSettings;
+    private final FightManager fightManager;
+
+    public DropController(DropManager dropManager, DropKeepInventoryManager keepInventoryManager, DropSettings dropSettings, FightManager fightManager) {
+        this.dropManager = dropManager;
+        this.keepInventoryManager = keepInventoryManager;
+        this.dropSettings = dropSettings;
+        this.fightManager = fightManager;
+    }
+
+    @EventHandler(priority = EventPriority.LOW)
+    void onPlayerDeath(PlayerDeathEvent event) {
+        Player player = event.getEntity();
+
+        DropType dropType = this.dropSettings.dropType;
+
+        if (dropType == DropType.UNCHANGED || !this.fightManager.isInCombat(player.getUniqueId())) {
+            return;
+        }
+        List<ItemStack> drops = event.getDrops();
+
+        Drop drop = Drop.builder()
+            .player(player)
+            .killer(player.getKiller())
+            .droppedItems(drops)
+            .droppedExp(player.getTotalExperience())
+            .build();
+
+        DropResult result = this.dropManager.modify(dropType, drop);
+
+        if (result == null) {
+            return;
+        }
+
+        drops.clear();
+        drops.addAll(result.droppedItems());
+
+        this.keepInventoryManager.addItems(player.getUniqueId(), result.removedItems());
+
+        if (this.dropSettings.affectExperience) {
+            event.setDroppedExp(drop.getDroppedExp());
+        }
+    }
+
+    @EventHandler
+    void onPlayerRespawn(PlayerRespawnEvent event) {
+        Player player = event.getPlayer();
+        UUID playerUniqueId = player.getUniqueId();
+
+        if (this.keepInventoryManager.hasItems(playerUniqueId)) {
+            PlayerInventory playerInventory = player.getInventory();
+
+            ItemStack[] itemsToGive = this.keepInventoryManager.nextItems(playerUniqueId)
+                .toArray(new ItemStack[0]);
+
+            playerInventory.addItem(itemsToGive);
+        }
+    }
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/DropKeepInventoryManager.java

@@ -1,4 +1,4 @@
-package com.eternalcode.combat.fight.drop;
+package com.eternalcode.combat.drop;
 
 import org.bukkit.inventory.ItemStack;
 
@@ -9,26 +9,22 @@ import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 
-public class DropKeepInventoryServiceImpl implements DropKeepInventoryService {
+public class DropKeepInventoryManager {
 
     private final Map<UUID, List<ItemStack>> itemsToGiveAfterRespawn = new HashMap<>();
 
-    @Override
     public void addItem(UUID uuid, ItemStack item) {
         this.itemsToGiveAfterRespawn.computeIfAbsent(uuid, k -> new ArrayList<>()).add(item);
     }
 
-    @Override
     public void addItems(UUID uuid, List<ItemStack> item) {
         item.forEach(i -> this.addItem(uuid, i));
     }
 
-    @Override
     public boolean hasItems(UUID uuid) {
         return this.itemsToGiveAfterRespawn.containsKey(uuid);
     }
 
-    @Override
     public List<ItemStack> nextItems(UUID uuid) {
         List<ItemStack> itemStacks = this.itemsToGiveAfterRespawn.remove(uuid);
 

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/DropManager.java

@@ -1,17 +1,16 @@
-package com.eternalcode.combat.fight.drop;
+package com.eternalcode.combat.drop;
 
 import java.util.HashMap;
 import java.util.Map;
 
-public class DropServiceImpl implements DropService {
+public class DropManager {
 
     private final Map<DropType, DropModifier> modifiers;
 
-    public DropServiceImpl() {
+    public DropManager() {
         this.modifiers = new HashMap<>();
     }
 
-    @Override
     public void registerModifier(DropModifier dropModifier) {
         DropType dropType = dropModifier.getDropType();
 
@@ -26,7 +25,6 @@ public class DropServiceImpl implements DropService {
         this.modifiers.put(dropType, dropModifier);
     }
 
-    @Override
     public DropResult modify(DropType dropType, Drop drop) {
         if (!this.modifiers.containsKey(dropType)) {
             throw new RuntimeException("No drop modifier found for type '%s'".formatted(dropType.name()));

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/DropModifier.java

@@ -1,4 +1,4 @@
-package com.eternalcode.combat.fight.drop;
+package com.eternalcode.combat.drop;
 
 public interface DropModifier {
 

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/DropResult.java

@@ -1,4 +1,4 @@
-package com.eternalcode.combat.fight.drop;
+package com.eternalcode.combat.drop;
 
 import org.bukkit.inventory.ItemStack;
 

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/DropSettings.java

@@ -0,0 +1,23 @@
+package com.eternalcode.combat.drop;
+
+import eu.okaeri.configs.OkaeriConfig;
+import eu.okaeri.configs.annotation.Comment;
+
+public class DropSettings extends OkaeriConfig {
+
+    @Comment({
+        "# UNCHANGED - The default way of item drop defined by the engine",
+        "# PERCENT - Drops a fixed percentage of items",
+        "# PLAYERS_HEALTH - Drops inverted percentage of the player's health (i.e. if the player has, for example, 80% HP, he will drop 20% of items. Only works when the player escapes from combat by quiting game)"
+    })
+    public DropType dropType = DropType.UNCHANGED;
+
+    @Comment("# What percentage of items should drop from the player? (Only if Drop Type is set to PERCENT)")
+    public int dropItemPercent = 100;
+
+    @Comment("# This option is responsible for the lowest percentage of the player that can drop (i.e. if the player leaves the game while he has 100% of his HP, the percentage of items that is set in this option will drop, if you set this option to 0, then nothing will drop from such a player)")
+    public int playersHealthPercentClamp = 20;
+
+    @Comment("# Does the drop modification affect the experience drop?")
+    public boolean affectExperience = false;
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/DropType.java

@@ -1,4 +1,4 @@
-package com.eternalcode.combat.fight.drop;
+package com.eternalcode.combat.drop;
 
 public enum DropType {
 

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/impl/PercentDropModifier.java

@@ -1,10 +1,10 @@
-package com.eternalcode.combat.fight.drop.impl;
+package com.eternalcode.combat.drop.impl;
 
-import com.eternalcode.combat.fight.drop.Drop;
-import com.eternalcode.combat.fight.drop.DropModifier;
-import com.eternalcode.combat.fight.drop.DropResult;
-import com.eternalcode.combat.fight.drop.DropSettings;
-import com.eternalcode.combat.fight.drop.DropType;
+import com.eternalcode.combat.drop.Drop;
+import com.eternalcode.combat.drop.DropModifier;
+import com.eternalcode.combat.drop.DropResult;
+import com.eternalcode.combat.drop.DropSettings;
+import com.eternalcode.combat.drop.DropType;
 import com.eternalcode.combat.util.InventoryUtil;
 import com.eternalcode.combat.util.MathUtil;
 import com.eternalcode.combat.util.RemoveItemResult;

eternalcombat-api/src/main/java/com/eternalcode/combat/drop/impl/PlayersHealthDropModifier.java

@@ -1,10 +1,10 @@
-package com.eternalcode.combat.fight.drop.impl;
+package com.eternalcode.combat.drop.impl;
 
-import com.eternalcode.combat.fight.drop.Drop;
-import com.eternalcode.combat.fight.drop.DropModifier;
-import com.eternalcode.combat.fight.drop.DropResult;
-import com.eternalcode.combat.fight.drop.DropSettings;
-import com.eternalcode.combat.fight.drop.DropType;
+import com.eternalcode.combat.drop.Drop;
+import com.eternalcode.combat.drop.DropModifier;
+import com.eternalcode.combat.drop.DropResult;
+import com.eternalcode.combat.drop.DropSettings;
+import com.eternalcode.combat.drop.DropType;
 import com.eternalcode.combat.fight.logout.Logout;
 import com.eternalcode.combat.fight.logout.LogoutService;
 import com.eternalcode.combat.util.InventoryUtil;

eternalcombat-api/src/main/java/com/eternalcode/combat/event/EventCaller.java

@@ -0,0 +1,20 @@
+package com.eternalcode.combat.event;
+
+import org.bukkit.Server;
+import org.bukkit.event.Event;
+
+public class EventCaller {
+
+    private final Server server;
+
+    public EventCaller(Server server) {
+        this.server = server;
+    }
+
+    public <T extends Event> T publishEvent(T event) {
+        this.server.getPluginManager().callEvent(event);
+
+        return event;
+    }
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/FightManager.java

@@ -4,31 +4,69 @@ import com.eternalcode.combat.fight.event.CauseOfTag;
 import com.eternalcode.combat.fight.event.CauseOfUnTag;
 import com.eternalcode.combat.fight.event.FightTagEvent;
 import com.eternalcode.combat.fight.event.FightUntagEvent;
+import com.eternalcode.combat.event.EventCaller;
+
 import java.time.Duration;
+import java.time.Instant;
 import java.util.Collection;
-import java.util.Set;
+import java.util.Collections;
+import java.util.Map;
 import java.util.UUID;
-import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.Nullable;
+import java.util.concurrent.ConcurrentHashMap;
 
-public interface FightManager {
+public class FightManager {
 
-    boolean isInCombat(UUID player);
+    private final Map<UUID, FightTag> fights = new ConcurrentHashMap<>();
+    private final EventCaller eventCaller;
 
-    FightTag getTag(UUID target);
+    public FightManager(EventCaller eventCaller) {
+        this.eventCaller = eventCaller;
+    }
 
-    Collection<FightTag> getFights();
+    public boolean isInCombat(UUID player) {
+        if (!this.fights.containsKey(player)) {
+            return false;
+        }
 
-    // Players who tagged the given player during their current combat session.
-    @ApiStatus.Experimental
-    Set<UUID> getOpponents(UUID player);
+        FightTag fightTag = this.fights.get(player);
 
-    @ApiStatus.Experimental
-    FightTagEvent tag(UUID target, Duration delay, CauseOfTag causeOfTag, @Nullable UUID tagger);
+        return !fightTag.isExpired();
+    }
 
-    FightTagEvent tag(UUID target, Duration delay, CauseOfTag causeOfTag);
+    public FightUntagEvent untag(UUID player, CauseOfUnTag causeOfUnTag) {
+        FightUntagEvent event = this.eventCaller.publishEvent(new FightUntagEvent(player, causeOfUnTag));
+        if (event.isCancelled()) {
+            return event;
+        }
 
-    FightUntagEvent untag(UUID player, CauseOfUnTag causeOfUnTag);
+        this.fights.remove(player);
+        return event;
+    }
 
-    void untagAll();
+    public FightTagEvent tag(UUID target, Duration delay, CauseOfTag causeOfTag) {
+        FightTagEvent event = this.eventCaller.publishEvent(new FightTagEvent(target, causeOfTag));
+
+        if (event.isCancelled()) {
+            return event;
+        }
+        Instant now = Instant.now();
+        Instant endOfCombatLog = now.plus(delay);
+
+        FightTag fightTag = new FightTag(target, endOfCombatLog);
+
+        this.fights.put(target, fightTag);
+        return event;
+    }
+
+    public Collection<FightTag> getFights() {
+        return Collections.unmodifiableCollection(this.fights.values());
+    }
+
+    public FightTag getTag(UUID target) {
+        return this.fights.get(target);
+    }
+
+    public void untagAll() {
+        this.fights.clear();
+    }
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/FightTag.java

@@ -3,20 +3,38 @@ package com.eternalcode.combat.fight;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.UUID;
-import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.Nullable;
 
-public interface FightTag {
+public class FightTag {
 
-    @Nullable
-    @ApiStatus.Experimental
-    UUID getTagger();
+    private final UUID taggedPlayer;
+    private final Instant endOfCombatLog;
 
-    Duration getRemainingDuration();
+    FightTag(UUID personToAddCombat, Instant endOfCombatLog) {
+        this.taggedPlayer = personToAddCombat;
+        this.endOfCombatLog = endOfCombatLog;
 
-    boolean isExpired();
+    }
 
-    Instant getEndOfCombatLog();
+    public UUID getTaggedPlayer() {
+        return this.taggedPlayer;
+    }
+
+    public Instant getEndOfCombatLog() {
+        return this.endOfCombatLog;
+    }
+
+    public boolean isExpired() {
+        return Instant.now().isAfter(this.endOfCombatLog);
+    }
+
+    public Duration getRemainingDuration() {
+        Duration between = Duration.between(Instant.now(), this.endOfCombatLog);
+
+        if (between.isNegative()) {
+            return Duration.ZERO;
+        }
+
+        return between;
+    }
 
-    UUID getTaggedPlayer();
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/FightTask.java

@@ -0,0 +1,67 @@
+package com.eternalcode.combat.fight;
+
+import com.eternalcode.combat.fight.event.CauseOfUnTag;
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.bossbar.FightBossBarService;
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import com.eternalcode.combat.notification.implementation.BossBarNotification;
+import com.eternalcode.combat.util.DurationUtil;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import panda.utilities.text.Formatter;
+
+import java.time.Duration;
+import java.util.UUID;
+
+public class FightTask implements Runnable {
+
+    private final Server server;
+    private final PluginConfig config;
+    private final FightManager fightManager;
+    private final FightBossBarService bossBarService;
+    private final NotificationAnnouncer announcer;
+
+    public FightTask(Server server, PluginConfig config, FightManager fightManager, FightBossBarService bossBarService, NotificationAnnouncer announcer) {
+        this.server = server;
+        this.config = config;
+        this.fightManager = fightManager;
+        this.bossBarService = bossBarService;
+        this.announcer = announcer;
+    }
+
+    @Override
+    public void run() {
+        for (FightTag fightTag : this.fightManager.getFights()) {
+            Player player = this.server.getPlayer(fightTag.getTaggedPlayer());
+
+            if (player == null) {
+                continue;
+            }
+
+            UUID playerUniqueId = player.getUniqueId();
+
+            if (fightTag.isExpired()) {
+                this.fightManager.untag(playerUniqueId, CauseOfUnTag.TIME_EXPIRED);
+                return;
+            }
+
+            Duration remaining = fightTag.getRemainingDuration();
+            Formatter formatter = new Formatter()
+                    .register("{TIME}", DurationUtil.format(remaining));
+
+            Notification combatNotification = this.config.messages.combatNotification;
+
+            this.sendFightNotification(player, fightTag, combatNotification, formatter);
+        }
+    }
+
+    private void sendFightNotification(Player player, FightTag fightTag, Notification notification, Formatter formatter) {
+        if (notification instanceof BossBarNotification bossBarNotification) {
+            this.bossBarService.send(player, fightTag, bossBarNotification, formatter);
+            return;
+        }
+
+        this.announcer.send(player, notification, formatter);
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/bossbar/FightBossBar.java

@@ -0,0 +1,9 @@
+package com.eternalcode.combat.fight.bossbar;
+
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.bossbar.BossBar;
+
+import java.time.Duration;
+
+public record FightBossBar(Audience audience, BossBar bossBar, float progress, Duration combatDuration) {
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/bossbar/FightBossBarRegistry.java

@@ -0,0 +1,27 @@
+package com.eternalcode.combat.fight.bossbar;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+class FightBossBarRegistry {
+
+    private final Map<UUID, FightBossBar> fightBossBars = new ConcurrentHashMap<>();
+
+    void add(UUID uuid, FightBossBar fightBossBar) {
+        this.fightBossBars.put(uuid, fightBossBar);
+    }
+
+    void remove(UUID uuid) {
+        this.fightBossBars.remove(uuid);
+    }
+
+    boolean hasFightBossBar(UUID uuid) {
+        return this.fightBossBars.containsKey(uuid);
+    }
+
+    Optional<FightBossBar> getFightBossBar(UUID uuid) {
+        return Optional.ofNullable(this.fightBossBars.get(uuid));
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/bossbar/FightBossBarService.java

@@ -0,0 +1,119 @@
+package com.eternalcode.combat.fight.bossbar;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightTag;
+import com.eternalcode.combat.notification.implementation.BossBarNotification;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.bossbar.BossBar;
+import net.kyori.adventure.platform.AudienceProvider;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.entity.Player;
+import panda.utilities.text.Formatter;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Optional;
+import java.util.UUID;
+
+public class FightBossBarService {
+
+    private final PluginConfig pluginConfig;
+    private final FightBossBarRegistry bossBarRegistry = new FightBossBarRegistry();
+    private final AudienceProvider audienceProvider;
+    private final MiniMessage miniMessage;
+
+    public FightBossBarService(PluginConfig pluginConfig, AudienceProvider audienceProvider, MiniMessage miniMessage) {
+        this.pluginConfig = pluginConfig;
+        this.audienceProvider = audienceProvider;
+        this.miniMessage = miniMessage;
+    }
+
+    public void hide(FightTag fightTag, FightBossBar fightBossBar) {
+        Audience audience = fightBossBar.audience();
+        BossBar bossBar = fightBossBar.bossBar();
+        UUID taggedPlayer = fightTag.getTaggedPlayer();
+
+        audience.hideBossBar(bossBar);
+        this.bossBarRegistry.remove(taggedPlayer);
+    }
+
+    public void hide(UUID playerUuid) {
+        Optional<FightBossBar> bossBar = this.bossBarRegistry.getFightBossBar(playerUuid);
+
+        if (bossBar.isPresent()) {
+            FightBossBar fightBossBar = bossBar.get();
+            Audience audience = fightBossBar.audience();
+            BossBar bar = fightBossBar.bossBar();
+
+            audience.hideBossBar(bar);
+            this.bossBarRegistry.remove(playerUuid);
+        }
+    }
+
+    public void send(Player player, FightTag fightTag, BossBarNotification bossBarNotification, Formatter formatter) {
+        UUID playerUniqueId = player.getUniqueId();
+
+        FightBossBar fightBossBar = this.bossBarRegistry.getFightBossBar(playerUniqueId)
+            .orElseGet(() -> this.create(player, bossBarNotification, formatter));
+
+        if (!this.bossBarRegistry.hasFightBossBar(playerUniqueId)) {
+            this.show(player, fightBossBar);
+            return;
+        }
+
+        String message = formatter.format(bossBarNotification.message());
+
+        this.update(fightTag, fightBossBar, message);
+    }
+
+    private void update(FightTag fightTag, FightBossBar fightBossBar, String message) {
+        if (fightTag.isExpired()) {
+            this.hide(fightTag, fightBossBar);
+            return;
+        }
+
+        BossBar bossBar = fightBossBar.bossBar();
+        float fightBossBarProgress = fightBossBar.progress();
+
+        if (fightBossBarProgress < 0.0F) {
+            Instant now = Instant.now();
+
+            Instant endOfCombatLog = fightTag.getEndOfCombatLog();
+
+            Duration between = Duration.between(now, endOfCombatLog);
+            Duration combatDuration = fightBossBar.combatDuration();
+
+            float difference = (float) between.toMillis() / combatDuration.toMillis();
+            float progress = Math.max(0.0F, Math.min(1.0F, difference));
+
+            bossBar.progress(progress);
+        }
+
+        Component name = this.miniMessage.deserialize(message);
+
+        bossBar.name(name);
+    }
+
+    private void show(Player player, FightBossBar fightBossBar) {
+        UUID playerUniqueId = player.getUniqueId();
+
+        Audience audience = this.audienceProvider.player(playerUniqueId);
+        BossBar bossBar = fightBossBar.bossBar();
+
+        audience.showBossBar(bossBar);
+        this.bossBarRegistry.add(playerUniqueId, fightBossBar);
+    }
+
+    private FightBossBar create(Player player, BossBarNotification bossBarNotification, Formatter formatter) {
+        Audience audience = this.audienceProvider.player(player.getUniqueId());
+
+        Component name = this.miniMessage.deserialize(formatter.format(bossBarNotification.message()));
+        BossBar bossBar = bossBarNotification.create(name);
+
+        float progress = bossBarNotification.progress();
+        Duration combatDuration = this.pluginConfig.settings.combatDuration;
+
+        return new FightBossBar(audience, bossBar, progress, combatDuration);
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/controller/FightActionBlockerController.java

@@ -0,0 +1,163 @@
+package com.eternalcode.combat.fight.controller;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.WhitelistBlacklistMode;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityToggleGlideEvent;
+import org.bukkit.event.inventory.InventoryOpenEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerToggleFlightEvent;
+
+import java.util.List;
+import java.util.UUID;
+
+public class FightActionBlockerController implements Listener {
+
+    private final FightManager fightManager;
+    private final NotificationAnnouncer announcer;
+    private final PluginConfig config;
+
+    public FightActionBlockerController(FightManager fightManager, NotificationAnnouncer announcer, PluginConfig config) {
+        this.fightManager = fightManager;
+        this.announcer = announcer;
+        this.config = config;
+    }
+
+    @EventHandler
+    void onPlace(BlockPlaceEvent event) {
+        if (!this.config.settings.shouldPreventBlockPlacing) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        Block block = event.getBlock();
+        int level = block.getY();
+
+        List<Material> specificBlocksToPreventPlacing = this.config.settings.specificBlocksToPreventPlacing;
+
+        boolean isBlockPlaceLevel = level > this.config.settings.minBlockPlacingLevel;
+        if (isBlockPlaceLevel && specificBlocksToPreventPlacing.isEmpty()) {
+            event.setCancelled(true);
+            this.announcer.sendMessage(player, this.config.messages.blockPlacingBlockedDuringCombat);
+        }
+
+        Material blockMaterial = block.getType();
+        boolean isBlockInDisabledList = specificBlocksToPreventPlacing.contains(blockMaterial);
+        if (isBlockPlaceLevel && isBlockInDisabledList) {
+            event.setCancelled(true);
+            this.announcer.sendMessage(player, this.config.messages.blockPlacingBlockedDuringCombat);
+        }
+    }
+
+    @EventHandler
+    void onToggleGlide(EntityToggleGlideEvent event) {
+        if (!this.config.settings.shouldPreventElytraUsage) {
+            return;
+        }
+
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        if (event.isGliding()) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    void onFly(PlayerToggleFlightEvent event) {
+        if (!this.config.settings.shouldPreventFlying) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        if (event.isFlying()) {
+            player.setAllowFlight(false);
+
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler
+    void onDamage(EntityDamageEvent event) {
+        if (!this.config.settings.shouldElytraDisableOnDamage) {
+            return;
+        }
+
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+        UUID uniqueId = player.getUniqueId();
+
+        if (this.fightManager.isInCombat(uniqueId) && player.isGliding()) {
+            player.setGliding(false);
+        }
+    }
+
+    @EventHandler
+    void onOpenInventory(InventoryOpenEvent event) {
+        if (!this.config.settings.shouldPreventInventoryOpening) {
+            return;
+        }
+
+        Player player = (Player) event.getPlayer();
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        event.setCancelled(true);
+
+        this.announcer.sendMessage(player, this.config.messages.inventoryBlockedDuringCombat);
+    }
+
+    @EventHandler
+    void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
+        Player player = event.getPlayer();
+        UUID playerUniqueId = player.getUniqueId();
+
+        if (!this.fightManager.isInCombat(playerUniqueId)) {
+            return;
+        }
+
+        String command = event.getMessage().split(" ")[0].substring(1).toLowerCase();
+
+        boolean isMatchCommand = this.config.settings.blockedCommands.stream()
+            .anyMatch(command::startsWith);
+
+        WhitelistBlacklistMode mode = this.config.settings.commandBlockingMode;
+
+        boolean shouldCancel = mode.shouldBlock(isMatchCommand);
+
+        if (shouldCancel) {
+            event.setCancelled(true);
+            this.announcer.sendMessage(player, this.config.messages.commandDisabledDuringCombat);
+        }
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/controller/FightMessageController.java

@@ -2,25 +2,30 @@ package com.eternalcode.combat.fight.controller;
 
 import com.eternalcode.combat.config.implementation.PluginConfig;
 import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.fight.bossbar.FightBossBarService;
+import com.eternalcode.combat.fight.event.CauseOfUnTag;
 import com.eternalcode.combat.fight.event.FightTagEvent;
 import com.eternalcode.combat.fight.event.FightUntagEvent;
-import com.eternalcode.combat.notification.NoticeService;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
 import org.bukkit.Server;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import panda.utilities.text.Formatter;
 
 public class FightMessageController implements Listener {
 
     private final FightManager fightManager;
-    private final NoticeService noticeService;
+    private final NotificationAnnouncer announcer;
+    private final FightBossBarService bossBarService;
     private final PluginConfig config;
     private final Server server;
 
-    public FightMessageController(FightManager fightManager, NoticeService noticeService, PluginConfig config, Server server) {
+    public FightMessageController(FightManager fightManager, NotificationAnnouncer announcer, FightBossBarService bossBarService, PluginConfig config, Server server) {
         this.fightManager = fightManager;
-        this.noticeService = noticeService;
+        this.announcer = announcer;
+        this.bossBarService = bossBarService;
         this.config = config;
         this.server = server;
     }
@@ -37,10 +42,7 @@ public class FightMessageController implements Listener {
             return;
         }
 
-        this.noticeService.create()
-            .player(player.getUniqueId())
-            .notice(this.config.messagesSettings.playerTagged)
-            .send();
+        this.announcer.sendMessage(player, this.config.messages.playerTagged);
     }
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
@@ -51,10 +53,11 @@ public class FightMessageController implements Listener {
             throw new IllegalStateException("Player cannot be null!");
         }
 
-        this.noticeService.create()
-            .player(player.getUniqueId())
-            .notice(this.config.messagesSettings.playerUntagged)
-            .send();
+        if (!this.fightManager.isInCombat(player.getUniqueId())) {
+            return;
+        }
 
+        this.announcer.sendMessage(player, this.config.messages.playerUntagged);
+        this.bossBarService.hide(event.getPlayer());
     }
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/controller/FightTagController.java

@@ -30,16 +30,11 @@ public class FightTagController implements Listener {
 
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
-        // Thorns are ignored because both users should be in combat from hitting each other
-        if (event.getCause().equals(EntityDamageEvent.DamageCause.THORNS)) {
-            return;
-        }
-
         if (!(event.getEntity() instanceof Player attackedPlayerByPerson)) {
             return;
         }
 
-        List<EntityType> disabledProjectileEntities = this.config.combat.ignoredProjectileTypes;
+        List<EntityType> disabledProjectileEntities = this.config.settings.disabledProjectileEntities;
 
         if (event.getDamager() instanceof Projectile projectile && disabledProjectileEntities.contains(projectile.getType())) {
             return;
@@ -55,7 +50,19 @@ public class FightTagController implements Listener {
             return;
         }
 
-        if (this.config.combat.disableFlying) {
+        Duration combatTime = this.config.settings.combatDuration;
+        UUID attackedUniqueId = attackedPlayerByPerson.getUniqueId();
+        UUID attackerUniqueId = attacker.getUniqueId();
+
+        if (attacker.isOp()) {
+            return;
+        }
+
+        if (attackedPlayerByPerson.isOp() && this.config.settings.excludeAdminFromCombat) {
+            return;
+        }
+
+        if (this.config.settings.shouldPreventFlying) {
             if (attackedPlayerByPerson.isFlying()) {
                 attackedPlayerByPerson.setFlying(false);
                 attackedPlayerByPerson.setAllowFlight(false);
@@ -67,18 +74,13 @@ public class FightTagController implements Listener {
             }
         }
 
-        Duration combatTime = this.config.settings.combatTimerDuration;
-        UUID attackedUniqueId = attackedPlayerByPerson.getUniqueId();
-        UUID attackerUniqueId = attacker.getUniqueId();
-
-        this.fightManager.tag(attackedUniqueId, combatTime, CauseOfTag.PLAYER, attackerUniqueId);
-        this.fightManager.tag(attackerUniqueId, combatTime, CauseOfTag.PLAYER, attackedUniqueId);
+        this.fightManager.tag(attackedUniqueId, combatTime, CauseOfTag.PLAYER);
+        this.fightManager.tag(attackerUniqueId, combatTime, CauseOfTag.PLAYER);
     }
 
-
     @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
     void onEntityDamage(EntityDamageEvent event) {
-        if (!this.config.combat.enableDamageCauseLogging) {
+        if (!this.config.settings.shouldEnableDamageCauses) {
             return;
         }
 
@@ -90,11 +92,12 @@ public class FightTagController implements Listener {
             return;
         }
 
-        Duration combatTime = this.config.settings.combatTimerDuration;
+        Duration combatTime = this.config.settings.combatDuration;
+
         UUID uuid = player.getUniqueId();
 
-        List<EntityDamageEvent.DamageCause> damageCauses = this.config.combat.loggedDamageCauses;
-        WhitelistBlacklistMode mode = this.config.combat.damageCauseRestrictionMode;
+        List<EntityDamageEvent.DamageCause> damageCauses = this.config.settings.damageCausesToLog;
+        WhitelistBlacklistMode mode = this.config.settings.damageCausesMode;
 
         EntityDamageEvent.DamageCause cause = event.getCause();
 
@@ -107,7 +110,6 @@ public class FightTagController implements Listener {
         this.fightManager.tag(uuid, combatTime, CauseOfTag.NON_PLAYER);
     }
 
-
     @Nullable
     Player getDamager(EntityDamageByEntityEvent event) {
         if (event.getDamager() instanceof Player damager) {
@@ -124,10 +126,7 @@ public class FightTagController implements Listener {
     private boolean isPlayerInDisabledWorld(Player player) {
         String worldName = player.getWorld().getName();
 
-        // Treat allowedWorlds as a whitelist: if the world is not listed, consider it disabled
-        return !this.config.settings.allowedWorlds.contains(worldName);
+        return this.config.settings.worldsToIgnore.contains(worldName);
     }
 
-
-
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/controller/FightUnTagController.java

@@ -0,0 +1,58 @@
+package com.eternalcode.combat.fight.controller;
+
+import com.eternalcode.combat.fight.event.CauseOfUnTag;
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.fight.logout.LogoutService;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+
+public class FightUnTagController implements Listener {
+
+    private final FightManager fightManager;
+    private final PluginConfig config;
+    private final LogoutService logoutService;
+
+    public FightUnTagController(FightManager fightManager, PluginConfig config, LogoutService logoutService) {
+        this.fightManager = fightManager;
+        this.config = config;
+        this.logoutService = logoutService;
+    }
+
+    @EventHandler
+    void onPlayerDeath(PlayerDeathEvent event) {
+        Player player = event.getEntity();
+        Player killer = player.getKiller();
+
+        if (!this.fightManager.isInCombat(player.getUniqueId())) {
+            return;
+        }
+
+        CauseOfUnTag cause = this.getDeathCause(player, killer);
+
+        this.fightManager.untag(player.getUniqueId(), cause);
+
+        if (killer != null && this.config.settings.shouldReleaseAttacker) {
+            this.fightManager.untag(killer.getUniqueId(), CauseOfUnTag.ATTACKER_RELEASE);
+        }
+    }
+
+    private CauseOfUnTag getDeathCause(Player player, Player killer) {
+        if (this.logoutService.hasLoggedOut(player.getUniqueId())) {
+            return CauseOfUnTag.LOGOUT;
+        }
+
+        if (killer == null) {
+            return CauseOfUnTag.DEATH;
+        }
+
+        if (this.fightManager.isInCombat(killer.getUniqueId())) {
+            return CauseOfUnTag.DEATH_BY_PLAYER;
+        }
+
+        return CauseOfUnTag.DEATH;
+    }
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/drop/DropKeepInventoryService.java

@@ -1,16 +0,0 @@
-package com.eternalcode.combat.fight.drop;
-
-import java.util.List;
-import java.util.UUID;
-import org.bukkit.inventory.ItemStack;
-
-public interface DropKeepInventoryService {
-
-    List<ItemStack> nextItems(UUID uuid);
-
-    boolean hasItems(UUID uuid);
-
-    void addItems(UUID uuid, List<ItemStack> item);
-
-    void addItem(UUID uuid, ItemStack item);
-}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/drop/DropService.java

@@ -1,8 +0,0 @@
-package com.eternalcode.combat.fight.drop;
-
-public interface DropService {
-
-    DropResult modify(DropType dropType, Drop drop);
-
-    void registerModifier(DropModifier dropModifier);
-}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/effect/FightEffectService.java

@@ -1,25 +1,75 @@
 package com.eternalcode.combat.fight.effect;
 
-import java.util.List;
 import org.bukkit.entity.Player;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
-/**
- * Manages custom potion effects on players during combat.
- * Active effects before combat are stored and restored after combat ends.
- */
-public interface FightEffectService {
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.List;
+import java.util.ArrayList;
 
-    void removeCustomEffect(Player player, PotionEffectType type, Integer amplifier);
+public class FightEffectService {
 
-    void applyCustomEffect(Player player, PotionEffectType type, Integer amplifier);
+    private final Map<UUID, List<PotionEffect>> activeEffects = new HashMap<>();
+    private static final int INFINITE_DURATION = -1;
 
-    List<PotionEffect> getCurrentEffects(Player player);
+    public void storeActiveEffect(Player player, PotionEffect effect) {
+        List<PotionEffect> effects = this.activeEffects.computeIfAbsent(player.getUniqueId(), k -> new ArrayList<>());
 
-    void clearStoredEffects(Player player);
+        effects.add(effect);
+    }
 
-    void restoreActiveEffects(Player player);
+    public void restoreActiveEffects(Player player) {
+        List<PotionEffect> currentEffects = this.getCurrentEffects(player);
 
-    void storeActiveEffect(Player player, PotionEffect effect);
+        for (PotionEffect effect : currentEffects) {
+            player.addPotionEffect(effect);
+        }
+
+        this.clearStoredEffects(player);
+    }
+
+    public void clearStoredEffects(Player player) {
+        this.activeEffects.remove(player.getUniqueId());
+    }
+
+    public List<PotionEffect> getCurrentEffects(Player player) {
+        return this.activeEffects.getOrDefault(player.getUniqueId(), new ArrayList<>());
+    }
+
+    public void applyCustomEffect(Player player, PotionEffectType type, Integer amplifier) {
+        PotionEffect activeEffect = player.getPotionEffect(type);
+
+        if (activeEffect == null) {
+            player.addPotionEffect(new PotionEffect(type, INFINITE_DURATION, amplifier));
+            return;
+        }
+
+        if (activeEffect.getAmplifier() > amplifier) {
+            return;
+        }
+
+        if (activeEffect.getDuration() == -1) {
+            return;
+        }
+
+        this.storeActiveEffect(player, activeEffect);
+        player.addPotionEffect(new PotionEffect(type, INFINITE_DURATION, amplifier));
+    }
+
+    public void removeCustomEffect(Player player, PotionEffectType type, Integer amplifier) {
+        PotionEffect activeEffect = player.getPotionEffect(type);
+
+        if (activeEffect == null) {
+            return;
+        }
+
+        if (activeEffect.getAmplifier() != amplifier) {
+            return;
+        }
+
+        player.removePotionEffect(type);
+    }
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/event/CancelTagReason.java

@@ -1,10 +0,0 @@
-package com.eternalcode.combat.fight.event;
-
-public enum CancelTagReason {
-
-    TAGOUT,
-    PERMISSION_BYPASS,
-    ADMIN,
-    CREATIVE_MODE,
-
-}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/event/CauseOfTag.java

@@ -1,30 +1,8 @@
 package com.eternalcode.combat.fight.event;
 
 public enum CauseOfTag {
-
-    /**
-     * The player was tagged in combat as a result of an attack by another player.
-     */
     PLAYER,
-
-    /**
-     * The player was tagged in combat due to an interaction with a non-player entity
-     * (e.g., mobs or environmental damage).
-     */
     NON_PLAYER,
-
-    /**
-     * A command was executed to apply a combat tag to the player.
-     */
     COMMAND,
-
-    /**
-     * Crystal or anchor explosion caused the tag.
-     */
-    CRYSTAL,
-
-    /**
-     * A custom cause, typically defined by external plugins or systems, applied the combat tag.
-     */
     CUSTOM
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/event/CauseOfUnTag.java

@@ -1,43 +1,11 @@
 package com.eternalcode.combat.fight.event;
 
 public enum CauseOfUnTag {
-    /**
-     * The combat tag expired after a set duration.
-     */
     TIME_EXPIRED,
-
-    /**
-     * The player died, which resulted in the removal of the combat tag.
-     */
     DEATH,
-
-    /**
-     * The player was killed by another player, causing the combat tag to be removed.
-     */
     DEATH_BY_PLAYER,
-
-    /**
-     * The player logged out, triggering the removal of the combat tag.
-     */
     LOGOUT,
-
-    /**
-     * A command was executed to remove the player's combat tag.
-     */
     COMMAND,
-
-    /**
-     * The attacker released the player, ending the combat and removing the tag.
-     */
     ATTACKER_RELEASE,
-
-    /**
-     * All of the player's combat opponents logged out, so there was nobody left to fight.
-     */
-    OPPONENT_LOGOUT,
-
-    /**
-     * A custom cause, typically defined by external plugins or systems.
-     */
     CUSTOM
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/event/FightTagEvent.java

@@ -5,80 +5,59 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
 import java.util.UUID;
-import org.jetbrains.annotations.NotNull;
 
-/**
- * This event is triggered when a player is tagged in a fight.
- */
 public class FightTagEvent extends Event implements Cancellable {
 
-    private static final HandlerList HANDLER_LIST = new HandlerList();
+    private static final HandlerList handlers = new HandlerList();
     private final UUID player;
     private final CauseOfTag cause;
-    private boolean cancelled = false;
-    private CancelTagReason cancelReason;
+    private boolean isCancelled = false;
+    private String cancelMessage = "";
 
     public FightTagEvent(UUID player, CauseOfTag cause) {
-        super(false);
-
         this.player = player;
         this.cause = cause;
     }
 
-    /**
-     * Gets the UUID of the player who was tagged.
-     *
-     * @return The UUID of the tagged player.
-     */
     public UUID getPlayer() {
         return this.player;
     }
 
-    /**
-     * Gets the reason why the player was tagged.
-     *
-     * @return The cause of the combat tag as a {@link CauseOfTag}.
-     */
     public CauseOfTag getCause() {
         return this.cause;
     }
 
     @Override
     public boolean isCancelled() {
-        return this.cancelled;
+        return this.isCancelled;
     }
 
     @Override
     public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
+        throw new UnsupportedOperationException("Use #cancel(String) instead");
     }
 
-    /**
-     * Gets the reason why the event was cancelled.
-     *
-     * @return The cancel reason.
-     */
-    public CancelTagReason getCancelReason() {
-        return this.cancelReason;
+    public void cancel(String cancelMessage) {
+        this.isCancelled = true;
+        this.cancelMessage = cancelMessage;
     }
 
-    /**
-     * Sets the reason why the event was cancelled.
-     *
-     * @param cancelReason The cancel reason.
-     */
-    public void setCancelReason(CancelTagReason cancelReason) {
-        this.cancelReason = cancelReason;
+    public void allow() {
+        this.isCancelled = false;
+        this.cancelMessage = "";
+    }
+
+    public String getCancelMessage() {
+        return this.cancelMessage;
     }
 
-    @NotNull
     @Override
     public HandlerList getHandlers() {
-        return HANDLER_LIST;
+        return handlers;
     }
 
     public static HandlerList getHandlerList() {
-        return HANDLER_LIST;
+        return handlers;
     }
 
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/event/FightUntagEvent.java

@@ -5,61 +5,43 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
 import java.util.UUID;
-import org.jetbrains.annotations.NotNull;
 
-/**
- * This event is triggered when a player is untagged during a fight.
- */
 public class FightUntagEvent extends Event implements Cancellable {
 
-    private static final HandlerList HANDLER_LIST = new HandlerList();
-
+    private static final HandlerList handlers = new HandlerList();
     private final UUID player;
     private final CauseOfUnTag cause;
-    private boolean cancelled;
+    private boolean isCancelled = false;
 
     public FightUntagEvent(UUID player, CauseOfUnTag cause) {
-        super(false);
-
         this.player = player;
         this.cause = cause;
     }
 
-    /**
-     * Gets the UUID of the player who was untagged.
-     *
-     * @return The UUID of the untagged player.
-     */
     public UUID getPlayer() {
         return this.player;
     }
-
-    /**
-     * Gets the reason for why the player was untagged.
-     *
-     * @return The cause of untagging as a {@link CauseOfUnTag}.
-     */
+    
     public CauseOfUnTag getCause() {
         return this.cause;
     }
 
     @Override
     public boolean isCancelled() {
-        return this.cancelled;
+        return this.isCancelled;
     }
 
     @Override
     public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
+        this.isCancelled = cancelled;
     }
 
-    @NotNull
     @Override
     public HandlerList getHandlers() {
-        return HANDLER_LIST;
+        return handlers;
     }
 
     public static HandlerList getHandlerList() {
-        return HANDLER_LIST;
+        return handlers;
     }
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/logout/LogoutController.java

@@ -0,0 +1,47 @@
+package com.eternalcode.combat.fight.logout;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import panda.utilities.text.Formatter;
+
+public class LogoutController implements Listener {
+
+    private final FightManager fightManager;
+    private final LogoutService logoutService;
+    private final NotificationAnnouncer announcer;
+    private final PluginConfig config;
+
+
+    public LogoutController(FightManager fightManager, LogoutService logoutService, NotificationAnnouncer announcer, PluginConfig config) {
+        this.fightManager = fightManager;
+        this.logoutService = logoutService;
+        this.announcer = announcer;
+        this.config = config;
+    }
+
+    @EventHandler(priority = EventPriority.HIGH)
+    void onQuit(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+
+        if (!this.fightManager.isInCombat(player.getUniqueId())) {
+            return;
+        }
+
+        this.logoutService.punishForLogout(player);
+        player.setHealth(0.0);
+
+        Formatter formatter = new Formatter()
+                .register("{PLAYER}", player.getName());
+
+        String format = formatter.format(this.config.messages.playerLoggedOutDuringCombat);
+        this.announcer.broadcast(format);
+
+    }
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/pearl/FightPearlController.java

@@ -0,0 +1,101 @@
+package com.eternalcode.combat.fight.pearl;
+
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import com.eternalcode.combat.util.DurationUtil;
+import org.bukkit.Material;
+import org.bukkit.entity.EnderPearl;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import panda.utilities.text.Formatter;
+
+import java.time.Duration;
+import java.util.UUID;
+
+public class FightPearlController implements Listener {
+
+    private final FightPearlSettings settings;
+    private final NotificationAnnouncer announcer;
+    private final FightManager fightManager;
+    private final FightPearlManager fightPearlManager;
+
+    public FightPearlController(FightPearlSettings settings, NotificationAnnouncer announcer, FightManager fightManager, FightPearlManager fightPearlManager) {
+        this.settings = settings;
+        this.announcer = announcer;
+        this.fightManager = fightManager;
+        this.fightPearlManager = fightPearlManager;
+    }
+
+    @EventHandler
+    void onInteract(PlayerInteractEvent event) {
+        Player player = event.getPlayer();
+        UUID uniqueId = player.getUniqueId();
+
+        if (!this.settings.pearlThrowBlocked) {
+            return;
+        }
+
+        if (!this.fightManager.isInCombat(uniqueId)) {
+            return;
+        }
+
+        ItemStack item = event.getItem();
+        if (item == null || item.getType() != Material.ENDER_PEARL) {
+            return;
+        }
+
+        Action action = event.getAction();
+        if (action != Action.RIGHT_CLICK_AIR && action != Action.RIGHT_CLICK_BLOCK) {
+            return;
+        }
+
+        if (this.settings.pearlThrowDelay.isZero()) {
+            event.setCancelled(true);
+            this.announcer.sendMessage(player, this.settings.pearlThrowBlockedDuringCombat);
+            return;
+        }
+
+        if (this.fightPearlManager.hasDelay(uniqueId)) {
+            event.setCancelled(true);
+
+            Duration remainingPearlDelay = this.fightPearlManager.getRemainingDelay(uniqueId);
+
+            Formatter formatter = new Formatter()
+                .register("{TIME}", DurationUtil.format(remainingPearlDelay));
+
+            String format = formatter.format(this.settings.pearlThrowBlockedDelayDuringCombat);
+            this.announcer.sendMessage(player, format);
+            return;
+        }
+
+        this.fightPearlManager.markDelay(uniqueId);
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    void onEntityDamage(EntityDamageByEntityEvent event) {
+        if (this.settings.pearlThrowDamageEnabled) {
+            return;
+        }
+
+        if (!(event.getEntity() instanceof Player)) {
+            return;
+        }
+
+        if (!(event.getDamager() instanceof EnderPearl)) {
+            return;
+        }
+
+        if (event.getCause() != EntityDamageEvent.DamageCause.FALL) {
+            return;
+        }
+
+        event.setDamage(0.0D);
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/pearl/FightPearlManager.java

@@ -0,0 +1,37 @@
+package com.eternalcode.combat.fight.pearl;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.UUID;
+
+public class FightPearlManager {
+
+    private final FightPearlSettings pearlSettings;
+    private final Cache<UUID, Instant> pearlDelays;
+
+    public FightPearlManager(FightPearlSettings pearlSettings) {
+        this.pearlSettings = pearlSettings;
+        this.pearlDelays = Caffeine.newBuilder()
+            .expireAfterWrite(pearlSettings.pearlThrowDelay)
+            .build();
+    }
+
+    public void markDelay(UUID uuid) {
+        this.pearlDelays.put(uuid, Instant.now().plus(this.pearlSettings.pearlThrowDelay));
+    }
+
+    public boolean hasDelay(UUID uuid) {
+        return Instant.now().isBefore(this.getDelay(uuid));
+    }
+
+    public Duration getRemainingDelay(UUID uuid) {
+        return Duration.between(Instant.now(), this.getDelay(uuid));
+    }
+
+    public Instant getDelay(UUID uuid) {
+        return this.pearlDelays.asMap().getOrDefault(uuid, Instant.MIN);
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/pearl/FightPearlService.java

@@ -1,16 +0,0 @@
-package com.eternalcode.combat.fight.pearl;
-
-import java.time.Duration;
-import java.time.Instant;
-import java.util.UUID;
-
-public interface FightPearlService {
-
-    Instant getDelay(UUID uuid);
-
-    Duration getRemainingDelay(UUID uuid);
-
-    boolean hasDelay(UUID uuid);
-
-    void markDelay(UUID uuid);
-}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/pearl/FightPearlSettings.java

@@ -0,0 +1,29 @@
+package com.eternalcode.combat.fight.pearl;
+
+import eu.okaeri.configs.OkaeriConfig;
+import eu.okaeri.configs.annotation.Comment;
+
+import java.time.Duration;
+
+public class FightPearlSettings extends OkaeriConfig {
+
+    @Comment({ "# Is pearl damage to be enabled?", "# This will work globally" })
+    public boolean pearlThrowDamageEnabled = true;
+
+    @Comment("# Set true, If you want to lock pearls during the combat")
+    public boolean pearlThrowBlocked = false;
+
+    @Comment({
+        "# Block throwing pearls with delay?",
+        "# If you set this to for example 3s, player will have to wait 3 seconds before throwing another pearl",
+        "# Set to 0 to disable"
+    })
+    public Duration pearlThrowDelay = Duration.ofSeconds(3);
+
+    @Comment("# Message sent when player tries to throw ender pearl, but are disabled")
+    public String pearlThrowBlockedDuringCombat = "&cThrowing ender pearls is prohibited during combat!";
+
+    @Comment("# Message sent when player tries to throw ender pearl, but has delay")
+    public String pearlThrowBlockedDelayDuringCombat = "&cYou must wait {TIME} before next throw!";
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/tagout/FightTagOutController.java

@@ -1,6 +1,6 @@
 package com.eternalcode.combat.fight.tagout;
 
-import com.eternalcode.combat.fight.event.CancelTagReason;
+import com.eternalcode.combat.config.implementation.PluginConfig;
 import com.eternalcode.combat.fight.event.FightTagEvent;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -10,9 +10,11 @@ import java.util.UUID;
 public class FightTagOutController implements Listener {
 
     private final FightTagOutService tagOutService;
+    private final PluginConfig config;
 
-    public FightTagOutController(FightTagOutService tagOutService) {
+    public FightTagOutController(FightTagOutService tagOutService, PluginConfig config) {
         this.tagOutService = tagOutService;
+        this.config = config;
     }
 
     @EventHandler
@@ -20,8 +22,7 @@ public class FightTagOutController implements Listener {
         UUID uniqueId = event.getPlayer();
 
         if (this.tagOutService.isTaggedOut(uniqueId)) {
-            event.setCancelReason(CancelTagReason.TAGOUT);
-            event.setCancelled(true);
+            event.cancel(this.config.messages.admin.adminTagOutCanceled);
         }
     }
 

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/tagout/FightTagOutService.java

@@ -1,13 +1,34 @@
 package com.eternalcode.combat.fight.tagout;
 
 import java.time.Duration;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.UUID;
 
-public interface FightTagOutService {
+public class FightTagOutService {
 
-    boolean isTaggedOut(UUID player);
+    private final Map<UUID, Instant> tagOuts = new HashMap<>();
 
-    void unTagOut(UUID player);
+    public void tagOut(UUID player, Duration duration) {
+        Instant endTime = Instant.now().plus(duration);
+
+        this.tagOuts.put(player, endTime);
+    }
+
+    public void unTagOut(UUID player) {
+        this.tagOuts.remove(player);
+    }
+
+    public boolean isTaggedOut(UUID player) {
+        Instant endTime = this.tagOuts.get(player);
+
+        if (endTime == null) {
+            return false;
+        }
+        Instant now = Instant.now();
+
+        return now.isBefore(endTime);
+    }
 
-    void tagOut(UUID player, Duration duration);
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/fight/tagout/TagOutCommand.java

@@ -0,0 +1,94 @@
+package com.eternalcode.combat.fight.tagout;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import com.eternalcode.combat.util.DurationUtil;
+import dev.rollczi.litecommands.argument.Arg;
+import dev.rollczi.litecommands.command.execute.Execute;
+import dev.rollczi.litecommands.command.permission.Permission;
+import dev.rollczi.litecommands.command.route.Route;
+import org.bukkit.entity.Player;
+import panda.utilities.text.Formatter;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.UUID;
+
+@Route(name = "tagout", aliases = "tagimmunity")
+public class TagOutCommand {
+
+    private final FightTagOutService fightTagOutService;
+    private final NotificationAnnouncer announcer;
+    private final PluginConfig config;
+
+    public TagOutCommand(FightTagOutService fightTagOutService, NotificationAnnouncer announcer, PluginConfig config) {
+        this.fightTagOutService = fightTagOutService;
+        this.announcer = announcer;
+        this.config = config;
+    }
+
+    @Execute(required = 1)
+    @Permission("eternalcombat.tagout")
+    void tagout(Player sender, @Arg Duration time) {
+        UUID targetUniqueId = sender.getUniqueId();
+
+        Formatter formatter = new Formatter()
+            .register("{PLAYER}", sender.getName())
+            .register("{TIME}", DurationUtil.format(time));
+
+        this.fightTagOutService.tagOut(targetUniqueId, time);
+
+        String format = formatter.format(this.config.messages.admin.adminTagOutSelf);
+        this.announcer.sendMessage(sender, format);
+    }
+
+    @Execute(required = 2)
+    @Permission("eternalcombat.tagout")
+    void tagout(Player sender, @Arg Player target, @Arg Duration time) {
+        UUID targetUniqueId = target.getUniqueId();
+
+        Instant now = Instant.now();
+        Duration remaining = Duration.between(now, now.plus(time));
+
+        Formatter formatter = new Formatter()
+            .register("{PLAYER}", target.getName())
+            .register("{TIME}", DurationUtil.format(remaining));
+
+        this.fightTagOutService.tagOut(targetUniqueId, time);
+
+        String adminTagOutFormat = formatter.format(this.config.messages.admin.adminTagOut);
+        this.announcer.sendMessage(sender, adminTagOutFormat);
+
+        String playerTagOutFormat = formatter.format(this.config.messages.admin.playerTagOut);
+        this.announcer.sendMessage(target, playerTagOutFormat);
+    }
+
+    @Execute(route = "remove", required = 1)
+    @Permission("eternalcombat.tagout")
+    void untagout(Player sender, @Arg Player target) {
+        UUID targetUniqueId = target.getUniqueId();
+
+        this.fightTagOutService.unTagOut(targetUniqueId);
+
+        Formatter formatter = new Formatter()
+            .register("{PLAYER}", target.getName());
+
+        if (!targetUniqueId.equals(sender.getUniqueId())) {
+            String adminUnTagOutFormat = formatter.format(this.config.messages.admin.adminTagOutOff);
+            this.announcer.sendMessage(sender, adminUnTagOutFormat);
+        }
+
+        this.announcer.sendMessage(target, this.config.messages.admin.playerTagOutOff);
+    }
+
+    @Execute(route = "remove", required = 0)
+    @Permission("eternalcombat.tagout")
+    void untagout(Player sender) {
+        UUID senderUniqueId = sender.getUniqueId();
+
+        this.fightTagOutService.unTagOut(senderUniqueId);
+
+        this.announcer.sendMessage(sender, this.config.messages.admin.playerTagOutOff);
+    }
+}
+

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/Notification.java

@@ -0,0 +1,8 @@
+package com.eternalcode.combat.notification;
+
+public interface Notification {
+
+    String message();
+
+    NotificationType type();
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/NotificationAnnouncer.java

@@ -0,0 +1,79 @@
+package com.eternalcode.combat.notification;
+
+import com.eternalcode.combat.notification.implementation.BossBarNotification;
+import net.kyori.adventure.audience.Audience;
+import net.kyori.adventure.bossbar.BossBar;
+import net.kyori.adventure.platform.AudienceProvider;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.title.Title;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import panda.utilities.text.Formatter;
+
+public final class NotificationAnnouncer {
+
+    private final AudienceProvider audienceProvider;
+    private final MiniMessage miniMessage;
+
+    public NotificationAnnouncer(AudienceProvider audienceProvider, MiniMessage miniMessage) {
+        this.audienceProvider = audienceProvider;
+        this.miniMessage = miniMessage;
+    }
+
+    public void send(CommandSender sender, Notification notification, Formatter formatter) {
+        Audience audience = this.audience(sender);
+        Component message = this.miniMessage.deserialize(formatter.format(notification.message()));
+
+        NotificationType type = notification.type();
+
+        switch (type) {
+            case CHAT -> audience.sendMessage(message);
+            case ACTION_BAR -> audience.sendActionBar(message);
+
+            case TITLE -> {
+                Title title = Title.title(message, Component.empty());
+
+                audience.showTitle(title);
+            }
+
+            case SUB_TITLE -> {
+                Title subTitle = Title.title(Component.empty(), message);
+
+                audience.showTitle(subTitle);
+            }
+
+            case BOSS_BAR -> {
+                BossBarNotification bossBarNotification = (BossBarNotification) notification;
+
+                BossBar bossBar = bossBarNotification.create(message);
+
+                audience.showBossBar(bossBar);
+            }
+
+            default -> throw new IllegalStateException("Unknown notification type: " + type);
+        }
+    }
+
+    public void sendMessage(CommandSender commandSender, String text) {
+        Audience audience = this.audience(commandSender);
+        Component message = this.miniMessage.deserialize(text);
+
+        audience.sendMessage(message);
+    }
+
+    public void broadcast(String text) {
+        Audience audience = this.audienceProvider.all();
+        Component message = this.miniMessage.deserialize(text);
+
+        audience.sendMessage(message);
+    }
+
+    private Audience audience(CommandSender sender) {
+        if (sender instanceof Player player) {
+            return this.audienceProvider.player(player.getUniqueId());
+        }
+
+        return this.audienceProvider.console();
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/NotificationType.java

@@ -0,0 +1,9 @@
+package com.eternalcode.combat.notification;
+
+public enum NotificationType {
+    CHAT,
+    ACTION_BAR,
+    TITLE,
+    SUB_TITLE,
+    BOSS_BAR
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/implementation/ActionBarNotification.java

@@ -0,0 +1,12 @@
+package com.eternalcode.combat.notification.implementation;
+
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.NotificationType;
+
+public record ActionBarNotification(String message) implements Notification {
+
+    @Override
+    public NotificationType type() {
+        return NotificationType.ACTION_BAR;
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/implementation/BossBarNotification.java

@@ -0,0 +1,20 @@
+package com.eternalcode.combat.notification.implementation;
+
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.NotificationType;
+import net.kyori.adventure.bossbar.BossBar;
+import net.kyori.adventure.text.Component;
+
+public record BossBarNotification(String message, float progress, BossBar.Color color, BossBar.Overlay overlay) implements Notification {
+
+    public BossBar create(Component name) {
+        float replacedProgress = this.progress < 0.0F ? BossBar.MAX_PROGRESS : this.progress;
+
+        return BossBar.bossBar(name, replacedProgress, this.color, this.overlay);
+    }
+
+    @Override
+    public NotificationType type() {
+        return NotificationType.BOSS_BAR;
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/implementation/ChatNotification.java

@@ -0,0 +1,12 @@
+package com.eternalcode.combat.notification.implementation;
+
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.NotificationType;
+
+public record ChatNotification(String message) implements Notification {
+
+    @Override
+    public NotificationType type() {
+        return NotificationType.CHAT;
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/implementation/SubTitleNotification.java

@@ -0,0 +1,12 @@
+package com.eternalcode.combat.notification.implementation;
+
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.NotificationType;
+
+public record SubTitleNotification(String message) implements Notification {
+
+    @Override
+    public NotificationType type() {
+        return NotificationType.SUB_TITLE;
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/implementation/TitleNotification.java

@@ -0,0 +1,12 @@
+package com.eternalcode.combat.notification.implementation;
+
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.NotificationType;
+
+public record TitleNotification(String message) implements Notification {
+
+    @Override
+    public NotificationType type() {
+        return NotificationType.TITLE;
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/notification/serializer/NotificationSerializer.java

@@ -0,0 +1,64 @@
+package com.eternalcode.combat.notification.serializer;
+
+import com.eternalcode.combat.notification.Notification;
+import com.eternalcode.combat.notification.NotificationType;
+import com.eternalcode.combat.notification.implementation.ActionBarNotification;
+import com.eternalcode.combat.notification.implementation.BossBarNotification;
+import com.eternalcode.combat.notification.implementation.ChatNotification;
+import com.eternalcode.combat.notification.implementation.SubTitleNotification;
+import com.eternalcode.combat.notification.implementation.TitleNotification;
+import eu.okaeri.configs.schema.GenericsDeclaration;
+import eu.okaeri.configs.serdes.DeserializationData;
+import eu.okaeri.configs.serdes.ObjectSerializer;
+import eu.okaeri.configs.serdes.SerializationData;
+import net.kyori.adventure.bossbar.BossBar;
+import org.checkerframework.checker.nullness.qual.NonNull;
+
+import java.util.Optional;
+
+public class NotificationSerializer implements ObjectSerializer<Notification> {
+    
+    @Override
+    public boolean supports(@NonNull Class<? super Notification> type) {
+        return Notification.class.isAssignableFrom(type);
+    }
+
+    @Override
+    public void serialize(@NonNull Notification notification, @NonNull SerializationData data, @NonNull GenericsDeclaration generics) {
+        data.add("type", notification.type(), NotificationType.class);
+        data.add("message", notification.message(), String.class);
+
+        if (notification instanceof BossBarNotification bossBarNotification) {
+            data.add("progress", bossBarNotification.progress(), float.class);
+            data.add("color", bossBarNotification.color(), BossBar.Color.class);
+            data.add("overlay", bossBarNotification.overlay(), BossBar.Overlay.class);
+        }
+    }
+
+    @Override
+    public Notification deserialize(@NonNull DeserializationData data, @NonNull GenericsDeclaration generics) {
+        NotificationType type = data.get("type", NotificationType.class);
+        String message = data.get("message", String.class);
+
+        return switch (type) {
+            case CHAT -> new ChatNotification(message);
+            case ACTION_BAR -> new ActionBarNotification(message);
+
+            case TITLE -> new TitleNotification(message);
+            case SUB_TITLE -> new SubTitleNotification(message);
+
+            case BOSS_BAR -> {
+                float progress = Optional.ofNullable(data.get("progress", float.class))
+                    .orElse(BossBar.MAX_PROGRESS);
+
+                BossBar.Color color = Optional.ofNullable(data.get("color", BossBar.Color.class))
+                    .orElse(BossBar.Color.RED);
+
+                BossBar.Overlay overlay = Optional.ofNullable(data.get("overlay", BossBar.Overlay.class))
+                    .orElse(BossBar.Overlay.PROGRESS);
+
+                yield new BossBarNotification(message, progress, color, overlay);
+            }
+        };
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/region/DefaultRegionProvider.java

@@ -0,0 +1,41 @@
+package com.eternalcode.combat.region;
+
+import org.bukkit.Location;
+
+public class DefaultRegionProvider implements RegionProvider {
+
+    private final int radius;
+
+    public DefaultRegionProvider(int radius) {
+        this.radius = radius;
+    }
+
+    @Override
+    public boolean isInRegion(Location location) {
+        Location spawnLocation = location.getWorld().getSpawnLocation();
+        double x = spawnLocation.getX();
+        double z = spawnLocation.getZ();
+
+        Point min = new Point(x - this.radius, z - this.radius);
+        Point max = new Point(x + this.radius, z + this.radius);
+
+        return this.contains(min, max, location.getX(), location.getZ());
+    }
+
+    @Override
+    public Location getRegionCenter(Location location) {
+        Location spawnLocation = location.getWorld().getSpawnLocation();
+        double x = spawnLocation.getX();
+        double z = spawnLocation.getZ();
+
+        return new Location(location.getWorld(), x, location.getY(), z);
+    }
+
+    public boolean contains(Point min, Point max, double x, double z) {
+        return x >= min.x() && x < max.x()
+            && z >= min.z() && z < max.z();
+    }
+
+    public record Point(double x, double z) {}
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/region/Point.java

@@ -1,6 +0,0 @@
-package com.eternalcode.combat.region;
-
-import org.bukkit.World;
-
-public record Point(World world, double x, double z) {
-}

eternalcombat-api/src/main/java/com/eternalcode/combat/region/Region.java

@@ -1,25 +0,0 @@
-package com.eternalcode.combat.region;
-
-import org.bukkit.Location;
-
-public interface Region {
-
-    Point getCenter();
-
-    Location getMin();
-
-    Location getMax();
-
-    default boolean contains(Location location) {
-        return this.contains(location.getX(), location.getY(), location.getZ());
-    }
-
-    default boolean contains(double x, double y, double z) {
-        Location min = this.getMin();
-        Location max = this.getMax();
-        return x >= min.getX() && x < max.getX()
-            && y >= min.getY() && y < max.getY()
-            && z >= min.getZ() && z < max.getZ();
-    }
-
-}

eternalcombat-api/src/main/java/com/eternalcode/combat/region/RegionController.java

@@ -0,0 +1,78 @@
+package com.eternalcode.combat.region;
+
+import com.eternalcode.combat.config.implementation.PluginConfig;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.util.Vector;
+
+public class RegionController implements Listener {
+
+    private final NotificationAnnouncer announcer;
+    private final RegionProvider regionProvider;
+    private final FightManager fightManager;
+    private final PluginConfig pluginConfig;
+
+    public RegionController(NotificationAnnouncer announcer, RegionProvider regionProvider, FightManager fightManager, PluginConfig pluginConfig) {
+        this.announcer = announcer;
+        this.regionProvider = regionProvider;
+        this.fightManager = fightManager;
+        this.pluginConfig = pluginConfig;
+    }
+
+    @EventHandler
+    void onPlayerMove(PlayerMoveEvent event) {
+        Player player = event.getPlayer();
+
+        if (!this.fightManager.isInCombat(player.getUniqueId())) {
+            return;
+        }
+
+        Location locationTo = event.getTo();
+        int xTo = locationTo.getBlockX();
+        int yTo = locationTo.getBlockY();
+        int zTo = locationTo.getBlockZ();
+
+        Location locationFrom = event.getFrom();
+        int xFrom = locationFrom.getBlockX();
+        int yFrom = locationFrom.getBlockY();
+        int zFrom = locationFrom.getBlockZ();
+
+        if (xTo != xFrom || yTo != yFrom || zTo != zFrom) {
+            if (!this.regionProvider.isInRegion(locationTo)) {
+                return;
+            }
+
+            Location spawnLocation = this.regionProvider.getRegionCenter(locationTo);
+            Location playerLocation = player.getLocation().subtract(spawnLocation);
+            double distance = playerLocation.distance(spawnLocation);
+            Vector knockback = new Vector(0, 3, 0).multiply(this.pluginConfig.settings.blockedRegionKnockMultiplier / distance);
+            Vector vector = playerLocation.toVector().add(knockback);
+
+            player.setVelocity(vector);
+
+            this.announcer.sendMessage(player, this.pluginConfig.messages.cantEnterOnRegion);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerTeleport(PlayerTeleportEvent event) {
+        Player player = event.getPlayer();
+
+        if (!this.fightManager.isInCombat(player.getUniqueId())) {
+            return;
+        }
+
+        Location targetLocation = event.getTo();
+
+        if (this.regionProvider.isInRegion(targetLocation)) {
+            event.setCancelled(true);
+            this.announcer.sendMessage(player, this.pluginConfig.messages.cantEnterOnRegion);
+        }
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/region/RegionProvider.java

@@ -1,18 +1,11 @@
 package com.eternalcode.combat.region;
 
-import java.util.Collection;
-import java.util.Optional;
 import org.bukkit.Location;
-import org.bukkit.World;
 
 public interface RegionProvider {
 
-    Optional<Region> getRegion(Location location);
+    boolean isInRegion(Location location);
 
-    default boolean isInRegion(Location location) {
-        return this.getRegion(location).isPresent();
-    }
-
-    Collection<Region> getRegions(World world);
+    Location getRegionCenter(Location location);
 
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/region/WorldGuardRegionProvider.java

@@ -0,0 +1,69 @@
+package com.eternalcode.combat.region;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+import com.sk89q.worldguard.protection.regions.RegionContainer;
+import com.sk89q.worldguard.protection.regions.RegionQuery;
+import org.bukkit.Location;
+
+import java.util.List;
+
+public class WorldGuardRegionProvider implements RegionProvider {
+
+    private final List<String> regions;
+
+    public WorldGuardRegionProvider(List<String> regions) {
+        this.regions = regions;
+    }
+
+    @Override
+    public boolean isInRegion(Location location) {
+        return this.regions.stream().anyMatch(region -> this.isInCombatRegion(location, region));
+    }
+
+    @Override
+    public Location getRegionCenter(Location location) {
+        RegionContainer regionContainer = WorldGuard.getInstance().getPlatform().getRegionContainer();
+        RegionQuery regionQuery = regionContainer.createQuery();
+        ApplicableRegionSet applicableRegions = regionQuery.getApplicableRegions(BukkitAdapter.adapt(location));
+
+        double minX = 0;
+        double maxX = 0;
+        double minZ = 0;
+        double maxZ = 0;
+
+        for (ProtectedRegion region : applicableRegions.getRegions()) {
+            BlockVector3 min = region.getMinimumPoint();
+            BlockVector3 max = region.getMaximumPoint();
+
+            if (min.getX() < minX) {
+                minX = min.getX();
+            }
+            if (max.getX() > maxX) {
+                maxX = max.getX();
+            }
+            if (min.getZ() < minZ) {
+                minZ = min.getZ();
+            }
+            if (max.getZ() > maxZ) {
+                maxZ = max.getZ();
+            }
+        }
+
+        double x = (maxX - minX) / 2 + minX;
+        double z = (maxZ - minZ) / 2 + minZ;
+
+        return new Location(location.getWorld(), x, location.getY(), z);
+    }
+
+    private boolean isInCombatRegion(Location location, String regionName) {
+        RegionContainer regionContainer = WorldGuard.getInstance().getPlatform().getRegionContainer();
+        RegionQuery regionQuery = regionContainer.createQuery();
+        ApplicableRegionSet applicableRegions = regionQuery.getApplicableRegions(BukkitAdapter.adapt(location));
+
+        return applicableRegions.getRegions().stream().anyMatch(region -> region.getId().equalsIgnoreCase(regionName));
+    }
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/updater/UpdaterNotificationController.java

@@ -1,7 +1,6 @@
 package com.eternalcode.combat.updater;
 
 import com.eternalcode.combat.config.implementation.PluginConfig;
-import com.eternalcode.commons.concurrent.FutureHandler;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.platform.AudienceProvider;
 import net.kyori.adventure.text.minimessage.MiniMessage;
@@ -10,9 +9,12 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 
+import java.util.concurrent.CompletableFuture;
+
 public class UpdaterNotificationController implements Listener {
 
     private static final String NEW_VERSION_AVAILABLE = "<b><gradient:#8a1212:#fc6b03>EternalCombat:</gradient></b> <color:#fce303>New version of EternalCombat is available, please update!";
+    private static final String RECEIVE_UPDATES_PERMISSION = "eternalcombat.receiveupdates";
 
     private final UpdaterService updaterService;
     private final PluginConfig pluginConfig;
@@ -31,21 +33,23 @@ public class UpdaterNotificationController implements Listener {
         Player player = event.getPlayer();
         Audience audience = this.audienceProvider.player(player.getUniqueId());
 
-        if (!shouldNotify(player)) {
+        if (!player.hasPermission(RECEIVE_UPDATES_PERMISSION) || !this.pluginConfig.settings.shouldReceivePluginUpdates) {
             return;
         }
 
-        this.updaterService.checkForUpdate()
-            .thenAccept(result -> {
-                if (result.isUpdateAvailable()) {
-                    audience.sendMessage(this.miniMessage.deserialize(NEW_VERSION_AVAILABLE));
-                }
-            })
-            .exceptionally(FutureHandler::handleException);
-    }
+        CompletableFuture<Boolean> upToDate = this.updaterService.isUpToDate();
 
-    private boolean shouldNotify(Player player) {
-        return player.hasPermission("eternalcombat.receiveupdates") && this.pluginConfig.settings.notifyAboutUpdates;
+        upToDate.whenComplete((isUpToDate, throwable) -> {
+            if (throwable != null) {
+                throwable.printStackTrace();
+
+                return;
+            }
+
+            if (!isUpToDate) {
+                audience.sendMessage(this.miniMessage.deserialize(NEW_VERSION_AVAILABLE));
+            }
+        });
     }
 
 }

eternalcombat-api/src/main/java/com/eternalcode/combat/updater/UpdaterService.java

@@ -0,0 +1,35 @@
+package com.eternalcode.combat.updater;
+
+import com.eternalcode.gitcheck.GitCheck;
+import com.eternalcode.gitcheck.GitCheckResult;
+import com.eternalcode.gitcheck.git.GitRepository;
+import com.eternalcode.gitcheck.git.GitTag;
+import org.bukkit.plugin.PluginDescriptionFile;
+import panda.std.Lazy;
+
+import java.util.concurrent.CompletableFuture;
+
+public class UpdaterService {
+
+    private static final GitRepository GIT_REPOSITORY = GitRepository.of("EternalCodeTeam", "EternalCombat");
+
+    private final GitCheck gitCheck = new GitCheck();
+    private final Lazy<GitCheckResult> gitCheckResult;
+
+    public UpdaterService(PluginDescriptionFile descriptionFile) {
+        this.gitCheckResult = new Lazy<>(() -> {
+            String version = descriptionFile.getVersion();
+
+            return this.gitCheck.checkRelease(GIT_REPOSITORY, GitTag.of("v" + version));
+        });
+    }
+
+    public CompletableFuture<Boolean> isUpToDate() {
+        return CompletableFuture.supplyAsync(() -> {
+            GitCheckResult result = this.gitCheckResult.get();
+
+            return result.isUpToDate();
+        });
+    }
+
+}

eternalcombat-api/src/main/java/com/eternalcode/combat/util/DurationUtil.java

@@ -0,0 +1,24 @@
+package com.eternalcode.combat.util;
+
+import com.eternalcode.commons.time.DurationParser;
+import com.eternalcode.commons.time.TemporalAmountParser;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+
+public final class DurationUtil {
+
+    private static final TemporalAmountParser<Duration> WITHOUT_MILLS = new DurationParser()
+        .withUnit("s", ChronoUnit.SECONDS)
+        .withUnit("m", ChronoUnit.MINUTES)
+        .withUnit("h", ChronoUnit.HOURS)
+        .withUnit("d", ChronoUnit.DAYS)
+        .roundOff(ChronoUnit.MILLIS);
+
+    public DurationUtil() {
+        throw new UnsupportedOperationException("This class cannot be instantiated");
+    }
+
+    public static String format(Duration duration) {
+        return WITHOUT_MILLS.format(duration);
+    }
+}

eternalcombat-plugin/build.gradle.kts

@@ -1,215 +1,62 @@
-import net.minecrell.pluginyml.bukkit.BukkitPluginDescription
-import io.papermc.hangarpublishplugin.model.Platforms
 plugins {
     `eternalcombat-java`
     `eternalcombat-repositories`
 
     id("net.minecrell.plugin-yml.bukkit")
-    id("com.gradleup.shadow")
+    id("com.github.johnrengelman.shadow")
     id("xyz.jpenilla.run-paper")
-    id("com.modrinth.minotaur") version "2.9.0"
-    id("io.papermc.hangar-publish-plugin") version "0.1.4"
-}
-
-val buildNumber = providers.environmentVariable("GITHUB_RUN_NUMBER").orNull
-val isRelease = providers.environmentVariable("GITHUB_EVENT_NAME").orNull == "release"
-
-if (buildNumber != null && !isRelease) {
-    val offset = try {
-        val description = providers.exec {
-            commandLine("git", "describe", "--tags", "--long")
-        }.standardOutput.asText.get().trim()
-        val parts = description.split("-")
-        if (parts.size >= 3) parts[parts.size - 2] else "0"
-    } catch (e: Exception) {
-        try {
-            providers.exec {
-                commandLine("git", "rev-list", "--count", "HEAD")
-            }.standardOutput.asText.get().trim()
-        } catch (e: Exception) {
-            "0"
-        }
-    }
-    
-    val baseVersion = project.version.toString().replace("-SNAPSHOT", "")
-    version = "$baseVersion-SNAPSHOT+$offset"
-}
-
-val changelogText = providers.environmentVariable("CHANGELOG").orElse(providers.exec {
-    commandLine("git", "log", "-1", "--format=%B")
-}.standardOutput.asText)
-
-logger.lifecycle("Building version: $version")
-
-val paperVersions = (property("paperVersion") as String)
-    .split(",")
-    .map { it.trim() }
-
-val hangarToken = providers.environmentVariable("HANGAR_API_TOKEN")
-    .orElse(providers.gradleProperty("hangarToken"))
-
-val projectVersion = project.version.toString()
-val releaseChannel = if (isRelease) "Release" else "Snapshot"
-val shadowJarTask = tasks.shadowJar
-
-modrinth {
-    token.set(providers.environmentVariable("MODRINTH_TOKEN"))
-    projectId.set("eternalcombat")
-    versionNumber.set(projectVersion)
-    versionType.set(if (isRelease) "release" else "beta")
-    uploadFile.set(shadowJarTask) 
-    gameVersions.addAll(paperVersions)
-    loaders.addAll(listOf("paper", "spigot", "purpur"))
-    changelog.set(changelogText)
-    syncBodyFrom.set(rootProject.file("README.md").readText())
-}
-
-
-hangarPublish {
-    publications.register("plugin") {
-        version.set(projectVersion)
-        channel.set(releaseChannel)
-        changelog.set(changelogText)
-        id.set("eternalcombat")
-        apiKey.set(hangarToken)
-        platforms {
-            register(Platforms.PAPER) {
-                jar.set(shadowJarTask.flatMap { it.archiveFile })
-                platformVersions.set(paperVersions)
-            }
-        }
-    }
-}
-
-configurations.all {
-    resolutionStrategy {
-        eachDependency {
-            if (requested.group == "com.google.code.gson" && requested.name == "gson") {
-                useVersion("2.11.0")
-                because("WorldGuard requires strictly gson 2.11.0")
-            }
-        }
-    }
-}
-
-
-sourceSets {
-    main {
-        resources.srcDir("src/resources")
-    }
 }
 
 dependencies {
     implementation(project(":eternalcombat-api"))
-
-    compileOnly("io.papermc.paper:paper-api:1.19.4-R0.1-SNAPSHOT")
-    compileOnly("me.clip:placeholderapi:2.11.6")
-    compileOnly("com.sk89q.worldedit:worldedit-bukkit:7.3.0-SNAPSHOT") // Import WorldEdit.
-    compileOnly(
-        "com.sk89q.worldguard:worldguard-bukkit:7.0.9"
-    ) { // Import WorldGuard but without its bundled WorldEdit.
-        exclude(group = "com.sk89q.worldedit")
-    }
-    // kyori
-    implementation("net.kyori:adventure-platform-bukkit:${Versions.ADVENTURE_PLATFORM_BUKKIT}")
-    implementation("net.kyori:adventure-text-minimessage:${Versions.ADVENTURE_API}")
-    implementation("net.kyori:adventure-api") {
-        version {
-            strictly(Versions.ADVENTURE_API)
-        }
-    }
-    // litecommands
-    implementation("dev.rollczi:litecommands-bukkit:${Versions.LITE_COMMANDS}")
-
-    // Okaeri configs
-    implementation("eu.okaeri:okaeri-configs-serdes-commons:${Versions.OKAERI_CONFIGS_SERDES_COMMONS}")
-    implementation("eu.okaeri:okaeri-configs-serdes-bukkit:${Versions.OKAERI_CONFIGS_SERDES_BUKKIT}")
-
-    // XSeries
-    implementation("com.github.cryptomorin:XSeries:${Versions.XSERIES}")
-    // caffeine
-    implementation("com.github.ben-manes.caffeine:caffeine:${Versions.CAFFEINE}")
-
-    implementation("com.eternalcode:eternalcode-commons-adventure:${Versions.ETERNALCODE_COMMONS}")
-    implementation("com.eternalcode:eternalcode-commons-bukkit:${Versions.ETERNALCODE_COMMONS}")
-    implementation("com.eternalcode:eternalcode-commons-shared:${Versions.ETERNALCODE_COMMONS}")
-    implementation("com.eternalcode:eternalcode-commons-updater:${Versions.ETERNALCODE_COMMONS}")
-
-    // worldguard
-    compileOnly("com.sk89q.worldguard:worldguard-bukkit:${Versions.WORLD_GUARD_BUKKIT}")
-
-    // PlaceholderAPI
-    compileOnly("me.clip:placeholderapi:${Versions.PLACEHOLDER_API}")
-
-    // Multification
-    implementation("com.eternalcode:multification-bukkit:${Versions.MULTIFICATION}")
-    implementation("com.eternalcode:multification-okaeri:${Versions.MULTIFICATION}")
-    compileOnly("com.github.retrooper:packetevents-spigot:${Versions.PACKETEVENTS}")
-    implementation("io.papermc:paperlib:${Versions.PAPERLIB}")
-
-    implementation("eu.okaeri:okaeri-configs-core:5.0.9")
-    implementation("eu.okaeri:okaeri-configs-yaml-snakeyaml:5.0.9")
-    implementation("eu.okaeri:okaeri-configs-yaml-bukkit:5.0.9")
-    implementation("eu.okaeri:okaeri-configs-serdes-commons:5.0.9")
-    implementation("eu.okaeri:okaeri-configs-serdes-bukkit:5.0.9")
 }
 
 bukkit {
-    name = "EternalCombat-OG"
     main = "com.eternalcode.combat.CombatPlugin"
-    version = project.version.toString()
-    apiVersion = "1.19"
-    authors = listOf("EternalCodeTeam", "true-og")
-    prefix = "EternalCombat-OG"
-    load = BukkitPluginDescription.PluginLoadOrder.POSTWORLD
-    softDepend = listOf(
-        "WorldGuard"
-    )
-    depend = listOf(
-        "PacketEvents",
-    )
+    author = "EternalCodeTeam"
+    apiVersion = "1.13"
+    prefix = "EternalCombat"
+    name = "EternalCombat"
+    softDepend = listOf("WorldGuard")
     version = "${project.version}"
-
-    foliaSupported = false
 }
 
 tasks {
     runServer {
         minecraftVersion("1.19.4")
-        downloadPlugins.modrinth("WorldEdit", Versions.WORLDEDIT)
-        downloadPlugins.modrinth("PacketEvents", "${Versions.PACKETEVENTS}+spigot")
-        downloadPlugins.modrinth("WorldGuard", Versions.WORLDGUARD)
-        downloadPlugins.modrinth("LuckPerms", "v${Versions.LUCKPERMS}-bukkit")
     }
 }
 
 tasks.shadowJar {
-    archiveFileName.set("EternalCombat-OG-${project.version}.jar")
+    archiveFileName.set("EternalCombat v${project.version}.jar")
+
+    dependsOn("checkstyleMain")
+    dependsOn("checkstyleTest")
+    dependsOn("test")
 
     exclude(
         "org/intellij/lang/annotations/**",
         "org/jetbrains/annotations/**",
         "META-INF/**",
         "kotlin/**",
-        "javax/**",
-        "org/checkerframework/**",
-        "com/google/errorprone/**"
+        "javax/**"
     )
 
     val prefix = "com.eternalcode.combat.libs"
     listOf(
+        "panda.std",
+        "panda.utilities",
+        "org.panda-lang",
         "eu.okaeri",
         "net.kyori",
         "org.bstats",
-        "org.yaml",
         "dev.rollczi.litecommands",
         "com.eternalcode.gitcheck",
         "org.json.simple",
+        "org.apache.commons",
+        "javassist",
         "com.github.benmanes.caffeine",
-        "com.eternalcode.commons",
-        "com.eternalcode.multification",
-        "com.github.cryptomorin",
-        "io.papermc.lib",
+        "com.eternalcode.commons"
     ).forEach { pack ->
         relocate(pack, "$prefix.$pack")
     }

eternalcombat-plugin/src/main/java/com/eternalcode/combat/CombatPlugin.java

@@ -1,127 +1,99 @@
 package com.eternalcode.combat;
 
-import com.eternalcode.combat.border.BorderTriggerController;
-import com.eternalcode.combat.border.BorderService;
-import com.eternalcode.combat.border.BorderServiceImpl;
-import com.eternalcode.combat.border.animation.block.BorderBlockController;
-import com.eternalcode.combat.border.animation.particle.ParticleController;
 import com.eternalcode.combat.bridge.BridgeService;
+import com.eternalcode.combat.command.InvalidUsage;
+import com.eternalcode.combat.command.PermissionMessage;
 import com.eternalcode.combat.config.ConfigService;
 import com.eternalcode.combat.config.implementation.PluginConfig;
-import com.eternalcode.combat.crystalpvp.EndCrystalListener;
-import com.eternalcode.combat.crystalpvp.RespawnAnchorListener;
-import com.eternalcode.combat.event.EventManager;
-import com.eternalcode.combat.fight.FightManager;
-import com.eternalcode.combat.fight.FightManagerImpl;
-import com.eternalcode.combat.fight.FightTagCommand;
-import com.eternalcode.combat.fight.FightTask;
+import com.eternalcode.combat.drop.DropController;
+import com.eternalcode.combat.drop.DropKeepInventoryManager;
+import com.eternalcode.combat.drop.DropManager;
+import com.eternalcode.combat.drop.impl.PercentDropModifier;
+import com.eternalcode.combat.drop.impl.PlayersHealthDropModifier;
 import com.eternalcode.combat.fight.controller.FightActionBlockerController;
-import com.eternalcode.combat.fight.controller.FightBypassAdminController;
-import com.eternalcode.combat.fight.controller.FightBypassCreativeController;
-import com.eternalcode.combat.fight.controller.FightBypassPermissionController;
-import com.eternalcode.combat.fight.controller.FightInventoryController;
-import com.eternalcode.combat.fight.death.DeathFlareController;
-import com.eternalcode.combat.fight.death.DeathLightningController;
 import com.eternalcode.combat.fight.controller.FightMessageController;
 import com.eternalcode.combat.fight.controller.FightTagController;
 import com.eternalcode.combat.fight.controller.FightUnTagController;
-import com.eternalcode.combat.fight.drop.DropController;
-import com.eternalcode.combat.fight.drop.DropKeepInventoryService;
-import com.eternalcode.combat.fight.drop.DropKeepInventoryServiceImpl;
-import com.eternalcode.combat.fight.drop.DropService;
-import com.eternalcode.combat.fight.drop.DropServiceImpl;
-import com.eternalcode.combat.fight.drop.impl.PercentDropModifier;
-import com.eternalcode.combat.fight.drop.impl.PlayersHealthDropModifier;
 import com.eternalcode.combat.fight.effect.FightEffectController;
+import com.eternalcode.combat.event.EventCaller;
+import com.eternalcode.combat.fight.FightManager;
+import com.eternalcode.combat.fight.FightTask;
+import com.eternalcode.combat.fight.bossbar.FightBossBarService;
 import com.eternalcode.combat.fight.effect.FightEffectService;
-import com.eternalcode.combat.fight.effect.FightEffectServiceImpl;
-import com.eternalcode.combat.fight.firework.FireworkController;
-import com.eternalcode.combat.fight.knockback.KnockbackRegionController;
-import com.eternalcode.combat.fight.knockback.KnockbackService;
 import com.eternalcode.combat.fight.logout.LogoutController;
 import com.eternalcode.combat.fight.logout.LogoutService;
-import com.eternalcode.combat.fight.logout.OpponentLogoutController;
 import com.eternalcode.combat.fight.pearl.FightPearlController;
-import com.eternalcode.combat.fight.pearl.FightPearlService;
-import com.eternalcode.combat.fight.pearl.FightPearlServiceImpl;
-import com.eternalcode.combat.fight.tagout.FightTagOutCommand;
+import com.eternalcode.combat.fight.pearl.FightPearlManager;
 import com.eternalcode.combat.fight.tagout.FightTagOutController;
 import com.eternalcode.combat.fight.tagout.FightTagOutService;
-import com.eternalcode.combat.fight.tagout.FightTagOutServiceImpl;
-import com.eternalcode.combat.handler.InvalidUsageHandlerImpl;
-import com.eternalcode.combat.handler.MissingPermissionHandlerImpl;
-import com.eternalcode.combat.notification.NoticeService;
+import com.eternalcode.combat.fight.tagout.TagOutCommand;
+import com.eternalcode.combat.notification.NotificationAnnouncer;
+import com.eternalcode.combat.region.RegionController;
 import com.eternalcode.combat.region.RegionProvider;
 import com.eternalcode.combat.updater.UpdaterNotificationController;
 import com.eternalcode.combat.updater.UpdaterService;
 import com.eternalcode.commons.adventure.AdventureLegacyColorPostProcessor;
 import com.eternalcode.commons.adventure.AdventureLegacyColorPreProcessor;
-import com.eternalcode.commons.bukkit.scheduler.MinecraftScheduler;
-import com.eternalcode.multification.notice.Notice;
 import com.google.common.base.Stopwatch;
 import dev.rollczi.litecommands.LiteCommands;
-import dev.rollczi.litecommands.bukkit.LiteBukkitFactory;
-import dev.rollczi.litecommands.bukkit.LiteBukkitMessages;
-import java.io.File;
-import java.time.Duration;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Stream;
+import dev.rollczi.litecommands.bukkit.adventure.platform.LiteBukkitAdventurePlatformFactory;
+import dev.rollczi.litecommands.bukkit.tools.BukkitOnlyPlayerContextual;
+import dev.rollczi.litecommands.bukkit.tools.BukkitPlayerArgument;
 import net.kyori.adventure.platform.AudienceProvider;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bstats.bukkit.Metrics;
 import org.bukkit.Server;
 import org.bukkit.command.CommandSender;
-import org.bukkit.event.entity.PlayerDeathEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.entity.Player;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import java.io.File;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
+
 public final class CombatPlugin extends JavaPlugin implements EternalCombatApi {
 
     private static final String FALLBACK_PREFIX = "eternalcombat";
-    private static final String CONFIG_RESOURCE_PATH = "config.yml";
+    private static final int BSTATS_METRICS_ID = 17803;
 
     private FightManager fightManager;
-    private FightPearlService fightPearlService;
+    private FightPearlManager fightPearlManager;
     private FightTagOutService fightTagOutService;
     private FightEffectService fightEffectService;
 
-    private DropService dropService;
-    private DropKeepInventoryService dropKeepInventoryService;
+    private LogoutService logoutService;
+
+    private DropManager dropManager;
+    private DropKeepInventoryManager dropKeepInventoryManager;
 
     private RegionProvider regionProvider;
 
+    private PluginConfig pluginConfig;
+
     private AudienceProvider audienceProvider;
     private LiteCommands<CommandSender> liteCommands;
 
-
     @Override
     public void onEnable() {
         Stopwatch started = Stopwatch.createStarted();
         Server server = this.getServer();
 
         File dataFolder = this.getDataFolder();
-        File configFile = new File(dataFolder, CONFIG_RESOURCE_PATH);
-
-        if (!configFile.exists()) {
-            this.saveResource(CONFIG_RESOURCE_PATH, false);
-        }
 
         ConfigService configService = new ConfigService();
 
-        EventManager eventManager = new EventManager(this);
-        PluginConfig pluginConfig = configService.create(PluginConfig.class, configFile);
+        EventCaller eventCaller = new EventCaller(server);
 
-        MinecraftScheduler scheduler = CombatSchedulerAdapter.getAdaptiveScheduler(this);
+        this.pluginConfig = configService.create(PluginConfig.class, new File(dataFolder, "config.yml"));
 
-        this.fightManager = new FightManagerImpl(eventManager);
-        this.fightPearlService = new FightPearlServiceImpl(pluginConfig.pearl);
-        this.fightTagOutService = new FightTagOutServiceImpl();
-        this.fightEffectService = new FightEffectServiceImpl();
-
-        LogoutService logoutService = new LogoutService();
-
-        this.dropService = new DropServiceImpl();
-        this.dropKeepInventoryService = new DropKeepInventoryServiceImpl();
+        this.fightManager = new FightManager(eventCaller);
+        this.fightPearlManager = new FightPearlManager(this.pluginConfig.pearl);
+        this.fightTagOutService = new FightTagOutService();
+        this.fightEffectService = new FightEffectService();
+        this.logoutService = new LogoutService();
+        this.dropManager = new DropManager();
+        this.dropKeepInventoryManager = new DropKeepInventoryManager();
 
         UpdaterService updaterService = new UpdaterService(this.getDescription());
 
@@ -131,85 +103,49 @@ public final class CombatPlugin extends JavaPlugin implements EternalCombatApi {
             .preProcessor(new AdventureLegacyColorPreProcessor())
             .build();
 
-        NoticeService noticeService = new NoticeService(this.audienceProvider, pluginConfig, miniMessage);
-
-        BridgeService bridgeService = new BridgeService(
-            pluginConfig,
-            server.getPluginManager(),
-            this.getLogger(),
-            this,
-            this.fightManager
-        );
-        bridgeService.init(server);
+        FightBossBarService fightBossBarService = new FightBossBarService(this.pluginConfig, this.audienceProvider, miniMessage);
 
+        BridgeService bridgeService = new BridgeService(this.pluginConfig, server.getPluginManager(), this.getLogger());
+        bridgeService.init();
         this.regionProvider = bridgeService.getRegionProvider();
-        BorderService borderService = new BorderServiceImpl(scheduler, server, regionProvider, eventManager, () -> pluginConfig.border);
-        KnockbackService knockbackService = new KnockbackService(pluginConfig, scheduler, regionProvider);
 
-        this.liteCommands = LiteBukkitFactory.builder(FALLBACK_PREFIX, this, server)
-            .message(LiteBukkitMessages.PLAYER_NOT_FOUND, pluginConfig.messagesSettings.playerNotFound)
-            .message(LiteBukkitMessages.PLAYER_ONLY, pluginConfig.messagesSettings.admin.onlyForPlayers)
+        NotificationAnnouncer notificationAnnouncer = new NotificationAnnouncer(this.audienceProvider, miniMessage);
 
-            .invalidUsage(new InvalidUsageHandlerImpl(pluginConfig, noticeService))
-            .missingPermission(new MissingPermissionHandlerImpl(pluginConfig, noticeService))
+        this.liteCommands = LiteBukkitAdventurePlatformFactory.builder(server, FALLBACK_PREFIX, this.audienceProvider)
+            .argument(Player.class, new BukkitPlayerArgument<>(this.getServer(), this.pluginConfig.messages.playerNotFound))
+            .contextualBind(Player.class, new BukkitOnlyPlayerContextual<>(this.pluginConfig.messages.admin.onlyForPlayers))
 
-            .commands(
-                new FightTagCommand(this.fightManager, noticeService, pluginConfig),
-                new FightTagOutCommand(this.fightTagOutService, noticeService, pluginConfig),
-                new EternalCombatReloadCommand(configService, noticeService)
-            )
+            .invalidUsageHandler(new InvalidUsage(this.pluginConfig, notificationAnnouncer))
+            .permissionHandler(new PermissionMessage(this.pluginConfig, notificationAnnouncer))
 
-            .result(Notice.class, (invocation, result, chain) -> noticeService.create()
-                .viewer(invocation.sender())
-                .notice(result)
-                .send())
+            .commandInstance(new CombatCommand(this.fightManager, configService, notificationAnnouncer, this.pluginConfig))
+            .commandInstance(new TagOutCommand(this.fightTagOutService, notificationAnnouncer, this.pluginConfig))
 
-            .build();
+            .register();
 
-        FightTask fightTask = new FightTask(server, pluginConfig, this.fightManager, noticeService);
-        scheduler.timer(fightTask, Duration.ofSeconds(1), Duration.ofSeconds(1));
+        FightTask fightTask = new FightTask(server, this.pluginConfig, this.fightManager, fightBossBarService, notificationAnnouncer);
+        this.getServer().getScheduler().runTaskTimer(this, fightTask, 20L, 20L);
+
+        new Metrics(this, BSTATS_METRICS_ID);
 
         Stream.of(
-            new PercentDropModifier(pluginConfig.drop),
-            new PlayersHealthDropModifier(pluginConfig.drop, logoutService)
-        ).forEach(this.dropService::registerModifier);
+            new PercentDropModifier(this.pluginConfig.dropSettings),
+            new PlayersHealthDropModifier(this.pluginConfig.dropSettings, this.logoutService)
+        ).forEach(this.dropManager::registerModifier);
 
-        eventManager.subscribe(
-            new FightTagController(this.fightManager, pluginConfig),
-            new FightUnTagController(this.fightManager, pluginConfig, logoutService),
-            new FightBypassAdminController(server, pluginConfig),
-            new FightBypassPermissionController(server, pluginConfig),
-            new FightBypassCreativeController(server, pluginConfig),
-            new FightActionBlockerController(this.fightManager, noticeService, pluginConfig, server),
-            new FightPearlController(pluginConfig.pearl, noticeService, this.fightManager, this.fightPearlService),
-            new DeathFlareController(pluginConfig, server, scheduler, this),
-            new DeathLightningController(pluginConfig, server),
-            new UpdaterNotificationController(updaterService, pluginConfig, this.audienceProvider, miniMessage),
-            new KnockbackRegionController(noticeService, this.regionProvider, this.fightManager, knockbackService, server),
-            new FightEffectController(pluginConfig.effect, this.fightEffectService, this.fightManager, server),
-            new FightTagOutController(this.fightTagOutService),
-            new OpponentLogoutController(this.fightManager, server),
-            new FightMessageController(this.fightManager, noticeService, pluginConfig, server),
-            new BorderTriggerController(borderService, () -> pluginConfig.border, fightManager, server, scheduler),
-            new ParticleController(borderService, () -> pluginConfig.border.particle, scheduler, server),
-            new BorderBlockController(borderService, () -> pluginConfig.border.block, scheduler, server),
-            new EndCrystalListener(this, this.fightManager, pluginConfig),
-            new RespawnAnchorListener(this, this.fightManager, pluginConfig),
-            new FireworkController(this.fightManager, pluginConfig, noticeService),
-            new FightInventoryController(this.fightManager, pluginConfig, noticeService)
-        );
-
-        eventManager.subscribe(
-            PlayerDeathEvent.class,
-            pluginConfig.drop.dropEventPriority,
-            new DropController(dropService, dropKeepInventoryService, pluginConfig.drop, fightManager, miniMessage)
-        );
-
-        eventManager.subscribe(
-            PlayerQuitEvent.class,
-            pluginConfig.combat.quitPunishmentEventPriority,
-            new LogoutController(this.fightManager, logoutService, noticeService, pluginConfig)
-        );
+        Stream.of(
+            new DropController(this.dropManager, this.dropKeepInventoryManager, this.pluginConfig.dropSettings, this.fightManager),
+            new FightTagController(this.fightManager, this.pluginConfig),
+            new LogoutController(this.fightManager, this.logoutService, notificationAnnouncer, this.pluginConfig),
+            new FightUnTagController(this.fightManager, this.pluginConfig, this.logoutService),
+            new FightActionBlockerController(this.fightManager, notificationAnnouncer, this.pluginConfig),
+            new FightPearlController(this.pluginConfig.pearl, notificationAnnouncer, this.fightManager, this.fightPearlManager),
+            new UpdaterNotificationController(updaterService, this.pluginConfig, this.audienceProvider, miniMessage),
+            new RegionController(notificationAnnouncer, this.regionProvider, this.fightManager, this.pluginConfig),
+            new FightEffectController(this.pluginConfig.effect, this.fightEffectService, this.fightManager, this.getServer()),
+            new FightTagOutController(this.fightTagOutService, this.pluginConfig),
+            new FightMessageController(this.fightManager, notificationAnnouncer, fightBossBarService, this.pluginConfig, this.getServer())
+        ).forEach(listener -> this.getServer().getPluginManager().registerEvents(listener, this));
 
         EternalCombatProvider.initialize(this);
 
@@ -219,22 +155,19 @@ public final class CombatPlugin extends JavaPlugin implements EternalCombatApi {
 
     @Override
     public void onDisable() {
-        if (EternalCombatProvider.isInitialized()) {
-            EternalCombatProvider.deinitialize();
-        }
+        EternalCombatProvider.deinitialize();
 
         if (this.liteCommands != null) {
-            this.liteCommands.unregister();
+            this.liteCommands.getPlatform().unregisterAll();
         }
 
         if (this.audienceProvider != null) {
             this.audienceProvider.close();
         }
 
-        if (this.fightManager != null) {
-            this.fightManager.untagAll();
-        }
+        this.fightManager.untagAll();
     }
+
     @Override
     public FightManager getFightManager() {
         return this.fightManager;
@@ -246,8 +179,8 @@ public final class CombatPlugin extends JavaPlugin implements EternalCombatApi {
     }
 
     @Override
-    public FightPearlService getFightPearlService() {
-        return this.fightPearlService;
+    public FightPearlManager getFightPearlManager() {
+        return this.fightPearlManager;
     }
 
     @Override
@@ -261,12 +194,17 @@ public final class CombatPlugin extends JavaPlugin implements EternalCombatApi {
     }
 
     @Override
-    public DropService getDropService() {
-        return this.dropService;
+    public DropManager getDropManager() {
+        return this.dropManager;
     }
 
     @Override
-    public DropKeepInventoryService getDropKeepInventoryService() {
-        return this.dropKeepInventoryService;
+    public DropKeepInventoryManager getDropKeepInventoryManager() {
+        return this.dropKeepInventoryManager;
+    }
+
+    @Override
+    public PluginConfig getPluginConfig() {
+        return this.pluginConfig;
     }
 }