UnifiedData v2

import com.unifieddata.api.Data;

// Reading player gold
Data.from("PLAYER").entity(playerUuid.toString())
    .get("currencies.gold")
    .thenAccept(value -> {
        int gold = value.asInt(0);
        player.sendMessage(Message.raw("You have " + gold + " gold"));
    });

// Setting player gold
Data.from("PLAYER").entity(playerUuid.toString())
    .set("currencies.gold", 500);

// Add 100 gold atomically
Data.from("PLAYER").entity(playerUuid.toString())
    .add("currencies.gold", 100);

package com.example.mymod;

import com.hypixel.hytale.server.core.plugin.JavaPlugin;
import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
import com.hypixel.hytale.server.core.event.events.player.PlayerReadyEvent;
import com.unifieddata.api.Data;

public final class ExampleMod extends JavaPlugin {

    public ExampleMod(JavaPluginInit init) {
        super(init);
    }

    @Override
    protected void setup() {
        // Nothing needed here for UnifiedData
    }

    @Override
    protected void start() {
        // Optional: Register a schema if you plan to use queries
        Data.schema("PLAYER")
            .index("level")
            .index("currencies.gold")
            .register();

        // Register event listeners
        getEventRegistry().registerGlobal(PlayerReadyEvent.class, this::onPlayerReady);
    }

    private void onPlayerReady(PlayerReadyEvent event) {
        String uuid = event.getPlayer().getUuid().toString();

        // Check if player exists, if not initialize their data
        Data.from("PLAYER").entity(uuid).exists("level")
            .thenAccept(exists -> {
                if (!exists) {
                    // New player - initialize default data
                    Data.from("PLAYER").entity(uuid).setAll(java.util.Map.of(
                        "level", 1,
                        "currencies.gold", 100,
                        "currencies.gems", 0
                    ));
                } else {
                    // Returning player - increment login count
                    Data.from("PLAYER").entity(uuid).increment("stats.loginCount");
                }
            });
    }

    @Override
    protected void shutdown() {
        // Nothing needed - UnifiedData handles cleanup
    }
}

{
  "nickname": "Steve",
  "level": 42,
  "currencies": {
    "gold": 1500,
    "gems": 25
  },
  "stats": {
    "pvp": {
      "kills": 150,
      "deaths": 45
    }
  },
  "guilds": ["rebels", "traders"],
  "inventory": {
    "weapons": {
      "sword": {
        "damage": 50,
        "durability": 100
      }
    }
  }
}

Data.from("PLAYER").entity(uuid).get("currencies.gold")
    .thenAccept(value -> {
        int gold = value.asInt();      // Returns 0 if null
        int gold = value.asInt(100);   // Returns 100 if null
    });

Data.from("PLAYER").entity(uuid).get("currencies")
    .thenAccept(value -> {
        JsonObject currencies = value.asObject();
        // { "gold": 1500, "gems": 25 }
    });

// String
Data.from("PLAYER").entity(uuid).getString("nickname")
    .thenAccept(name -> { /* ... */ });

Data.from("PLAYER").entity(uuid).getString("nickname", "Unknown")
    .thenAccept(name -> { /* default if null */ });

// Integer
Data.from("PLAYER").entity(uuid).getInt("level")
    .thenAccept(level -> { /* ... */ });

// Long
Data.from("PLAYER").entity(uuid).getLong("stats.totalXp")
    .thenAccept(xp -> { /* ... */ });

// Double
Data.from("PLAYER").entity(uuid).getDouble("stats.kdr")
    .thenAccept(kdr -> { /* ... */ });

// Boolean
Data.from("PLAYER").entity(uuid).getBool("settings.notifications")
    .thenAccept(enabled -> { /* ... */ });

Data.from("PLAYER").entity(uuid)
    .get("currencies.gold", "currencies.gems", "level")
    .thenAccept(values -> {
        int gold = values.get("currencies.gold").asInt();
        int gems = values.get("currencies.gems").asInt();
        int level = values.get("level").asInt();
    });

Data.from("PLAYER").entity(uuid).exists("nickname")
    .thenAccept(exists -> {
        if (exists) {
            // Field exists and is not null
        }
    });

// Set a flat field
Data.from("PLAYER").entity(uuid).set("nickname", "Steve");

// Set a nested field (creates intermediate objects automatically)
Data.from("PLAYER").entity(uuid).set("currencies.gold", 500);

// Deep nesting works too
Data.from("PLAYER").entity(uuid).set("inventory.weapons.sword.damage", 50);

// Set an entire object
JsonObject stats = new JsonObject();
stats.addProperty("kills", 0);
stats.addProperty("deaths", 0);
Data.from("PLAYER").entity(uuid).set("stats.pvp", stats);

Data.from("PLAYER").entity(uuid).setAll(Map.of(
    "currencies.gold", 1000,
    "currencies.gems", 50,
    "level", 10
));

// Delete a specific field
Data.from("PLAYER").entity(uuid).delete("tempBonus");

// Delete a nested field
Data.from("PLAYER").entity(uuid).delete("currencies.tempGold");

// Delete entire entity (all data for this player)
Data.from("PLAYER").entity(uuid).deleteEntity();

// Add to a value (can be negative)
Data.from("PLAYER").entity(uuid).add("currencies.gold", 100)
    .thenAccept(newValue -> {
        // newValue is the result after adding
    });

// Increment by 1
Data.from("PLAYER").entity(uuid).increment("stats.loginCount");

// Decrement by 1
Data.from("PLAYER").entity(uuid).decrement("inventory.potions");

Data.from("PLAYER").entity(uuid).toggle("settings.darkMode")
    .thenAccept(newValue -> {
        // newValue is the new boolean state
    });

// Push to array (creates array if doesn't exist)
Data.from("PLAYER").entity(uuid).push("guilds", "rebels");

// Pull from array (removes first matching element)
Data.from("PLAYER").entity(uuid).pull("guilds", "rebels")
    .thenAccept(removed -> {
        // true if element was found and removed
    });

// Apply custom transformation
Data.from("PLAYER").entity(uuid).update("level", current -> {
    int level = current.asInt(1);
    return Math.min(level + 1, 100); // Cap at 100
});

Data.query("PLAYER")
    .where("level").greaterThan(40)
    .execute()
    .thenAccept(entities -> {
        for (Entity entity : entities) {
            String id = entity.id();
            int level = entity.get("level").asInt();
        }
    });

// AND conditions
Data.query("PLAYER")
    .where("level").greaterThan(40)
    .and("currencies.gold").greaterThan(1000)
    .execute();

// OR conditions
Data.query("PLAYER")
    .where("rank").equalTo("admin")
    .or("rank").equalTo("moderator")
    .execute();

Data.query("PLAYER")
    .where("level").greaterThan(0)
    .orderBy("level", false)  // false = descending
    .limit(10)
    .execute();

// Purchase: only succeed if player has enough gold
Data.from("PLAYER").entity(uuid)
    .transaction()
    .require("currencies.gold").greaterThanOrEqual(100)
    .then()
    .add("currencies.gold", -100)
    .add("inventory.potions", 1)
    .commit()
    .thenAccept(result -> {
        if (result.isSuccess()) {
            player.sendMessage(Message.raw("Purchase successful!"));
        } else {
            player.sendMessage(Message.raw("Not enough gold!"));
        }
    });

Data.schema("PLAYER")
    .index("level")               // Index flat field
    .index("rank")
    .index("currencies.gold")     // Index nested field
    .indexArray("guilds")         // Index array elements
    .register();

// Default: SMART - reads from cache, writes to both
Data.from("PLAYER").entity(uuid).get("currencies.gold");

// Local smart - uses local RAM cache only (bypasses network cache)
// Best for time-critical operations like combat/movement
Data.from("PLAYER").entity(uuid)
    .mode(StorageMode.LOCAL_SMART)
    .get("stats.health");

// Local cache only - volatile RAM storage, no persistence
// Best for cooldowns, temp state, tick data
Data.from("PLAYER").entity(uuid)
    .mode(StorageMode.LOCAL_CACHE_ONLY)
    .set("cooldowns.dash", System.currentTimeMillis() + 5000);

// Force read from storage, bypass cache
Data.from("PLAYER").entity(uuid)
    .mode(StorageMode.DIRECT)
    .get("currencies.gold");

// Primary cache only (may be network-based)
Data.from("PLAYER").entity(uuid)
    .mode(StorageMode.CACHE_ONLY)
    .set("session.tempData", data);

// Write to cache immediately, storage async (faster but risky)
Data.from("PLAYER").entity(uuid)
    .mode(StorageMode.WRITE_BEHIND)
    .set("stats.lastSeen", System.currentTimeMillis());

{
  "storageBackend": "json",
  "dataDirectory": "data",
  "cacheTtlSeconds": 300,
  "cacheMaxEntries": 10000,
  "cacheEnabled": true,
  "ioThreadPoolSize": 4,
  "asyncWrites": true,
  "debugLogging": false
}

value.isNull()      // true if null or missing
value.exists()      // true if not null
value.isString()
value.isNumber()
value.isBool()
value.isArray()
value.isObject()

value.asString()              // null if not string
value.asString("default")     // "default" if null

value.asInt()                 // 0 if not number
value.asInt(100)              // 100 if null

value.asLong()
value.asLong(0L)

value.asDouble()
value.asDouble(0.0)

value.asBool()                // false if not boolean
value.asBool(true)            // true if null

value.asArray()               // null if not array
value.asList()                // Empty list if null

value.asObject()              // null if not object