First Commit Natural Regeneration

Author: Toskan4134

README.md

@@ -1,101 +1,78 @@
-# 🛠️ Hytale Plugin Template
+# Natural Regeneration
 
-Welcome to the **Hytale Plugin Template**! This project is a pre-configured foundation for building **Java Plugins**. It streamlines the development process by handling classpath setup, server execution, and asset bundling.
+A Hytale server plugin that passively regenerates player health after not taking damage for a configurable period of time.
 
-> **⚠️ Early Access Warning**
-> Hytale is currently in Early Access. Features, APIs, and this template are subject to frequent changes. Please ensure you are using the latest version of the template for the best experience.
+## Features
 
----
+- Automatic health regeneration after a delay period
+- Fully configurable via in-game commands
+- Persistent configuration saved to JSON
+- Optimized for server performance
 
-## 📋 Prerequisites
+## How It Works
 
-Before you begin, ensure your environment is ready:
+1. When a player takes damage, their regeneration timer resets
+2. After the configured delay (default: 10 seconds), health regeneration begins
+3. Health regenerates at the configured rate until the player reaches max health or takes damage again
 
-* **Hytale Launcher**: Installed and updated.
-* **Java 25 SDK**: Required for modern Hytale development.
-* **IntelliJ IDEA**: (Community or Ultimate) Recommended for full feature support.
+## Commands
 
----
+| Command | Description |
+|---------|-------------|
+| `/nr` | Shows help and available subcommands |
+| `/nr status` | Display current configuration |
+| `/nr toggle` | Enable or disable regeneration |
+| `/nr delay <seconds>` | Set delay before regeneration starts |
+| `/nr amount <hp>` | Set HP regenerated per tick |
+| `/nr interval <seconds>` | Set time between regeneration ticks |
 
-## 🚀 Quick Start Installation
+**Aliases:** `/naturalregeneration`, `/naturalregen`, `/nr`
 
-### 1. Initial Setup (Before Importing)
+## Configuration
 
-To avoid IDE caching issues, configure these files **before** you open the project in IntelliJ:
+Configuration is automatically saved to `Server/Plugin/Config/NaturalRegeneration.json`
 
-* **`settings.gradle`**: Set your unique project name.
-```gradle
-rootProject.name = 'MyAwesomePlugin'
+| Option | Default | Description |
+|--------|---------|-------------|
+| `Enabled` | `true` | Whether regeneration is active |
+| `DelaySeconds` | `10.0` | Seconds after damage before regen starts |
+| `AmountHP` | `1.0` | HP restored per regeneration tick |
+| `IntervalSeconds` | `1.0` | Seconds between regeneration ticks |
 
-```
-
-
-* **`gradle.properties`**: Set your `maven_group` (e.g., `com.yourname`) and starting version.
-* **`src/main/resources/manifest.json`**: Update your plugin metadata.
-* **CRITICAL:** Ensure the `"Main"` property points exactly to your entry-point class.
-
-
-
-### 2. Importing the Project
-
-1. Open IntelliJ IDEA and select **Open**.
-2. Navigate to the template folder and click **OK**.
-3. Wait for the Gradle sync to finish. This will automatically download dependencies, create a `./run` folder, and generate the **HytaleServer** run configuration.
-
-### 3. Authenticating your Test Server
-
-You **must** authenticate your local server to connect to it:
-
-1. Launch the **HytaleServer** configuration in IDEA.
-2. In the terminal, run: `auth login device`.
-3. Follow the printed URL to log in via your Hytale account.
-4. Once verified, run: `auth persistence Encrypted`.
-
----
+### Example Configuration
 
-## 🎮 Developing & Testing
-
-### Running the Server
-
-If you do not see the **HytaleServer** run configuration in the top-right dropdown, click "Edit Configurations..." to unhide it. Press the **Green Play Button** to start, or the **Bug Icon** to start in Debug Mode to enable breakpoints.
-
-### Verifying the Setup
-
-1. Launch your standard Hytale Client.
-2. Connect to `Local Server` (127.0.0.1).
-3. Type `/test` in-game. If it returns your plugin version, everything is working!
-
-### Bundling Assets
-
-You can include models and textures by placing them in `src/main/resources/Common/` or `src/main/resources/Server/`. These are editable in real-time using the in-game **Asset Editor**.
-
----
-
-## 📦 Building your Plugin
+```json
+{
+    "Enabled": true,
+    "DelaySeconds": 10.0,
+    "AmountHP": 1.0,
+    "IntervalSeconds": 1.0
+}
+```
 
-To create a shareable `.jar` file for distribution:
+## Installation
 
-1. Open the **Gradle Tab** on the right side of IDEA.
-2. Navigate to `Tasks` -> `build` -> `build`.
-3. Your compiled plugin will be in: `build/libs/your-plugin-name-1.0.0.jar`.
+1. Build the plugin JAR file
+2. Place the JAR in your server's `plugins` folder
+3. Start/restart the server
+4. Configure using in-game commands or edit the config file
 
-To install it manually, drop the JAR into `%appdata%/Hytale/UserData/Mods/`.
+## Building
 
----
+```bash
+./gradlew build
+```
 
-## 📚 Advanced Documentation
+The compiled JAR will be located in `build/libs/`
 
-For detailed guides on commands, event listeners, and professional patterns, visit our full documentation:
-👉 **[Hytale Modding Documentation](https://britakee-studios.gitbook.io/hytale-modding-documentation)**
+## Requirements
 
----
+- Hytale Server (compatible version)
 
-## 🆘 Troubleshooting
+## License
 
-* **Sync Fails**: Check that your Project SDK is set to **Java 25** via `File > Project Structure`.
-* **Cannot Connect**: Ensure you ran the `auth` commands in the server console.
-* **Plugin Not Loading**: Double-check your `manifest.json` for typos in the `"Main"` class path.
+MIT License
 
----
+## Author
 
-**Need Help?** Visit our full guide here: **[Hytale Modding Documentation](https://britakee-studios.gitbook.io/hytale-modding-documentation)**
+Toskan4134

gradle.properties

@@ -1,9 +1,9 @@
 # The current version of your project. Please use semantic versioning!
-version=0.0.2
+version=1.0.0
 
 # The group ID used for maven publishing. Usually the same as your package name
 # but not the same as your plugin group!
-maven_group=org.example
+maven_group=org.toskan4134
 
 # The version of Java used by your plugin. The game is built on Java 21 but
 # actually runs on Java 25.

settings.gradle

@@ -1 +1 @@
-rootProject.name = 'ExamplePlugin'
+rootProject.name = 'NaturalRegeneration'

src/main/java/org/example/plugin/ExampleCommand.java

@@ -0,0 +1,48 @@
+package org.toskan4134.NaturalRegeneration;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.logger.HytaleLogger;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageEventSystem;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nullable;
+
+/**
+ * ECS system that listens for damage events to track when entities receive damage.
+ * Extends DamageEventSystem to receive Damage events.
+ */
+public class DamageListenerSystem extends DamageEventSystem {
+
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Nullable
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.any();
+    }
+
+    @Override
+    public void handle(int entityIndex,
+                       ArchetypeChunk<EntityStore> chunk,
+                       Store<EntityStore> store,
+                       CommandBuffer<EntityStore> commandBuffer,
+                       Damage damage) {
+
+        // Get damage info
+        float damageAmount = damage.getAmount();
+
+        if (damageAmount <= 0) {
+            return; // Not real damage
+        }
+
+        // Record damage in tracker
+        // entityIndex is the index of the entity that received damage
+        DamageTracker.onDamageReceived(entityIndex, damageAmount);
+
+        LOGGER.atFine().log("Entity " + entityIndex + " received " + damageAmount + " damage");
+    }
+}

src/main/java/org/example/plugin/ExamplePlugin.java

@@ -0,0 +1,113 @@
+package org.toskan4134.NaturalRegeneration;
+
+import com.hypixel.hytale.logger.HytaleLogger;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Utility class that tracks when an entity receives damage.
+ * Stores the timestamp of the last damage received for each entity.
+ */
+public class DamageTracker {
+
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    // Map storing last damage time by entity index
+    private static final Map<Integer, Long> lastDamageTime = new ConcurrentHashMap<>();
+
+    // Maximum time to keep records (10 minutes)
+    private static final long MAX_RECORD_AGE_MS = 600_000L;
+
+    // Counter for periodic cleanup
+    private static long lastCleanupTime = 0L;
+    private static final long CLEANUP_INTERVAL_MS = 60_000L; // Cleanup every minute
+
+    /**
+     * Records that an entity has received damage.
+     * @param entityIndex Entity index in the ECS
+     */
+    public static void onDamageReceived(int entityIndex) {
+        lastDamageTime.put(entityIndex, System.currentTimeMillis());
+        cleanupIfNeeded();
+    }
+
+    /**
+     * Records that an entity has received damage with amount.
+     * @param entityIndex Entity index
+     * @param damageAmount Amount of damage received
+     */
+    public static void onDamageReceived(int entityIndex, float damageAmount) {
+        lastDamageTime.put(entityIndex, System.currentTimeMillis());
+        cleanupIfNeeded();
+    }
+
+    /**
+     * Gets the time of the last damage received by an entity.
+     * @param entityIndex Entity index
+     * @return Timestamp of last damage, or 0 if never damaged
+     */
+    public static long getLastDamageTime(int entityIndex) {
+        return lastDamageTime.getOrDefault(entityIndex, 0L);
+    }
+
+    /**
+     * Checks if an entity can regenerate health.
+     * @param entityIndex Entity index
+     * @param currentTimeMs Current time in milliseconds
+     * @param delayMs Required delay in milliseconds since last damage
+     * @return true if enough time has passed since last damage
+     */
+    public static boolean canRegenerate(int entityIndex, long currentTimeMs, long delayMs) {
+        Long lastDamage = lastDamageTime.get(entityIndex);
+        if (lastDamage == null) {
+            return true; // Never received damage
+        }
+        return (currentTimeMs - lastDamage) >= delayMs;
+    }
+
+    /**
+     * Clears the record for an entity.
+     * @param entityIndex Entity index
+     */
+    public static void clearEntity(int entityIndex) {
+        lastDamageTime.remove(entityIndex);
+    }
+
+    /**
+     * Cleans up old records if enough time has passed.
+     */
+    private static void cleanupIfNeeded() {
+        long currentTime = System.currentTimeMillis();
+        if (currentTime - lastCleanupTime < CLEANUP_INTERVAL_MS) {
+            return;
+        }
+        lastCleanupTime = currentTime;
+
+        // Clean old entries
+        Iterator<Map.Entry<Integer, Long>> iterator = lastDamageTime.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<Integer, Long> entry = iterator.next();
+            if (currentTime - entry.getValue() > MAX_RECORD_AGE_MS) {
+                iterator.remove();
+            }
+        }
+
+        LOGGER.atFine().log("DamageTracker cleanup: " + lastDamageTime.size() + " active entries");
+    }
+
+    /**
+     * Clears all records.
+     */
+    public static void clearAll() {
+        lastDamageTime.clear();
+    }
+
+    /**
+     * Gets the number of active entries.
+     */
+    public static int getActiveCount() {
+        return lastDamageTime.size();
+    }
+}