Added Empire State API

There's still a few things that need to be done till I can declare
v1.1.0 as "done"

Author: Geolykt

src/main/java/de/geolykt/starloader/api/Galimulator.java

@@ -16,7 +16,12 @@
  * This should be used to reduce the amount of calls to obfuscated methods, which will improve the
  *  sanity of anyone that is working on updating an extension.
  */
-public class Galimulator {
+public final class Galimulator {
+
+    /**
+     * Constructor that should not be called.
+     */
+    private Galimulator() {}
 
     /**
      * Connect two stars with each other. The preferred way of connecting two stars.

src/main/java/de/geolykt/starloader/api/empire/ActiveEmpire.java

@@ -116,6 +116,14 @@ public interface ActiveEmpire extends Empire, Metadatable {
      */
     public @NotNull Religion getReligion();
 
+    /**
+     * Obtains the registry key of the current state of the empire.
+     * To obtain the actual empire state object, it has to be passed into it's respective registry first.
+     *
+     * @return A {@link NamespacedKey} representing the current state of the empire.
+     */
+    public @NotNull NamespacedKey getState();
+
     /**
      * Obtains the technology level of the empire. It shouldn't be below 1 as math have some issues there and this
      * event does not occur naturally.
@@ -186,4 +194,14 @@ public interface ActiveEmpire extends Empire, Metadatable {
      * @param religion The new religion to preach
      */
     public void setReligion(@NotNull Religion religion);
+
+    /**
+     * Sets the state of the empire via a registry key that corresponds to the future state of the empire.
+     * Note that the key should be valid and for invalid keys an exception will quickly be thrown.
+     *
+     * @param state A {@link NamespacedKey} representing the future state of the empire.
+     * @param force If true no events will be called and the action is more likely to happen
+     * @return Whether the state was changed
+     */
+    public boolean setState(@NotNull NamespacedKey state, boolean force);
 }

src/main/java/de/geolykt/starloader/api/event/empire/EmpireRiotingEvent.java

@@ -0,0 +1,21 @@
+package de.geolykt.starloader.api.event.empire;
+
+import org.jetbrains.annotations.NotNull;
+
+import de.geolykt.starloader.api.empire.ActiveEmpire;
+import de.geolykt.starloader.api.registry.RegistryKeys;
+
+/**
+ * Event that is fired whenever an empire enters a rioting stage.
+ */
+public class EmpireRiotingEvent extends EmpireStateChangeEvent {
+
+    /**
+     * Constructor.
+     *
+     * @param empire The affected empire
+     */
+    public EmpireRiotingEvent(@NotNull ActiveEmpire empire) {
+        super(empire, RegistryKeys.GALIMULATOR_RIOTING);
+    }
+}

src/main/java/de/geolykt/starloader/api/event/empire/EmpireStabiliseEvent.java

@@ -0,0 +1,28 @@
+package de.geolykt.starloader.api.event.empire;
+
+import org.jetbrains.annotations.NotNull;
+
+import de.geolykt.starloader.api.NamespacedKey;
+import de.geolykt.starloader.api.empire.ActiveEmpire;
+
+/**
+ * Event that is fired whenever an Empire changes into a stanle state from a less stable state, like
+ * if the empire changed from the RIOTING or DEGENERATING state.
+ *
+ * @see EmpireUnfortifyEvent
+ */
+public class EmpireStabiliseEvent extends EmpireStateChangeEvent {
+
+    /**
+     * Constructor.
+     * For certain states a subclass might be better used.
+     * The validity of the registry key is not directly checked by this constructor,
+     * however it would be nice of the caller to make sure that it is valid as otherwise bad things can happen.
+     *
+     * @param empire The target empire
+     * @param state The registry key of the new state of the empire
+     */
+    public EmpireStabiliseEvent(@NotNull ActiveEmpire empire, @NotNull NamespacedKey state) {
+        super(empire, state);
+    }
+}

src/main/java/de/geolykt/starloader/api/event/empire/EmpireStateChangeEvent.java

@@ -0,0 +1,61 @@
+package de.geolykt.starloader.api.event.empire;
+
+import org.jetbrains.annotations.NotNull;
+
+import de.geolykt.starloader.api.NamespacedKey;
+import de.geolykt.starloader.api.empire.ActiveEmpire;
+import de.geolykt.starloader.api.event.Cancellable;
+
+/**
+ * Event fired when the state of an empire is altered.
+ */
+public class EmpireStateChangeEvent extends EmpireEvent implements Cancellable {
+
+    /**
+     * The registry key of the proposed new state of the empire.
+     */
+    protected final NamespacedKey state;
+
+    /**
+     * The cancellation status of the event.
+     * It should not be modified directly and instead be modified via {@link Cancellable#setCancelled(boolean)}.
+     */
+    private boolean cancelled = false;
+
+    /**
+     * Constructor.
+     * For certain states a subclass might be better used.
+     * The validity of the registry key is not directly checked by this constructor,
+     * however it would be nice of the caller to make sure that it is valid as otherwise bad things can happen.
+     *
+     * @param empire The target empire
+     * @param newState The registry key of the new state of the empire
+     */
+    public EmpireStateChangeEvent(@NotNull ActiveEmpire empire, @NotNull NamespacedKey newState) {
+        super(empire);
+        state = newState;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    /**
+     * Obtains a {@link NamespacedKey} that represents the new empire state that will be applied once
+     * the event is passed without getting cancelled (this might not be the case if the event is fired by an extension
+     * for dummy checks). To obtain the empire state it has to be passed through a registry beforehand.
+     * Note that the validity of the key is not guaranteed, however it is very likely that it is a valid registry key.
+     * Unless the caller of the constructor did some errors.
+     *
+     * @return The {@link NamespacedKey} of the new state of the empire.
+     */
+    public @NotNull NamespacedKey getNewState() {
+        return state;
+    }
+}

src/main/java/de/geolykt/starloader/api/event/empire/EmpireTranscendEvent.java

@@ -0,0 +1,24 @@
+package de.geolykt.starloader.api.event.empire;
+
+import org.jetbrains.annotations.NotNull;
+
+import de.geolykt.starloader.api.empire.ActiveEmpire;
+import de.geolykt.starloader.api.registry.RegistryKeys;
+
+/**
+ * Event that is fired whenever an Empire transcends into hyperbliss.
+ * It is most often fired almost directly after an {@link TechnologyLevelSetEvent}, however extensions
+ * might fire this event directly.
+ */
+public class EmpireTranscendEvent extends EmpireStateChangeEvent {
+
+    /**
+     * Constructor.
+     *
+     * @param empire The affected empire
+     */
+    public EmpireTranscendEvent(@NotNull ActiveEmpire empire) {
+        super(empire, RegistryKeys.GALIMULATOR_TRANSCENDING);
+        // No further data
+    }
+}

src/main/java/de/geolykt/starloader/api/gui/Drawing.java

@@ -112,7 +112,7 @@ public static float drawText(@NotNull String message, float x, float y, @NotNull
      *
      * @param message The message to send
      */
-    public static void sendBulletin(@NotNull String message) {
+    public static void sendBulletin(@NotNull String message) { // FIXME typo
         implementation.sendBulletin(message);
     }
 

src/main/java/de/geolykt/starloader/api/registry/EmpireStateMetadataEntry.java

@@ -0,0 +1,54 @@
+package de.geolykt.starloader.api.registry;
+
+import de.geolykt.starloader.api.registry.MetadatableRegistry.MetadataEntry;
+
+/**
+ * The metadata entry for empire states.
+ * This for example can be used for dynamic responses to the empire state as well
+ * as further extension harmony.
+ */
+public class EmpireStateMetadataEntry extends MetadataEntry {
+
+    /**
+     * Used for {@link #isStable()}
+     */
+    protected final boolean stable;
+
+    /**
+     * Whether diplomatic relations are hindered due to the warmongering behaviour
+     * Used for {@link #isWarmongering()}
+     */
+    protected final boolean warmongering;
+
+    /**
+     * Constructor.
+     *
+     * @param stable Whether to consider the state "stable"
+     * @param warmongering Whether diplomatic relations are hindered due to the warmongering behaviour
+     */
+    public EmpireStateMetadataEntry(boolean stable, boolean warmongering) {
+        this.stable = stable;
+        this.warmongering = warmongering;
+    }
+
+    /**
+     * Obtains whether this empire state can be considered "stable", for example
+     * Fortifying as well as expanding fall under this category.
+     *
+     * @return Whether the state is considered stable
+     */
+    public boolean isStable() {
+        return stable;
+    }
+
+    /**
+     * Whether diplomatic relations are handicapped due to the warmongering behaviour.
+     * In the base game, blood crusade, crusading and ALL WILL BE ASHES fall in this category.
+     * If the implementation returns true, then the treaties will be voided when the new state is added
+     *
+     * @return The warmongering flag
+     */
+    public boolean isWarmongering() {
+        return warmongering;
+    }
+}

src/main/java/de/geolykt/starloader/api/registry/MetadatableRegistry.java

@@ -0,0 +1,72 @@
+package de.geolykt.starloader.api.registry;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import de.geolykt.starloader.api.NamespacedKey;
+
+/**
+ * Registry of enum and/or enum-like objects with additionally capability to add metadata to
+ * the key-value pairs. This is added for extension harmony as multiple extensions cannot do these
+ * themselves without  breaking aspects of the functionality or creating agreements themselves.
+ * Since the StarloaderAPI is already one of the first extensions to experiment with such aspects,
+ * the StarloaderAPI is taking the authority in this.
+ * The metadata is a concept that is introduced since especially non-abstract enums are very state based
+ * and a metadata API would make it more data based and increase the modifiability of the behaviour of the game.
+ *
+ * @param <T> The type the registry is holding
+ * @param <U> The metadata container type of the registry entries
+ */
+public abstract class MetadatableRegistry<T, U extends MetadatableRegistry.MetadataEntry> extends Registry<T> {
+
+    /**
+     * The metadata entry structure. Does nothing on it's own other than looking good; it is up to the implementation
+     * to make it more meaningful.
+     */
+    public static abstract class MetadataEntry {}
+
+    /**
+     * Internal map containing the key-metadata entry pairs of the registry for lookup.
+     */
+    protected final Map<NamespacedKey, U> metadataEntries = new HashMap<>();
+
+    /**
+     * Obtains the metadata entry bound to the given registry key. If no metadata is bound at that key,
+     * then null will be returned.
+     *
+     * @param key The {@link NamespacedKey} that is used for the lookup operation
+     * @return The {@link MetadataEntry}
+     */
+    public @Nullable U getMetadataEntry(@NotNull NamespacedKey key) {
+        return metadataEntries.get(key);
+    }
+
+    /**
+     * @deprecated This method has no use as it does not specify the metadata.
+     *
+     * This operation instantly throws an exception
+     *
+     * @param key irrelevant
+     * @param value irrelevant
+     */
+    @Override
+    @Deprecated(forRemoval = false, since = "1.1.0")
+    public final void register(@NotNull NamespacedKey key, @NotNull T value) {
+        throw new IllegalArgumentException("The metadatable registry requires to know the metadata entry."
+                + "Use the other register method instead.");
+    }
+
+    /**
+     * Registers the value to the given key; the implementation might be thread-safe, however extensions should always
+     * believe that multithreading can be dangerous and as such this method should never be called concurrently as otherwise
+     * some other things (such as the values array) might break.
+     *
+     * @param key The key of the entry to register
+     * @param value The value of the entry
+     * @param metadata The metadata entry.
+     */
+    public abstract void register(@NotNull NamespacedKey key, @NotNull T value, @NotNull U metadata);
+}

src/main/java/de/geolykt/starloader/api/registry/Registry.java

@@ -9,9 +9,10 @@
 import de.geolykt.starloader.DebugNagException;
 import de.geolykt.starloader.api.NamespacedKey;
 import snoddasmannen.galimulator.EmpireSpecial;
+import snoddasmannen.galimulator.EmpireState;
 
 /**
- * Registry of enum and/or enum-like objects.s
+ * Registry of enum and/or enum-like objects.
  * This is added for extension harmony as multiple extensions cannot do these themselves without
  * breaking aspects of the functionality or creating agreements themselves. Since the StarloaderAPI
  * is already one of the first extensions to experiment with such aspects, the StarloaderAPI is taking
@@ -26,6 +27,11 @@ public abstract class Registry<T> {
      */
     public static Registry<EmpireSpecial> EMPIRE_SPECIALS;
 
+    /**
+     * The empire state registry.
+     */
+    public static MetadatableRegistry<EmpireState, EmpireStateMetadataEntry> EMPIRE_STATES;
+
     /**
      * Internal map containing the key-value pairs of the registry for lookup.
      */
@@ -87,6 +93,8 @@ public abstract class Registry<T> {
      * Registers the value to the given key; the implementation might be thread-safe, however extensions should always
      * believe that multithreading can be dangerous and as such this method should never be called concurrently as otherwise
      * some other things (such as the values array) might break.
+     * Note that {@link MetadatableRegistry} does not support this method, if the registry is one of these,
+     * {@link MetadatableRegistry#register(NamespacedKey, Object, de.geolykt.starloader.api.registry.MetadatableRegistry.MetadataEntry)} should be used instead.
      *
      * @param key The key of the entry to register
      * @param value The value of the entry