Component API Implementation

library/data/component/build.gradle

@@ -0,0 +1,60 @@
+plugins {
+	id("qsl.module")
+}
+
+qslModule {
+	name = "Quilt Component Attachment API"
+	moduleName = "component"
+	id = "quilt_component"
+	description = "API allowing attachment and querying of an ECS-like interface for entities, block-entities, chunks, etc."
+	library = "data"
+	moduleDependencies {
+		core {
+			api("qsl_base")
+			api("lifecycle_events")
+			api("networking")
+		}
+	}
+
+	entrypoints {
+		events {
+			values = [
+				"org.quiltmc.qsl.component.impl.event.ServerTickEventListener"
+			]
+		}
+
+		init {
+			values = ["org.quiltmc.qsl.component.impl.CommonInitializer"]
+		}
+
+		client_init {
+			values = ["org.quiltmc.qsl.component.impl.client.ClientInitializer"]
+		}
+	}
+
+	accessWidener()
+
+	injectedInterface("net/minecraft/class_2586") {
+		values = ["org/quiltmc/qsl/component/api/ComponentProvider"]
+	}
+
+	injectedInterface("net/minecraft/class_1297") {
+		values = ["org/quiltmc/qsl/component/api/ComponentProvider"]
+	}
+
+	injectedInterface("net/minecraft/class_2791") {
+		values = ["org/quiltmc/qsl/component/api/ComponentProvider"]
+	}
+
+	injectedInterface("net/minecraft/class_31") {
+		values = ["org/quiltmc/qsl/component/api/ComponentProvider"]
+	}
+
+	injectedInterface("net/minecraft/class_1799") {
+		values = ["org/quiltmc/qsl/component/api/ComponentProvider"]
+	}
+
+	injectedInterface("net/minecraft/class_310") {
+		values = ["org/quiltmc/qsl/component/api/ComponentProvider"]
+	}
+}

library/data/component/src/main/java/org/quiltmc/qsl/component/api/Component.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.component.api;
+
+import org.jetbrains.annotations.NotNull;
+
+public interface Component {
+	@FunctionalInterface
+	interface Factory<T extends Component> {
+		@NotNull
+		T create();
+	}
+}

library/data/component/src/main/java/org/quiltmc/qsl/component/api/ComponentContainer.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.component.api;
+
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.util.Identifier;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+public interface ComponentContainer { // TODO: Maybe split up responsibilities?
+	Optional<Component> expose(Identifier id);
+
+	void writeNbt(@NotNull NbtCompound providerRootNbt);
+
+	void readNbt(@NotNull NbtCompound providerRootNbt);
+
+	void tick(@NotNull ComponentProvider provider);
+
+	void receiveSyncPacket(@NotNull Identifier id, @NotNull PacketByteBuf buf);
+
+	void sync(@NotNull ComponentProvider provider);
+}

library/data/component/src/main/java/org/quiltmc/qsl/component/api/ComponentInjectionPredicate.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.component.api;
+
+public interface ComponentInjectionPredicate {
+	boolean canInject(ComponentProvider provider);
+}

library/data/component/src/main/java/org/quiltmc/qsl/component/api/ComponentProvider.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.component.api;
+
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.entity.Entity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.level.LevelProperties;
+import org.jetbrains.annotations.NotNull;
+import org.quiltmc.qsl.base.api.util.InjectedInterface;
+import org.quiltmc.qsl.component.api.components.FunctionComponent;
+
+import java.util.Optional;
+
+@InjectedInterface({
+		Entity.class,
+		BlockEntity.class,
+		Chunk.class,
+		LevelProperties.class,
+		ItemStack.class,
+		MinecraftClient.class
+})
+public interface ComponentProvider {
+	@NotNull
+	ComponentContainer getContainer();
+
+	default <T, U, C extends FunctionComponent<T, U>> Optional<U> call(ComponentType<C> type, T t) {
+		return this.expose(type).map(func -> func.call(this, t));
+	}
+
+	default <C extends Component> Optional<C> expose(ComponentType<C> id) {
+		return Components.expose(id, this);
+	}
+
+	default void sync() {
+		this.getContainer().sync(this);
+	}
+}

library/data/component/src/main/java/org/quiltmc/qsl/component/api/ComponentType.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.component.api;
+
+import net.minecraft.util.Identifier;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public record ComponentType<T extends Component>(Identifier id, Component.Factory<T> factory,
+												 boolean isStatic) implements Component.Factory<T> {
+	public static final Static STATIC_CACHE = new Static();
+
+	@SuppressWarnings("unchecked")
+	public Optional<T> cast(Component component) {
+		try {
+			return Optional.of((T) component);
+		} catch (ClassCastException ignored) {
+			return Optional.empty();
+		}
+	}
+
+	@Override
+	public @NotNull T create() {
+		if (this.isStatic) {
+			return STATIC_CACHE.getOrCreate(this);
+		}
+		return this.factory.create();
+	}
+
+	public static class Static {
+		private final Map<Identifier, Component> staticInstances = new HashMap<>();
+
+		private Static() {
+
+		}
+
+		@SuppressWarnings("unchecked")
+		@NotNull <C extends Component> C getOrCreate(ComponentType<C> type) {
+			if (this.staticInstances.containsKey(type.id())) {
+				return (C) this.staticInstances.get(type.id());
+			} else {
+				C singleton = type.factory.create();
+				this.staticInstances.put(type.id(), singleton);
+				return singleton;
+			}
+		}
+	}
+}

library/data/component/src/main/java/org/quiltmc/qsl/component/api/Components.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.component.api;
+
+import net.minecraft.util.Identifier;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.util.registry.RegistryKey;
+import org.quiltmc.qsl.component.api.components.TickingComponent;
+import org.quiltmc.qsl.component.impl.ComponentsImpl;
+import org.quiltmc.qsl.component.impl.predicates.ClassInjectionPredicate;
+import org.quiltmc.qsl.component.impl.predicates.FilteredInheritedInjectionPredicate;
+import org.quiltmc.qsl.component.impl.predicates.InheritedInjectionPredicate;
+import org.quiltmc.qsl.component.impl.predicates.RedirectedInjectionPredicate;
+
+import java.util.Optional;
+import java.util.Set;
+
+public final class Components {
+	public static final RegistryKey<Registry<ComponentType<?>>> REGISTRY_KEY = ComponentsImpl.REGISTRY_KEY;
+
+	public static final Registry<ComponentType<?>> REGISTRY = ComponentsImpl.REGISTRY;
+
+	public static <C extends Component> void inject(ComponentInjectionPredicate predicate, ComponentType<C> component) {
+		ComponentsImpl.inject(predicate, component);
+	}
+
+	public static <C extends Component> void inject(Class<?> clazz, ComponentType<C> component) {
+		ComponentsImpl.inject(new ClassInjectionPredicate(clazz), component);
+	}
+
+	public static <C extends Component> void injectInheritage(Class<?> clazz, ComponentType<C> component) {
+		ComponentsImpl.inject(new InheritedInjectionPredicate(clazz), component);
+	}
+
+	public static <C extends Component> void injectInheritanceExcept(Class<?> clazz, ComponentType<C> component, Class<?>... exceptions) {
+		ComponentsImpl.inject(new FilteredInheritedInjectionPredicate(clazz, exceptions), component);
+	}
+
+	public static <C extends Component> void injectRedirected(Class<?> mainClass, ComponentType<C> type, Class<?> others) {
+		ComponentsImpl.inject(new RedirectedInjectionPredicate(mainClass, Set.of(others)), type);
+	}
+
+	public static <C extends Component, S> Optional<C> expose(ComponentType<C> id, S obj) {
+		if (obj instanceof ComponentProvider provider) {
+			return provider.getContainer().expose(id.id())
+					.map(id::cast)
+					.map(Optional::orElseThrow); // If the casting fails something is wrong with the provided ComponentType. In that case we just throw.
+		}
+
+		return Optional.empty();
+	}
+
+	public static <C extends Component> ComponentType<C> register(Identifier id, Component.Factory<C> factory) {
+		return ComponentsImpl.register(id, factory);
+	}
+
+	public static <C extends Component> ComponentType<C> registerStatic(Identifier id, Component.Factory<C> factory) {
+		return ComponentsImpl.registerStatic(id, factory);
+	}
+
+	public static <C extends TickingComponent> ComponentType<C> registerTicking(Identifier id, C component) {
+		return ComponentsImpl.registerStatic(id, () -> component);
+	}
+}

library/data/component/src/main/java/org/quiltmc/qsl/component/api/components/FloatComponent.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2022 QuiltMC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.quiltmc.qsl.component.api.components;
+
+import org.quiltmc.qsl.component.api.Component;
+
+
+public interface FloatComponent extends Component {
+	float get();
+
+	void set(float value);
+}