Function bodies 82 total

public class ConfigScreen {

    public static Screen create(Screen parent) {
        ModConfig config = ModConfig.getInstance();
        ModConfig defaults = new ModConfig();

        ConfigBuilder builder = ConfigBuilder.create()
                .setParentScreen(parent)
                .setTitle(Text.translatable("config.miningstats.title"))
                .setSavingRunnable(config::save);

        ConfigEntryBuilder entry = builder.entryBuilder();

        // === HUD Settings ===
        ConfigCategory hud = builder.getOrCreateCategory(
                Text.translatable("config.miningstats.category.hud"));

        hud.addEntry(entry.startSelector(
                        Text.translatable("config.miningstats.hud_position"),
                        new String[]{"TOP_LEFT", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_RIGHT"},
                        config.hudPosition)
                .setDefaultValue("BOTTOM_LEFT")
                .setTooltip(Text.translatable("config.miningstats.hud_posit

    public static Screen create(Screen parent) {
        ModConfig config = ModConfig.getInstance();
        ModConfig defaults = new ModConfig();

        ConfigBuilder builder = ConfigBuilder.create()
                .setParentScreen(parent)
                .setTitle(Text.translatable("config.miningstats.title"))
                .setSavingRunnable(config::save);

        ConfigEntryBuilder entry = builder.entryBuilder();

        // === HUD Settings ===
        ConfigCategory hud = builder.getOrCreateCategory(
                Text.translatable("config.miningstats.category.hud"));

        hud.addEntry(entry.startSelector(
                        Text.translatable("config.miningstats.hud_position"),
                        new String[]{"TOP_LEFT", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_RIGHT"},
                        config.hudPosition)
                .setDefaultValue("BOTTOM_LEFT")
                .setTooltip(Text.translatable("config.miningstats.hud_position.tooltip"))
              

public class ModConfig {

    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
    private static final File CONFIG_FILE = new File(
            FabricLoader.getInstance().getConfigDir().toFile(),
            "miningstats.json"
    );

    private static ModConfig INSTANCE = null;

    // HUD Settings
    public String hudPosition = "BOTTOM_LEFT";
    public boolean hudVisibleAlways = false;
    public float hudOpacity = 0.6f;

    // Session Settings
    public boolean showSessionSummary = true;
    public boolean persistSessions = false;

    // Tracking Settings
    public boolean mergeDeepslate = true;
    public List<String> trackedOres = new ArrayList<>();

    // Milestone Settings
    public Map<String, Integer> milestones = new HashMap<>();

    public ModConfig() {
        // Default milestones
        milestones.put("diamond", 100);
        milestones.put("emerald", 50);
        milestones.put("ancient_debris", 25);
    }

    public static Mo

    public ModConfig() {
        // Default milestones
        milestones.put("diamond", 100);
        milestones.put("emerald", 50);
        milestones.put("ancient_debris", 25);
    }

    public static ModConfig getInstance() {
        if (INSTANCE == null) {
            INSTANCE = load();
        }
        return INSTANCE;
    }

    public static ModConfig load() {
        if (CONFIG_FILE.exists()) {
            try (FileReader reader = new FileReader(CONFIG_FILE)) {
                ModConfig config = GSON.fromJson(reader, ModConfig.class);
                if (config != null) {
                    return config;
                }
            } catch (IOException e) {
                System.err.println("Failed to load MiningStats config: " + e.getMessage());
            }
        }
        ModConfig config = new ModConfig();
        config.save();
        return config;
    }

    public void save() {
        try {
            CONFIG_FILE.getParentFile().mkdirs();
            try (FileWriter writer = new FileWriter(CONFIG_FILE)) {
                GSON.toJson(this, writer);
            }
        } catch (IOException e) {
            System.err.println("Failed to save MiningStats config: " + e.getMessage());
        }
    }

    public int getMilestoneThreshold(OreType type) {
        String key = type.name().toLowerCase();
        return milestones.getOrDefault(key, 0);
    }

    public HudPosition getHudPosition() {
        try {
            return HudPosition.valueOf(hudPosition);
        } catch (IllegalArgumentException e) {
            return HudPosition.BOTTOM_LEFT;
        }
    }

public class ModMenuIntegration implements ModMenuApi {

    @Override
    public ConfigScreenFactory<?> getModConfigScreenFactory() {
        return ConfigScreen::create;
    }
}

    public ConfigScreenFactory<?> getModConfigScreenFactory() {
        return ConfigScreen::create;
    }

public class OreRegistry {

    private static final Map<Block, OreType> BLOCK_TO_ORE = new HashMap<>();
    private static final Map<Identifier, OreType> CUSTOM_ORES = new HashMap<>();

    static {
        // Normal ores
        register(Blocks.COAL_ORE, OreType.COAL);
        register(Blocks.IRON_ORE, OreType.IRON);
        register(Blocks.GOLD_ORE, OreType.GOLD);
        register(Blocks.NETHER_GOLD_ORE, OreType.GOLD);
        register(Blocks.DIAMOND_ORE, OreType.DIAMOND);
        register(Blocks.EMERALD_ORE, OreType.EMERALD);
        register(Blocks.LAPIS_ORE, OreType.LAPIS);
        register(Blocks.REDSTONE_ORE, OreType.REDSTONE);
        register(Blocks.COPPER_ORE, OreType.COPPER);
        register(Blocks.NETHER_QUARTZ_ORE, OreType.QUARTZ);
        register(Blocks.ANCIENT_DEBRIS, OreType.ANCIENT_DEBRIS);

        // Deepslate variants (tracked separately, merged at display level via config)
        register(Blocks.DEEPSLATE_COAL_ORE, OreType.DEEPSLATE_COAL);
        register(Bloc

    private static void register(Block block, OreType type) {
        BLOCK_TO_ORE.put(block, type);
    }

    public static Optional<OreType> getOreType(Block block) {
        OreType type = BLOCK_TO_ORE.get(block);
        if (type != null) {
            return Optional.of(type);
        }
        Identifier id = Registries.BLOCK.getId(block);
        type = CUSTOM_ORES.get(id);
        return Optional.ofNullable(type);
    }

    public static void loadCustomOres(List<String> oreIds) {
        CUSTOM_ORES.clear();
        for (String oreId : oreIds) {
            Identifier id = Identifier.tryParse(oreId);
            if (id != null) {
                CUSTOM_ORES.put(id, OreType.COAL);
            }
        }
    }

    OreType(String displayName, int baseDrop, Item dropItem, OreType baseType) {
        this.displayName = displayName;
        this.baseDrop = baseDrop;
        this.dropItem = dropItem;
        this.baseType = baseType;
    }

    public String getDisplayName() {
        return displayName;
    }

    public int getBaseDrop() {
        return baseDrop;
    }

    public Item getDropItem() {
        return dropItem;
    }

    public boolean hasFortuneEffect() {
        return this != ANCIENT_DEBRIS;
    }

    public boolean isDeepslate() {
        return baseType != null;
    }

    public OreType getBaseType() {
        return baseType != null ? baseType : this;
    }

public class SessionData {

    private static final SessionData INSTANCE = new SessionData();

    private final Map<OreType, Integer> oreCounts = new EnumMap<>(OreType.class);
    private final Map<OreType, Integer> fortuneBonus = new EnumMap<>(OreType.class);
    private long sessionStartTime;
    private boolean active = false;
    private long pausedDurationMillis = 0;
    private long pauseStartTime = 0;

    private SessionData() {
        reset();
    }

    public static SessionData getInstance() {
        return INSTANCE;
    }

    public void reset() {
        oreCounts.clear();
        fortuneBonus.clear();
        sessionStartTime = System.currentTimeMillis();
        active = false;
        pausedDurationMillis = 0;
        pauseStartTime = 0;
    }

    public void start() {
        if (!active) {
            if (sessionStartTime == 0 || getTotalOres() == 0) {
                sessionStartTime = System.currentTimeMillis();
                pausedDurationMillis = 0;
      

    private SessionData() {
        reset();
    }

    public static SessionData getInstance() {
        return INSTANCE;
    }

    public void reset() {
        oreCounts.clear();
        fortuneBonus.clear();
        sessionStartTime = System.currentTimeMillis();
        active = false;
        pausedDurationMillis = 0;
        pauseStartTime = 0;
    }

    public void start() {
        if (!active) {
            if (sessionStartTime == 0 || getTotalOres() == 0) {
                sessionStartTime = System.currentTimeMillis();
                pausedDurationMillis = 0;
            }
            if (pauseStartTime > 0) {
                pausedDurationMillis += System.currentTimeMillis() - pauseStartTime;
                pauseStartTime = 0;
            }
            active = true;
        }
    }

    public void pause() {
        if (active) {
            active = false;
            pauseStartTime = System.currentTimeMillis();
        }
    }

    public boolean isActive() {
        return active;
    }

    public void incrementOreCount(OreType type) {
        oreCounts.merge(type, 1, Integer::sum);
    }

    public void addFortuneBonus(OreType type, int bonus) {
        if (bonus > 0) {
            fortuneBonus.merge(type, bonus, Integer::sum);
        }
    }

    public int getOreCount(OreType type) {
        return oreCounts.getOrDefault(type, 0);
    }

    public int getFortuneBonus(OreType type) {
        return fortuneBonus.getOrDefault(type, 0);
    }

    public Map<OreType, Integer> getOreCounts() {
        return oreCounts;
    }

    public int getTotalOres() {
        return oreCounts.values().stream().mapToInt(Integer::intValue).sum();
    }

    public int getTotalFortuneBonus() {
        return fortuneBonus.values().stream().mapToInt(Integer::intValue).sum();
    }

    public long getSessionDurationMillis() {
        long elapsed = System.currentTimeMillis() - sessionStartTime;
        long paused = pausedDurationMillis;
        if (!active && pauseStartTime > 0) {
            paused += System.currentTimeMillis() - pauseStartTime;
        }
        return elapsed - paused;
    }

    public Map<OreType, Integer> getMergedOreCounts() {
        Map<OreType, Integer> merged = new LinkedHashMap<>();
        for (OreType type : OreType.values()) {
            int count = getOreCount(type);
            if (count <= 0) continue;
            OreType base = type.getBaseType();
            merged.merge(base, count, Integer::sum);
        }
        return merged;
    }

    public Map<OreType, Integer> getMergedFortuneBonuses() {
        Map<OreType, Integer> merged = new LinkedHashMap<>();
        for (OreType type : OreType.values()) {
            int bonus = getFortuneBonus(type);
            if (bonus <= 0) continue;
            OreType base = type.getBaseType();
            merged.merge(base, bonus, Integer::sum);
        }
        return merged;
    }

    public int getMergedOreCount(OreType baseType) {
        int count = getOreCount(baseType);
        for (OreType type : OreType.values()) {
            if (type.isDeepslate() && type.getBaseType() == baseType) {
                count += getOreCount(type);
            }
        }
        return count;
    }

    public String getFormattedDuration() {
        long totalSeconds = getSessionDurationMillis() / 1000;
        long hours = totalSeconds / 3600;
        long minutes = (totalSeconds % 3600) / 60;
        long seconds = totalSeconds % 60;
        return String.format("%02d:%02d:%02d", hours, minutes, seconds);
    }

    public void saveToDisk() {
        try {
            Map<String, Object> data = new HashMap<>();

            Map<String, Integer> oreData = new HashMap<>();
            for (Map.Entry<OreType, Integer> e : oreCounts.entrySet()) {
                if (e.getValue() > 0) oreData.put(e.getKey().name(), e.getValue());
            }
            data.put("oreCounts", oreData);

            Map<String, Integer> fortuneData = new HashMap<>();
            for (Map.Entry<OreType, Integer> e : fortuneBonus.entrySet()) {
                if (e.getValue() > 0) fortuneData.put(e.getKey().name(), e.getValue());
            }
            data.put("fortuneBonus", fortuneData);

            data.put("durationMillis", getSessionDurationMillis());

            SESSION_FILE.getParentFile().mkdirs();
            try (FileWriter writer = new FileWriter(SESSION_FILE)) {
                GSON.toJson(data, writer);
            }
        } catch (IOException e) {
            System.err.println("Failed to save M

    public boolean loadFromDisk() {
        if (!SESSION_FILE.exists()) return false;
        try (FileReader reader = new FileReader(SESSION_FILE)) {
            Type mapType = new TypeToken<Map<String, Object>>() {}.getType();
            Map<String, Object> data = GSON.fromJson(reader, mapType);
            if (data == null) return false;

            reset();

            @SuppressWarnings("unchecked")
            Map<String, Double> oreData = (Map<String, Double>) data.get("oreCounts");
            if (oreData != null) {
                for (Map.Entry<String, Double> e : oreData.entrySet()) {
                    try {
                        OreType type = OreType.valueOf(e.getKey());
                        oreCounts.put(type, e.getValue().intValue());
                    } catch (IllegalArgumentException ignored) {}
                }
            }

            @SuppressWarnings("unchecked")
            Map<String, Double> fortuneData = (Map<String, Double>) data.get("fortuneBonu

    public void deleteSavedSession() {
        if (SESSION_FILE.exists()) {
            SESSION_FILE.delete();
        }
    }

public class HudEffects {

    private static int flashTicksRemaining = 0;
    private static int resetMessageTicksRemaining = 0;

    private static final int FLASH_DURATION = 10;  // 0.5 seconds
    private static final int RESET_MESSAGE_DURATION = 40;  // 2 seconds

    public static void triggerFlash() {
        flashTicksRemaining = FLASH_DURATION;
    }

    public static void triggerResetMessage() {
        resetMessageTicksRemaining = RESET_MESSAGE_DURATION;
    }

    public static void tick() {
        if (flashTicksRemaining > 0) flashTicksRemaining--;
        if (resetMessageTicksRemaining > 0) resetMessageTicksRemaining--;
    }

    public static boolean isFlashing() {
        return flashTicksRemaining > 0;
    }

    public static float getFlashAlpha() {
        return (float) flashTicksRemaining / FLASH_DURATION;
    }

    public static boolean isShowingResetMessage() {
        return resetMessageTicksRemaining > 0;
    }
}

    public static void triggerFlash() {
        flashTicksRemaining = FLASH_DURATION;
    }

    public static void triggerResetMessage() {
        resetMessageTicksRemaining = RESET_MESSAGE_DURATION;
    }

    public static void tick() {
        if (flashTicksRemaining > 0) flashTicksRemaining--;
        if (resetMessageTicksRemaining > 0) resetMessageTicksRemaining--;
    }

    public static boolean isFlashing() {
        return flashTicksRemaining > 0;
    }

    public static float getFlashAlpha() {
        return (float) flashTicksRemaining / FLASH_DURATION;
    }