ClientboundSendStatePacket.java

package de.geolykt.multiplayer.packets.s2c;

import java.nio.charset.StandardCharsets;
import java.util.concurrent.ThreadLocalRandom;

import org.slf4j.LoggerFactory;

import de.geolykt.multiplayer.client.Shared;
import de.geolykt.multiplayer.client.hacks.ClientEmpire;
import de.geolykt.multiplayer.client.hacks.HackStarGenerator;
import de.geolykt.multiplayer.packets.Packets;
import de.geolykt.packety.PacketHandler;

import snoddasmannen.galimulator.Empire;
import snoddasmannen.galimulator.GalColor;
import snoddasmannen.galimulator.MapData;
import snoddasmannen.galimulator.QuadTree;
import snoddasmannen.galimulator.Space;
import snoddasmannen.galimulator.Star;

import io.netty.buffer.ByteBuf;

public class ClientboundSendStatePacket extends ClientboundPacket {

    public static final PacketHandler<ClientboundSendStatePacket> HANDLER = (channel, packet) -> {
        Shared.logicalTasks.add(() -> {
            Shared.starLookup.clear();
            Shared.empireLookup.clear();
            Space.stars.clear();
            Space.empires.clear();

            Space.starCount = packet.stars.length;
            Space.maxYCache = 0.8F * (float)Math.sqrt((double)(Space.starCount / 100.0F));
            Space.maxXCache = Space.maxYCache * Space.aspectRatio; // Space.aspectRatio being ~1.77
            Shared.serverMaxX = packet.mapWidth / 2.0F;
            Shared.serverMaxY = packet.mapHeight / 2.0F;
            Shared.scaleX = Space.maxXCache / Shared.serverMaxX;
            Shared.scaleY = Space.maxYCache / Shared.serverMaxY;

            Space.mapData = new MapData(new HackStarGenerator());
            Space.starsQuadTree = new QuadTree(-Space.maxXCache, -Space.maxYCache, Space.maxXCache, Space.maxYCache);

            Shared.empireLookup.put(packet.neutralEmpireId, Space.neutralEmpire);

            {
                boolean modified;
                do {
                    for (StateEmpire empire : packet.empires) {
                        Empire parent = Shared.empireLookup.get(empire.parentId);
                        if (parent == null) {
                            continue;
                        }
                        Empire e = new Empire(GalColor.generateRandomColor(0, ThreadLocalRandom.current()), empire.name, Space.mapData.getRandomGovernment(), parent, empire.name);
                        Space.empires.add(e);
                        Shared.empireLookup.put(empire.id, e);
                        modified = true;
                    }
                    modified = false;
                } while(modified);
            }

            for (StateStar star : packet.stars) {
                if (star == null) {
                    continue;
                }

                Star galimStar = new Star(star.x * Shared.scaleX, star.y * Shared.scaleY, Shared.starLookup.size() - 1 /* Star ids start with -1 */);

                Empire owner = Shared.empireLookup.get(star.ownerId);
                galimStar.setOwnerEmpire(owner);
                Space.stars.add(galimStar);
                Space.starsQuadTree.insert(galimStar);
                Shared.starLookup.put(star.id, galimStar);
                ((ClientEmpire) owner).incrementStarCount();
                owner.get_k().add(galimStar);
            }

            for (StateStar star : packet.stars) {
                if (star == null) {
                    continue;
                }
                Star galimStar = Shared.starLookup.get(star.id);
                for (long lanes : star.starlanes) {
                    Space.connectStars(galimStar, Shared.starLookup.get(lanes));
                }
            }

            Space.starsQuadTree.buildPairs();
            Space.regenerateVoronoiCells();
        });
    };

    private static record StateEmpire(long id, long parentId, String name) {
    }

    private static record StateStar(long id, long ownerId, float x, float y, long[] starlanes) {
    }

    private final StateStar[] stars;
    private final StateEmpire[] empires;
    public final float mapHeight;
    public final float mapWidth;
    public final long neutralEmpireId;

    public ClientboundSendStatePacket(ByteBuf buffer, int len) {
        super(Packets.S2C_SEND_STATE);
        int startPosition = buffer.readerIndex();
        mapHeight = buffer.readFloat();
        mapWidth = buffer.readFloat();
        stars = new StateStar[buffer.readInt()];
        empires = new StateEmpire[buffer.readInt()];

        for (int i = 0; i < stars.length; i++) {
            long id = buffer.readLong();
            long ownerId = buffer.readLong();
            float x = buffer.readFloat();
            float y = buffer.readFloat();
            long[] starlanes = new long[buffer.readByte()];
            for (int j = 0; j < starlanes.length; j++) {
                starlanes[j] = buffer.readLong();
            }
            stars[i] = new StateStar(id, ownerId, x, y, starlanes);
        }

        for (int i = 0; i < empires.length; i++) {
            long id = buffer.readLong();
            long parentId = buffer.readLong();
            String name = buffer.readCharSequence(buffer.readShort(), StandardCharsets.UTF_8).toString();
            empires[i] = new StateEmpire(id, parentId, name);
        }

        neutralEmpireId = buffer.readLong();

        if ((buffer.readerIndex() - startPosition) != len) {
            LoggerFactory.getLogger(getClass()).error("Buffer underflow/Buffer overflow: Current index {}, old index {} - expected difference {}. That is a difference of {} bytes from the expected difference", buffer.readerIndex(), startPosition, len, (len - (buffer.readerIndex() - startPosition)));
        }
    }
}