changed/removed terra originum shti

src/main/java/com/smithy/faithful/Faithful.java

@@ -0,0 +1,23 @@
+package com.smithy.faithful;
+
+import net.fabricmc.api.ModInitializer;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import com.smithy.faithful.items.*;
+import com.smithy.faithful.registry.ModPowers;
+
+public class Faithful implements ModInitializer {
+	public static final String MOD_ID = "faithful";
+
+	public static final Logger LOGGER = LogManager.getLogger(MOD_ID);
+
+	@Override
+	public void onInitialize() {
+		IconItems.register();
+		ModPowers.register();
+		
+		LOGGER.info("man this Origins is " + MOD_ID);
+	}
+}

src/main/java/com/smithy/faithful/client/FaithfulOriginsClient.java

@@ -0,0 +1,13 @@
+package com.smithy.faithful.client;
+
+import net.fabricmc.api.ClientModInitializer;
+
+public class FaithfulOriginsClient implements ClientModInitializer {
+
+
+    @Override
+    public void onInitializeClient() {
+
+
+    }
+}

src/main/java/com/smithy/faithful/client/TerraKeybinds.java

@@ -0,0 +1,25 @@
+package com.smithy.faithful.client;
+
+import io.github.apace100.apoli.ApoliClient;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
+import net.minecraft.client.option.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.List;
+
+public class TerraKeybinds implements ClientModInitializer {
+
+	public List<String> keys = List.of("ternary","quaternary","quinary","senary","septenary","octonary","nonary","denary");
+
+	@Override
+	public void onInitializeClient() {
+		for(String key : keys) {
+			KeyBinding binding = new KeyBinding("key.origins."+key+"_active", InputUtil.Type.KEYSYM, GLFW.GLFW_KEY_UNKNOWN, "category.origins");
+			ApoliClient.registerPowerKeybinding(binding.getTranslationKey(), binding);
+			ApoliClient.registerPowerKeybinding(key, binding);
+			KeyBindingHelper.registerKeyBinding(binding);
+		}
+	}
+}

src/main/java/com/smithy/faithful/items/IconItems.java

@@ -0,0 +1,23 @@
+package com.smithy.faithful.items;
+
+import com.smithy.faithful.Faithful;
+
+import net.minecraft.item.Item;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.Rarity;
+import net.minecraft.registry.Registries;
+import net.minecraft.registry.Registry;
+
+public class IconItems {
+
+    public static final Item MYNC_EYE = new Item(new Item.Settings().maxCount(1).rarity(Rarity.EPIC));
+    public static final Item SPIRIT = new Item(new Item.Settings().maxCount(1).rarity(Rarity.EPIC));
+    public static final Item TINY = new Item(new Item.Settings().maxCount(1).rarity(Rarity.EPIC));
+
+    public static void register() {
+        Registry.register(Registries.ITEM, new Identifier(Faithful.MOD_ID, "mync_eye"), MYNC_EYE);
+        Registry.register(Registries.ITEM, new Identifier(Faithful.MOD_ID, "spirit"), SPIRIT);
+        Registry.register(Registries.ITEM, new Identifier(Faithful.MOD_ID, "tiny"), TINY);
+    }
+    
+}

src/main/java/com/smithy/faithful/mixin/EntityMixin.java

@@ -0,0 +1,27 @@
+package com.smithy.faithful.mixin;
+
+import io.github.apace100.apoli.component.PowerHolderComponent;
+import net.minecraft.block.BlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.Vec3d;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import com.smithy.faithful.power.PreventBlockSlowness;
+
+@Mixin(Entity.class)
+public abstract class EntityMixin {
+
+	@Inject(method = "slowMovement", at = @At("HEAD"), cancellable = true)
+	private void terraoriginum$preventBlockSlowness(BlockState state, Vec3d multiplier, CallbackInfo ci) {
+		for (PreventBlockSlowness power : PowerHolderComponent.getPowers((Entity) (Object) this, PreventBlockSlowness.class)) {
+			if (power.isActive()) {
+				ci.cancel();
+				return;
+			}
+		}
+	}
+
+}

src/main/java/com/smithy/faithful/mixin/IcarusHelperMixin.java

@@ -0,0 +1,48 @@
+package com.smithy.faithful.mixin;
+
+import com.llamalad7.mixinextras.injector.ModifyReturnValue;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.smithy.faithful.power.WingsPower;
+
+import dev.cammiescorner.icarus.api.IcarusPlayerValues;
+import dev.cammiescorner.icarus.util.IcarusHelper;
+import io.github.apace100.apoli.component.PowerHolderComponent;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+@Mixin(value = IcarusHelper.class, remap = false)
+public class IcarusHelperMixin {
+
+    @ModifyReturnValue(method = "getConfigValues", at = @At("RETURN"))
+    private static IcarusPlayerValues injectPowerConfigValues(IcarusPlayerValues original, LivingEntity entity) {
+        var list = PowerHolderComponent.getPowers(entity, WingsPower.class);
+        if(!list.isEmpty()) {
+            var power = list.get(0);
+            power.updateFallback(original);
+            return power;
+        }
+
+        return original;
+    }
+
+    @WrapOperation(method = "hasWings", at = @At(value = "INVOKE", target = "Ljava/util/function/Predicate;test(Ljava/lang/Object;)Z"))
+    private static boolean originHasWings(Predicate<LivingEntity> instance, Object entity, Operation<Boolean> original) {
+        return PowerHolderComponent.hasPower((LivingEntity) entity, WingsPower.class) || original.call(instance, entity);
+    }
+
+    @WrapOperation(method = "getEquippedWings", at = @At(value = "INVOKE", target = "Ljava/util/function/Function;apply(Ljava/lang/Object;)Ljava/lang/Object;"))
+    private static Object originGetWings(Function<LivingEntity, ItemStack> instance, Object entity, Operation<ItemStack> original) {
+        if (PowerHolderComponent.hasPower((LivingEntity) entity, WingsPower.class)) {
+            // null is special case
+            return null;
+        }
+
+        return original.call(instance, entity);
+    }
+}

src/main/java/com/smithy/faithful/mixin/PowderSnowBlockMixin.java

@@ -0,0 +1,24 @@
+package com.smithy.faithful.mixin;
+
+import io.github.apace100.apoli.component.PowerHolderComponent;
+import net.minecraft.block.PowderSnowBlock;
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import com.smithy.faithful.power.CanStandOnPowderSnow;
+
+@Mixin(PowderSnowBlock.class)
+public class PowderSnowBlockMixin {
+	@Inject(method = "canWalkOnPowderSnow", at = @At("HEAD"), cancellable = true)
+	private static void terraoriginum$canStandOnPowderSnow(Entity entity, CallbackInfoReturnable<Boolean> cir) {
+		for (CanStandOnPowderSnow canStandOnPowderSnowPower : PowerHolderComponent.getPowers(entity, CanStandOnPowderSnow.class)) {
+			if (canStandOnPowderSnowPower.isActive()) {
+				cir.setReturnValue(true);
+				return;
+			}
+		}
+	}
+}

src/main/java/com/smithy/faithful/mixin/client/IcarusClientMixin.java

@@ -0,0 +1,27 @@
+package com.smithy.faithful.mixin.client;
+
+import com.llamalad7.mixinextras.injector.ModifyReturnValue;
+import com.smithy.faithful.power.WingsPower;
+
+import dev.cammiescorner.icarus.client.IcarusClient;
+import io.github.apace100.apoli.component.PowerHolderComponent;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(value = IcarusClient.class, remap = false)
+public class IcarusClientMixin {
+
+    @ModifyReturnValue(method = "getWingsForRendering", at = @At(value = "RETURN"))
+    private static ItemStack injectOriginWings(ItemStack original, LivingEntity entity) {
+        if(original.isEmpty()) {
+            var list = PowerHolderComponent.getPowers(entity, WingsPower.class);
+            if (!list.isEmpty()) {
+                return list.get(0).getWingsType();
+            }
+        }
+
+        return original;
+    }
+}

src/main/java/com/smithy/faithful/power/CanStandOnPowderSnow.java

@@ -0,0 +1,11 @@
+package com.smithy.faithful.power;
+
+import io.github.apace100.apoli.power.Power;
+import io.github.apace100.apoli.power.PowerType;
+import net.minecraft.entity.LivingEntity;
+
+public class CanStandOnPowderSnow extends Power {
+    public CanStandOnPowderSnow(PowerType<?> type, LivingEntity entity) {
+		super(type, entity);
+	}
+}

src/main/java/com/smithy/faithful/power/PreventBlockSlowness.java

@@ -0,0 +1,11 @@
+package com.smithy.faithful.power;
+
+import io.github.apace100.apoli.power.Power;
+import io.github.apace100.apoli.power.PowerType;
+import net.minecraft.entity.LivingEntity;
+
+public class PreventBlockSlowness extends Power {
+	public PreventBlockSlowness(PowerType<?> type, LivingEntity entity) {
+		super(type, entity);
+	}
+}

src/main/java/com/smithy/faithful/power/WingsPower.java

@@ -0,0 +1,113 @@
+package com.smithy.faithful.power;
+
+import dev.cammiescorner.icarus.api.IcarusPlayerValues;
+import dev.cammiescorner.icarus.util.ServerPlayerFallbackValues;
+import io.github.apace100.apoli.power.Power;
+import io.github.apace100.apoli.power.PowerType;
+import io.github.apace100.apoli.power.factory.PowerFactory;
+import io.github.apace100.calio.data.SerializableData;
+import net.minecraft.util.Identifier;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+
+import com.smithy.faithful.Faithful;
+import com.smithy.faithful.util.CustomDataTypes;
+import com.smithy.faithful.util.OptionalBool;
+
+public class WingsPower extends Power implements IcarusPlayerValues {
+
+    public static final Identifier POWER_TYPE_ID = new Identifier(Faithful.MOD_ID, "wings");
+
+    private final ItemStack wingsType;
+    private final OptionalBool armorSlows;
+    private final OptionalDouble maxSlowedMultiplier;
+    private final OptionalDouble wingsSpeed;
+    private final OptionalDouble exhaustionAmount;
+    private final OptionalInt maxHeightAboveWorld;
+
+    private IcarusPlayerValues fallback = new ServerPlayerFallbackValues();
+
+    public WingsPower(PowerType<?> type, LivingEntity entity, ItemStack wingsType, OptionalBool armorSlows, OptionalDouble maxSlowedMultiplier, OptionalDouble wingsSpeed, OptionalDouble exhaustionAmount, OptionalInt maxHeightAboveWorld) {
+        super(type, entity);
+        this.wingsType = wingsType;
+        this.armorSlows = armorSlows;
+        this.maxSlowedMultiplier = maxSlowedMultiplier;
+        this.wingsSpeed = wingsSpeed;
+        this.exhaustionAmount = exhaustionAmount;
+        this.maxHeightAboveWorld = maxHeightAboveWorld;
+    }
+
+    public ItemStack getWingsType() {
+        return wingsType;
+    }
+
+    public void updateFallback(IcarusPlayerValues fallback) {
+        this.fallback = fallback;
+    }
+
+    @Override
+    public float wingsSpeed() {
+        return (float) wingsSpeed.orElseGet(fallback::wingsSpeed);
+    }
+
+    @Override
+    public float maxSlowedMultiplier() {
+        return (float) maxSlowedMultiplier.orElseGet(fallback::maxSlowedMultiplier);
+    }
+
+    @Override
+    public boolean armorSlows() {
+        return armorSlows.orElseGet(fallback::armorSlows);
+    }
+
+    @Override
+    public boolean canLoopDeLoop() {
+        return fallback.canLoopDeLoop();
+    }
+
+    @Override
+    public boolean canSlowFall() {
+        return fallback.canSlowFall();
+    }
+
+    @Override
+    public float exhaustionAmount() {
+        return (float) exhaustionAmount.orElseGet(fallback::exhaustionAmount);
+    }
+
+    @Override
+    public int maxHeightAboveWorld() {
+        return maxHeightAboveWorld.orElseGet(fallback::maxHeightAboveWorld);
+    }
+
+    @Override
+    public boolean maxHeightEnabled() {
+        return maxHeightAboveWorld.isPresent() || fallback.maxHeightEnabled();
+    }
+
+    public static PowerFactory<WingsPower> createFactory() {
+        return new PowerFactory<>(POWER_TYPE_ID,
+                new SerializableData()
+                        .add("wings_type", CustomDataTypes.STACK_OR_ITEM_NAME)
+                        .add("armor_slows", CustomDataTypes.OPTIONAL_BOOL, OptionalBool.DEFAULT)
+                        .add("max_slowed_multiplier", CustomDataTypes.OPTIONAL_DOUBLE, OptionalDouble.empty())
+                        .add("wings_speed", CustomDataTypes.OPTIONAL_DOUBLE, OptionalDouble.empty())
+                        .add("exhaustion_amount", CustomDataTypes.OPTIONAL_DOUBLE, OptionalDouble.empty())
+                        .add("max_height_above_world", CustomDataTypes.OPTIONAL_INT, OptionalInt.empty()),
+                data -> (type, owner) -> {
+                    ItemStack wingsType = data.get("wings_type");
+                    OptionalBool armorSlows = data.get("armor_slows");
+                    OptionalDouble maxSlowedMultiplier = data.get("max_slowed_multiplier");
+                    OptionalDouble wingsSpeed = data.get("wings_speed");
+                    OptionalDouble exhaustionAmount = data.get("exhaustion_amount");
+                    OptionalInt maxHeightAboveWorld = data.get("max_height_above_world");
+
+                    return new WingsPower(type, owner, wingsType, armorSlows, maxSlowedMultiplier, wingsSpeed, exhaustionAmount, maxHeightAboveWorld);
+                }
+        );
+    }
+    
+}

src/main/java/com/smithy/faithful/registry/ModPowers.java

@@ -0,0 +1,27 @@
+package com.smithy.faithful.registry;
+
+import com.smithy.faithful.Faithful;
+import com.smithy.faithful.power.CanStandOnPowderSnow;
+import com.smithy.faithful.power.PreventBlockSlowness;
+import com.smithy.faithful.power.WingsPower;
+
+import io.github.apace100.apoli.power.factory.PowerFactory;
+import io.github.apace100.apoli.registry.ApoliRegistries;
+import io.github.apace100.calio.data.SerializableData;
+import net.minecraft.registry.Registry;
+import net.minecraft.util.Identifier;
+
+public class ModPowers {
+
+    public static final PowerFactory<?> CAN_WALK_ON_POWDER_SNOW = new PowerFactory<>( new Identifier(Faithful.MOD_ID, "can_walk_on_powder_snow"), new SerializableData(), data -> (type, entity) -> new CanStandOnPowderSnow(type, entity)).allowCondition();
+    public static final PowerFactory<?> PREVENT_BLOCK_SLOWNESS = new PowerFactory<>(new Identifier(Faithful.MOD_ID, "prevent_block_slowness"), new SerializableData(), data -> (type, entity) -> new PreventBlockSlowness(type, entity)).allowCondition();
+    public static final PowerFactory<?> WINGS_POWER = WingsPower.createFactory().allowCondition();
+
+
+    public static void register() {
+        Registry.register(ApoliRegistries.POWER_FACTORY, CAN_WALK_ON_POWDER_SNOW.getSerializerId(), CAN_WALK_ON_POWDER_SNOW);
+        Registry.register(ApoliRegistries.POWER_FACTORY, PREVENT_BLOCK_SLOWNESS.getSerializerId(), PREVENT_BLOCK_SLOWNESS);
+        Registry.register(ApoliRegistries.POWER_FACTORY, WingsPower.POWER_TYPE_ID, WINGS_POWER);
+
+    }
+}

src/main/java/com/smithy/faithful/util/CodecHelper.java

@@ -0,0 +1,13 @@
+package com.smithy.faithful.util;
+
+import com.mojang.datafixers.util.Either;
+import com.mojang.serialization.Codec;
+import net.minecraft.registry.Registries;
+import net.minecraft.item.ItemStack;
+
+import java.util.function.UnaryOperator;
+
+public class CodecHelper {
+
+    public static final Codec<ItemStack> STACK_OR_ITEM_NAME = Codec.either(ItemStack.CODEC, Registries.ITEM.getCodec()).xmap(either -> either.map(UnaryOperator.identity(), ItemStack::new), Either::left);
+}

src/main/java/com/smithy/faithful/util/CustomDataTypes.java

@@ -0,0 +1,78 @@
+package com.smithy.faithful.util;
+import com.google.gson.JsonParseException;
+import com.mojang.serialization.JsonOps;
+import io.github.apace100.calio.data.SerializableDataType;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketByteBuf;
+
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+
+public class CustomDataTypes {
+
+    public static final SerializableDataType<ItemStack> STACK_OR_ITEM_NAME = new SerializableDataType<>(
+        ItemStack.class, 
+        PacketByteBuf::writeItemStack, 
+        PacketByteBuf::readItemStack, 
+        jsonElement -> CodecHelper.STACK_OR_ITEM_NAME.decode(JsonOps.INSTANCE, jsonElement).result().orElseThrow(() -> new JsonParseException("Could not parse ItemStack from JSON.")).getFirst()
+    );
+    
+    /*new SerializableDataType<>(ItemStack.class,
+            PacketByteBuf::writeItem,
+            PacketByteBuf::readItem,
+            jsonElement -> CodecHelper.STACK_OR_ITEM_NAME.decode(JsonOps.INSTANCE, jsonElement).result().orElseThrow(() -> new JsonParseException("Could not parse ItemStack from JSON.")).getFirst()
+    );*/
+
+    public static final SerializableDataType<OptionalBool> OPTIONAL_BOOL = new SerializableDataType<>(OptionalBool.class,
+            PacketByteBuf::writeEnumConstant,
+            buf -> buf.readEnumConstant(OptionalBool.class),
+            jsonElement -> {
+                if (jsonElement.isJsonPrimitive() && jsonElement.getAsJsonPrimitive().isBoolean()) {
+                    return OptionalBool.of(jsonElement.getAsBoolean());
+                }
+                return OptionalBool.DEFAULT;
+            }
+    );
+
+    public static final SerializableDataType<OptionalDouble> OPTIONAL_DOUBLE = new SerializableDataType<>(OptionalDouble.class,
+            (buf, optionalDouble) -> {
+                buf.writeBoolean(optionalDouble.isPresent());
+                if (optionalDouble.isPresent()) {
+                    buf.writeDouble(optionalDouble.getAsDouble());
+                }
+            },
+            buf -> {
+                if (buf.readBoolean()) {
+                    return OptionalDouble.of(buf.readDouble());
+                }
+                return OptionalDouble.empty();
+            },
+            jsonElement -> {
+                if (jsonElement.isJsonPrimitive() && jsonElement.getAsJsonPrimitive().isNumber()) {
+                    return OptionalDouble.of(jsonElement.getAsDouble());
+                }
+                return OptionalDouble.empty();
+            }
+    );
+
+    public static final SerializableDataType<OptionalInt> OPTIONAL_INT = new SerializableDataType<>(OptionalInt.class,
+            (buf, optionalInt) -> {
+                buf.writeBoolean(optionalInt.isPresent());
+                if (optionalInt.isPresent()) {
+                    buf.writeInt(optionalInt.getAsInt());
+                }
+            },
+            buf -> {
+                if (buf.readBoolean()) {
+                    return OptionalInt.of(buf.readInt());
+                }
+                return OptionalInt.empty();
+            },
+            jsonElement -> {
+                if (jsonElement.isJsonPrimitive() && jsonElement.getAsJsonPrimitive().isNumber()) {
+                    return OptionalInt.of(jsonElement.getAsInt());
+                }
+                return OptionalInt.empty();
+            }
+    );
+}

src/main/java/com/smithy/faithful/util/OptionalBool.java

@@ -0,0 +1,38 @@
+package com.smithy.faithful.util;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.MapCodec;
+
+import java.util.Optional;
+import java.util.function.BooleanSupplier;
+
+public enum OptionalBool {
+
+    TRUE,
+    FALSE,
+    DEFAULT;
+
+    public static OptionalBool of(Boolean value) {
+        return value == null ? DEFAULT : value ? TRUE : FALSE;
+    }
+
+    public boolean isTrue() {
+        return this == TRUE;
+    }
+
+    public boolean orElse(boolean defaultValue) {
+        return this == TRUE || (this == DEFAULT && defaultValue);
+    }
+
+    public boolean orElseGet(BooleanSupplier defaultValue) {
+        return this == TRUE || (this == DEFAULT && defaultValue.getAsBoolean());
+    }
+
+    public Optional<Boolean> asOptional() {
+        return this == DEFAULT ? Optional.empty() : Optional.of(isTrue());
+    }
+
+    public static MapCodec<OptionalBool> codecFieldOf(String fieldName) {
+        return Codec.BOOL.optionalFieldOf(fieldName).xmap(opt -> opt.map(aBoolean -> aBoolean ? TRUE : FALSE).orElse(DEFAULT), OptionalBool::asOptional);
+    }
+}

src/main/java/com/smithy/faithful/util/TerraHelper.java

@@ -0,0 +1,10 @@
+package com.smithy.faithful.util;
+
+import net.minecraft.entity.Entity;
+
+public class TerraHelper {
+
+    public static boolean isWet(Entity entity) {
+        return entity.isWet();
+    }
+}