Вопрос EventsRenderer Spookytime

[CobzaQvi4]

Имеется такой код:
Где взять юрл для спукитайм ивентов, юрл указанный в коде неактивен

package dev.sunlight.ui.display.impl;

import com.google.common.eventbus.Subscribe;
import dev.sunlight.ui.display.ElementRenderer;
import dev.sunlight.events.EventDisplay;
import dev.sunlight.utils.drag.Dragging;
import dev.sunlight.utils.render.color.ColorUtils;
import dev.sunlight.utils.text.BetterText;
import net.minecraft.util.text.ITextComponent;
import lombok.experimental.FieldDefaults;
import lombok.RequiredArgsConstructor;
import lombok.AccessLevel;
import com.mojang.blaze3d.matrix.MatrixStack;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

@FieldDefaults(level = AccessLevel.PRIVATE)
@RequiredArgsConstructor
public class EventsRenderer implements ElementRenderer {
    final Dragging dragging;
    float width;
    float height;
    float headerHeight;
    float eventsHeight;
    float spacingGap = 1.0f;
    private static final String urlevents = "http://87.120.186.137:5000/events";
    private static final Pattern patern = Pattern.compile("До следующего ивента:(\\d+)сек Анархия (\\d+)");
    private static final int maxPlannedEvents = 5;
    private static final int maxUnplannedEvents = 50;
    private final List<EventInfo> events = new ArrayList<>();
    private final Map<String, Integer> lowestSecondsMap = new HashMap<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    private boolean isInitialized = false;
    private long lastUpdateTime = 0;
    private long lastSuccessfulFetch = 0;
    private boolean fetchInProgress = false;

    private static class EventInfo {
        private final String name;
        private int seconds;
        private final long creationTime;

        public EventInfo(String name, int seconds) {
            this.name = name;
            this.seconds = seconds;
            this.creationTime = System.currentTimeMillis();
        }

        public String getName() {
            return name;
        }

        public int getSeconds() {
            return seconds;
        }

        public void setSeconds(int seconds) {
            this.seconds = seconds;
        }

        public void decrementSeconds() {
            if (seconds > 0) {
                seconds--;
            }
        }

        public long getCreationTime() {
            return creationTime;
        }
    }

    private void initialize() {
        if (isInitialized) return;
        isInitialized = true;
        scheduler.scheduleAtFixedRate(this::fetchEvents, 0, 2, TimeUnit.SECONDS);
        scheduler.scheduleAtFixedRate(this::updateCountdown, 1, 1, TimeUnit.SECONDS);
    }

    private void updateCountdown() {
        synchronized (events) {
            List<EventInfo> updatedEvents = new ArrayList<>(events);

            for (EventInfo event : updatedEvents) {
                event.decrementSeconds();
                String eventName = event.getName();
                int currentSeconds = event.getSeconds();
                lowestSecondsMap.compute(eventName, (k, v) -> (v == null || currentSeconds < v) ? currentSeconds : v);
            }
            long now = System.currentTimeMillis();
            updatedEvents.removeIf(event -> event.getSeconds() <= 0 && (now - event.getCreationTime() > 5000));
            updatedEvents.sort(Comparator.comparingInt(EventInfo::getSeconds));
            if (updatedEvents.size() > (maxPlannedEvents + maxUnplannedEvents)) {
                updatedEvents = new ArrayList<>(updatedEvents.subList(0, maxPlannedEvents + maxUnplannedEvents));
            }
            events.clear();
            events.addAll(updatedEvents);
        }
    }

    private void fetchEvents() {
        if (fetchInProgress) {
            return;
        }

        long currentTime = System.currentTimeMillis();
        if (currentTime - lastUpdateTime < 1000) {
            return;
        }

        fetchInProgress = true;
        lastUpdateTime = currentTime;

        CompletableFuture.runAsync(() -> {
            HttpURLConnection connection = null;
            try {
                URL url = new URL(urlevents);
                connection = (HttpURLConnection) url.openConnection();
                connection.setRequestMethod("GET");
                connection.setConnectTimeout(3000);
                connection.setReadTimeout(3000);

                int responseCode = connection.getResponseCode();
                System.out.println("HTTP Response Code: " + responseCode); // Отладочный вывод

                if (responseCode == HttpURLConnection.HTTP_OK) {
                    BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                    StringBuilder response = new StringBuilder();
                    String line;

                    while ((line = reader.readLine()) != null) {
                        response.append(line);
                    }
                    reader.close();

                    System.out.println("API Response: " + response.toString()); // Отладочный вывод

                    parseEvents(response.toString());
                    lastSuccessfulFetch = System.currentTimeMillis();
                } else {
                    System.err.println("HTTP Error: " + responseCode);
                }
            } catch (Exception e) {
                System.err.println("Error fetching events: " + e.getMessage());
                e.printStackTrace(); // Добавьте это для полного stack trace
            } finally {
                if (connection != null) {
                    connection.disconnect();
                }
                fetchInProgress = false;
            }
        });
    }

    private void parseEvents(String jsonResponse) {
        try {
            System.out.println("Parsing JSON: " + jsonResponse); // Отладочный вывод

            List<EventInfo> newEvents = new ArrayList<>();
            Gson gson = new Gson();
            JsonArray jsonArray = gson.fromJson(jsonResponse, JsonArray.class);

            System.out.println("JSON Array size: " + (jsonArray != null ? jsonArray.size() : "null")); // Отладочный вывод

            if (jsonArray != null && jsonArray.size() > 0) {
                JsonObject eventData = jsonArray.get(0).getAsJsonObject();
                JsonArray messages = eventData.getAsJsonArray("message");

                System.out.println("Messages array: " + (messages != null ? messages.size() : "null")); // Отладочный вывод

                if (messages != null) {
                    for (JsonElement messageElement : messages) {
                        String message = messageElement.getAsString();
                        System.out.println("Processing message: " + message); // Отладочный вывод

                        Matcher matcher = patern.matcher(message);
                        if (matcher.find()) {
                            int seconds = Integer.parseInt(matcher.group(1));
                            String anarchyNumber = matcher.group(2);
                            String eventName = "/an" + anarchyNumber;

                            System.out.println("Found event: " + eventName + " with " + seconds + " seconds"); // Отладочный вывод

                            if (seconds > 0) {
                                lowestSecondsMap.put(eventName, seconds);
                                newEvents.add(new EventInfo(eventName, seconds));
                            } else {
                                lowestSecondsMap.remove(eventName);
                            }
                        } else {
                            System.out.println("Pattern did not match message: " + message); // Отладочный вывод
                        }
                    }
                }
            } else {
                System.out.println("No data in JSON array"); // Отладочный вывод
            }

            System.out.println("New events found: " + newEvents.size()); // Отладочный вывод

            newEvents.sort(Comparator.comparingInt(EventInfo::getSeconds));

            synchronized (events) {
                Map<String, EventInfo> eventMap = new HashMap<>();
                for (EventInfo event : events) {
                    eventMap.put(event.getName(), event);
                }
                for (EventInfo newEvent : newEvents) {
                    EventInfo existingEvent = eventMap.get(newEvent.getName());
                    if (existingEvent != null) {
                        existingEvent.setSeconds(Math.min(existingEvent.getSeconds(), newEvent.getSeconds()));
                    } else {
                        eventMap.put(newEvent.getName(), newEvent);
                    }
                }
                List<EventInfo> mergedEvents = new ArrayList<>(eventMap.values());
                mergedEvents.sort(Comparator.comparingInt(EventInfo::getSeconds));
                if (mergedEvents.size() > (maxPlannedEvents + maxUnplannedEvents)) {
                    mergedEvents = mergedEvents.subList(0, maxPlannedEvents + maxUnplannedEvents);
                }
                events.clear();
                events.addAll(mergedEvents);

                System.out.println("Total events after merge: " + events.size()); // Отладочный вывод
            }
        } catch (Exception e) {
            System.err.println("Error parsing events: " + e.getMessage());
            e.printStackTrace(); // Добавьте это для полного stack trace
        }
    }

    @Override
    public void render(EventDisplay eventDisplay) {
        betterText.update();
        if (!isInitialized) {
            initialize();
        }

        MatrixStack ms = eventDisplay.getMatrixStack();
        float posX = dragging.getX();
        float posY = dragging.getY();
        float fontSize = 6.5F;
        float padding = 5;
        float maxWidth = dev.sunlight.utils.render.font.Fonts.sfMedium.getWidth("Events", fontSize) + padding * 2;
        eventsHeight = 0;

        List<EventInfo> plannedEvents = new ArrayList<>();
        List<EventInfo> unplannedEvents = new ArrayList<>();

        synchronized (events) {
            for (EventInfo e : events) {
                if (e.getSeconds() > 0) {
                    plannedEvents.add(e);
                } else if (e.getSeconds() == 0) {
                    unplannedEvents.add(e);
                }
            }
        }

        plannedEvents.sort(Comparator.comparingInt(EventInfo::getSeconds));
        unplannedEvents.sort(Comparator.comparing(EventInfo::getName));

        int plannedCount = plannedEvents.size();
        int unplannedCount = unplannedEvents.size();

        List<EventInfo> currentEvents = new ArrayList<>();

        if (plannedCount == 5) {
            currentEvents.addAll(plannedEvents.subList(0, 5));
            int unplannedToShow = Math.min(50, unplannedCount);
            currentEvents.addAll(unplannedEvents.subList(0, unplannedToShow));
        } else {
            int toShow = Math.min(5, plannedCount);
            currentEvents.addAll(plannedEvents.subList(0, toShow));
        }

        boolean dataStale = System.currentTimeMillis() - lastSuccessfulFetch > 10000 && lastSuccessfulFetch > 0;

        if (currentEvents.isEmpty()) {
            String statusText = lastSuccessfulFetch == 0 ? "Loading" + betterText.getOutput() : "No events";
            if (dataStale) {
                statusText = "Connection to host";
            }
            float statusWidth = dev.sunlight.utils.render.font.Fonts.sfMedium.getWidth(statusText, fontSize) + padding * 2;
            maxWidth = Math.max(maxWidth, statusWidth);
            headerHeight = fontSize + padding * 2;
            height = headerHeight + fontSize + padding - 2;
            width = Math.max(maxWidth, 80);
            dragging.setWidth(width);
            dragging.setHeight(height);

            drawBackground(ms, posX, posY, width, height);

            // Простой белый текст для заголовка
            dev.sunlight.utils.render.font.Fonts.sfMedium.drawCenteredText(ms, "Events", posX + width / 2, posY + 4f, ColorUtils.rgb(255, 255, 255), fontSize);
            dev.sunlight.utils.render.font.Fonts.sfMedium.drawText(ms, statusText, posX + padding, posY + headerHeight + padding, dataStale ? ColorUtils.rgba(255, 100, 100, 255) : ColorUtils.rgb(170, 170, 170), fontSize);
            return;
        }

        maxWidth = dev.sunlight.utils.render.font.Fonts.sfMedium.getWidth("Events", fontSize) + padding * 2;
        eventsHeight = 0;
        for (EventInfo event : currentEvents) {
            String eventText = event.getName() + " : " + event.getSeconds() + " sec";
            float textWidth = dev.sunlight.utils.render.font.Fonts.sfMedium.getWidth(eventText, fontSize) + padding * 2;
            if (textWidth > maxWidth) {
                maxWidth = textWidth;
            }
            eventsHeight += (fontSize + padding);
        }

        width = Math.max(maxWidth, 80);
        headerHeight = fontSize + padding * 2;
        height = headerHeight + spacingGap + eventsHeight - 2;
        dragging.setWidth(width);
        dragging.setHeight(height);

        drawBackground(ms, posX - 5, posY, width, height);

        // Простой белый текст для заголовка
        dev.sunlight.utils.render.font.Fonts.sfMedium.drawCenteredText(ms, "Events", posX + width / 2, posY + 4f, ColorUtils.rgb(255, 255, 255), fontSize);

        float currentY = posY + headerHeight - 2;
        for (EventInfo event : currentEvents) {
            String name = event.getName() + " » " + event.getSeconds() + " секунд";

            int color;
            if (event.getSeconds() <= 10) {
                long time = System.currentTimeMillis();
                float frequency = 2.0f;
                float alphaWave = (float) ((Math.sin(time / 1000.0 * frequency * Math.PI) + 1) / 2);
                int alpha = (int) (100 + 155 * alphaWave);
                color = ColorUtils.rgba(255, 135, 135, alpha);
            } else if (event.getSeconds() <= 30) {
                color = ColorUtils.rgba(255, 135, 135, 255);
            } else {
                color = ColorUtils.rgb(255, 255, 255); // Белый цвет для обычных событий
            }

            dev.sunlight.utils.render.font.Fonts.sfMedium.drawText(ms, name, posX + padding - 1, currentY, color, fontSize);
            currentY += fontSize + padding;
        }
    }

    // Метод для отрисовки фона
    private void drawBackground(MatrixStack ms, float x, float y, float width, float height) {
        try {
            int colorInt = ColorUtils.rgba(20, 20, 20, 180);
            java.awt.Color color = new java.awt.Color(colorInt, true);
            dev.sunlight.utils.render.RenderUtils.drawRoundedRect(x, y, width, height, 5, color);
        } catch (Exception e) {
            // fallback
            java.awt.Color fallbackColor = new java.awt.Color(20, 20, 20, 180);
            dev.sunlight.utils.render.RenderUtils.drawRoundedRect(x, y, width, height, 5, fallbackColor);
        }
    }

    private final BetterText betterText = new BetterText(List.of(
            "...", "...", "..."
    ), 100);
}

Помогите пожалуйста