Anvilcraft/DimDoors
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Working reader

Browse source
This commit is contained in:
SD 2021-03-01 12:37:14 +05:30
parent 8dd9ca05fb
commit 78df6743b2
No known key found for this signature in database
GPG key ID: E36B57EE08544BC5
17 changed files with 333 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/datagen/java/org/dimdev/dimdoors/datagen/LootTableProvider.java
View file

@ -25,10 +25,10 @@ public class LootTableProvider implements DataProvider {
}
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.GOLD_DOOR);
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.QUARTZ_DOOR);
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.OAK_DIMENSIONAL_DOOR);
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.IRON_DIMENSIONAL_DOOR);
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.GOLD_DIMENSIONAL_DOOR);
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.QUARTZ_DIMENSIONAL_DOOR);
// LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.OAK_DIMENSIONAL_DOOR);
// LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.IRON_DIMENSIONAL_DOOR);
// LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.GOLD_DIMENSIONAL_DOOR);
// LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.QUARTZ_DIMENSIONAL_DOOR);
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.OAK_DIMENSIONAL_TRAPDOOR);
LOOT_TABLE_CONSUMER.registerBlockDropSelf(ModBlocks.MARKING_PLATE);
}

2
src/main/java/org/dimdev/dimdoors/DimensionalDoorsInitializer.java
View file

@ -5,6 +5,7 @@ import java.nio.file.Path;
import me.sargunvohra.mcmods.autoconfig1u.AutoConfig;
import me.sargunvohra.mcmods.autoconfig1u.ConfigHolder;
import org.dimdev.dimdoors.block.ModBlocks;
import org.dimdev.dimdoors.block.door.condition.Condition;
import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
import org.dimdev.dimdoors.command.ModCommands;
import org.dimdev.dimdoors.entity.ModEntityTypes;
@ -114,6 +115,7 @@ public class DimensionalDoorsInitializer implements ModInitializer {
PocketGenerator.PocketGeneratorType.register();
AbstractPocket.AbstractPocketType.register();
PocketAddon.PocketAddonType.register();
Condition.ConditionType.register();
ResourceManagerHelper.get(ResourceType.SERVER_DATA).registerReloadListener(PocketLoader.getInstance());
ResourceManagerHelper.registerBuiltinResourcePack(new Identifier("dimdoors", "default_pockets"), dimDoorsMod, ResourcePackActivationType.DEFAULT_ENABLED);

14
src/main/java/org/dimdev/dimdoors/block/ModBlocks.java
View file

@ -4,6 +4,10 @@ import java.util.HashMap;
import java.util.Map;
import com.google.common.collect.Maps;
import org.dimdev.dimdoors.block.door.DimensionalDoorBlock;
import org.dimdev.dimdoors.block.door.DimensionalTrapdoorBlock;
import org.dimdev.dimdoors.block.door.DoorData;
import org.dimdev.dimdoors.block.door.DoorDataReader;
import net.minecraft.block.Block;
import net.minecraft.block.Blocks;
@ -95,18 +99,14 @@ public final class ModBlocks {
BLOCKS.forEach((str, block) -> {
Registry.register(Registry.BLOCK, str, block);
});
DoorDataReader.read();
BLOCKS.clear();
}
@Environment(EnvType.CLIENT)
public static void initClient() {
BlockRenderLayerMap.INSTANCE.putBlocks(RenderLayer.getCutout(),
ModBlocks.OAK_DIMENSIONAL_DOOR,
ModBlocks.GOLD_DIMENSIONAL_DOOR,
ModBlocks.IRON_DIMENSIONAL_DOOR,
ModBlocks.OAK_DIMENSIONAL_TRAPDOOR,
ModBlocks.QUARTZ_DIMENSIONAL_DOOR,
ModBlocks.QUARTZ_DOOR);
BlockRenderLayerMap.INSTANCE.putBlocks(RenderLayer.getCutout(), ModBlocks.QUARTZ_DOOR, ModBlocks.GOLD_DOOR);
DoorData.DOORS.forEach(door -> BlockRenderLayerMap.INSTANCE.putBlock(door, RenderLayer.getCutout()));
}
public static Block ancientFabricFromDye(DyeColor color) {

5
src/main/java/org/dimdev/dimdoors/block/DimensionalDoorBlock.java → src/main/java/org/dimdev/dimdoors/block/door/DimensionalDoorBlock.java
View file

@ -1,8 +1,11 @@
package org.dimdev.dimdoors.block;
package org.dimdev.dimdoors.block.door;
import net.minecraft.util.math.Vec3d;
import org.dimdev.dimdoors.DimensionalDoorsInitializer;
import org.dimdev.dimdoors.block.CoordinateTransformerBlock;
import org.dimdev.dimdoors.block.ModBlocks;
import org.dimdev.dimdoors.block.RiftProvider;
import org.dimdev.dimdoors.block.entity.DetachedRiftBlockEntity;
import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
import org.dimdev.dimdoors.util.math.MathUtil;

3
src/main/java/org/dimdev/dimdoors/block/DimensionalTrapdoorBlock.java → src/main/java/org/dimdev/dimdoors/block/door/DimensionalTrapdoorBlock.java
View file

@ -1,5 +1,6 @@
package org.dimdev.dimdoors.block;
package org.dimdev.dimdoors.block.door;
import org.dimdev.dimdoors.block.RiftProvider;
import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
import org.jetbrains.annotations.Nullable;

70
src/main/java/org/dimdev/dimdoors/block/door/UnbakedDoorData.java → src/main/java/org/dimdev/dimdoors/block/door/DoorData.java
View file

@ -1,5 +1,7 @@
package org.dimdev.dimdoors.block.door;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
@ -9,7 +11,6 @@ import java.util.function.Consumer;
import com.google.common.collect.ImmutableMap;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import org.dimdev.dimdoors.block.DimensionalDoorBlock;
import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
import org.dimdev.dimdoors.item.DimensionalDoorItem;
import org.dimdev.dimdoors.item.ItemExtensions;
@ -19,36 +20,50 @@ import org.dimdev.dimdoors.util.OptionalBool;
import net.minecraft.block.Block;
import net.minecraft.item.Item;
import net.minecraft.util.Identifier;
import net.minecraft.util.Pair;
import net.minecraft.util.Rarity;
import net.minecraft.util.Util;
import net.minecraft.util.registry.Registry;
import net.fabricmc.fabric.api.object.builder.v1.block.FabricBlockSettings;
public final class UnbakedDoorData implements AutoCloseable {
public final class DoorData implements AutoCloseable {
public static final List<Block> DOORS = new ArrayList<>();
private String id;
private UnbakedItemSettings itemSettings;
private UnbakedBlockSettings blockSettings;
private RiftDataList riftDataList;
private boolean closed = false;
public static UnbakedDoorData fromJson(JsonObject json) {
public static DoorData fromJson(JsonObject json) {
String id = json.get("id").getAsString();
UnbakedItemSettings itemSettings = UnbakedItemSettings.fromJson(json.getAsJsonObject("itemSettings"));
UnbakedBlockSettings blockSettings = UnbakedBlockSettings.fromJson(json.getAsJsonObject("blockSettings"));
RiftDataList riftDataList = RiftDataList.fromJson(json.getAsJsonArray("riftData"));
return new UnbakedDoorData(id, itemSettings, blockSettings, riftDataList);
return new DoorData(id, itemSettings, blockSettings, riftDataList);
}
public UnbakedDoorData(String id, UnbakedItemSettings itemSettings, UnbakedBlockSettings blockSettings, RiftDataList riftDataList) {
public DoorData(String id, UnbakedItemSettings itemSettings, UnbakedBlockSettings blockSettings, RiftDataList riftDataList) {
this.id = id;
this.itemSettings = itemSettings;
this.blockSettings = blockSettings;
this.riftDataList = riftDataList;
}
public Pair<Item, Block> construct() {
public JsonObject toJson(JsonObject json) {
json.addProperty("id", this.id);
return json;
}
private Consumer<? super EntranceRiftBlockEntity> createSetupFunction() {
return rift -> {
RiftDataList.OptRiftData riftData = this.riftDataList.getRiftData(rift);
riftData.getDestination().ifPresent(rift::setDestination);
riftData.getProperties().ifPresent(rift::setProperties);
};
}
@Override
public void close() {
if (closed) {
throw new UnsupportedOperationException("Already Closed");
}
@ -66,21 +81,13 @@ public final class UnbakedDoorData implements AutoCloseable {
FabricBlockSettings blockSettings = FabricBlockSettings.copyOf(Registry.BLOCK.get(new Identifier(this.blockSettings.parent)));
this.blockSettings.luminance.ifPresent(blockSettings::luminance);
Identifier id = new Identifier(this.id);
Block doorBlock = new DimensionalDoorBlock(blockSettings);
Item doorItem = new DimensionalDoorItem(doorBlock, itemSettings, createSetupFunction());
return new Pair<>(doorItem, doorBlock);
}
Registry.register(Registry.BLOCK, id, doorBlock);
Registry.register(Registry.ITEM, id, doorItem);
DOORS.add(doorBlock);
private Consumer<? super EntranceRiftBlockEntity> createSetupFunction() {
return rift -> {
RiftDataList.OptRiftData riftData = this.riftDataList.getRiftData(rift);
riftData.getDestination().ifPresent(rift::setDestination);
riftData.getProperties().ifPresent(rift::setProperties);
};
}
@Override
public void close() throws Exception {
this.id = null;
this.blockSettings = null;
this.itemSettings = null;
@ -89,7 +96,7 @@ public final class UnbakedDoorData implements AutoCloseable {
}
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
private static final class UnbakedItemSettings {
public static final class UnbakedItemSettings {
private static final Map<String, Rarity> RARITIES = Util.make(ImmutableMap.<String, Rarity>builder(), b -> {
for (Rarity rarity : Rarity.values()) {
b.put(rarity.name().toLowerCase(), rarity);
@ -110,29 +117,44 @@ public final class UnbakedDoorData implements AutoCloseable {
return new UnbakedItemSettings(parent, maxCount, maxDamage, rarity, fireproof);
}
private UnbakedItemSettings(Optional<String> parent, OptionalInt maxCount, OptionalInt maxDamage, Optional<Rarity> rarity, OptionalBool fireproof) {
public UnbakedItemSettings(Optional<String> parent, OptionalInt maxCount, OptionalInt maxDamage, Optional<Rarity> rarity, OptionalBool fireproof) {
this.parent = parent;
this.maxCount = maxCount;
this.maxDamage = maxDamage;
this.rarity = rarity;
this.fireproof = fireproof;
}
public JsonObject toJson(JsonObject json) {
parent.ifPresent(s -> json.addProperty("parent", s));
maxCount.ifPresent(s -> json.addProperty("maxCount", s));
maxDamage.ifPresent(s -> json.addProperty("maxDamage", s));
rarity.ifPresent(s -> json.addProperty("rarity", s.name().toLowerCase()));
fireproof.ifPresent(s -> json.addProperty("fireproof", s));
return json;
}
}
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
private static final class UnbakedBlockSettings {
public static final class UnbakedBlockSettings {
private final String parent;
private final OptionalInt luminance;
public static UnbakedBlockSettings fromJson(JsonObject json) {
String parent = Optional.ofNullable(json.get("parent")).map(JsonElement::getAsString).orElseThrow(() -> new RuntimeException("Missing parent block"));
OptionalInt luminance = Optional.ofNullable(json.get("maxCount")).map(JsonElement::getAsInt).map(OptionalInt::of).orElse(OptionalInt.empty());
OptionalInt luminance = Optional.ofNullable(json.get("luminance")).map(JsonElement::getAsInt).map(OptionalInt::of).orElse(OptionalInt.empty());
return new UnbakedBlockSettings(parent, luminance);
}
private UnbakedBlockSettings(String parent, OptionalInt luminance) {
public UnbakedBlockSettings(String parent, OptionalInt luminance) {
this.parent = parent;
this.luminance = luminance;
}
public JsonObject toJson(JsonObject json) {
json.addProperty("parent", parent);
luminance.ifPresent(s -> json.addProperty("luminance", s));
return json;
}
}
}

141
src/main/java/org/dimdev/dimdoors/block/door/DoorDataReader.java Normal file
View file

@ -0,0 +1,141 @@
package org.dimdev.dimdoors.block.door;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.stream.Collectors;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.dimdev.dimdoors.DimensionalDoorsInitializer;
import org.dimdev.dimdoors.block.door.condition.AlwaysTrueCondition;
import org.dimdev.dimdoors.block.door.condition.InverseCondition;
import org.dimdev.dimdoors.block.door.condition.WorldMatchCondition;
import org.dimdev.dimdoors.rift.registry.LinkProperties;
import org.dimdev.dimdoors.rift.targets.PrivatePocketExitTarget;
import org.dimdev.dimdoors.rift.targets.PrivatePocketTarget;
import org.dimdev.dimdoors.rift.targets.PublicPocketTarget;
import org.dimdev.dimdoors.rift.targets.RandomTarget;
import org.dimdev.dimdoors.util.OptionalBool;
import org.dimdev.dimdoors.world.ModDimensions;
import net.minecraft.util.Pair;
import net.minecraft.util.Rarity;
import net.minecraft.util.Util;
public class DoorDataReader {
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().setLenient().create();
private static final Logger LOGGER = LogManager.getLogger();
private static final DoorData DEFAULT_IRON_DIMENSIONAL_DOOR = new DoorData(
"dimdoors:iron_dimensional_door",
new DoorData.UnbakedItemSettings(
Optional.empty(),
OptionalInt.of(1),
OptionalInt.empty(),
Optional.of(Rarity.UNCOMMON),
OptionalBool.FALSE
),
new DoorData.UnbakedBlockSettings(
"minecraft:iron_door",
OptionalInt.of(10)
), new RiftDataList(Util.make(new LinkedList<>(), list -> list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(new PublicPocketTarget()), Optional.empty()), AlwaysTrueCondition.INSTANCE)))
));
private static final DoorData DEFAULT_GOLD_DIMENSIONAL_DOOR = new DoorData(
"dimdoors:gold_dimensional_door",
new DoorData.UnbakedItemSettings(
Optional.empty(),
OptionalInt.of(1),
OptionalInt.empty(),
Optional.of(Rarity.UNCOMMON),
OptionalBool.FALSE
),
new DoorData.UnbakedBlockSettings(
"dimdoors:gold_door",
OptionalInt.of(10)
), new RiftDataList(Util.make(new LinkedList<>(), list -> list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(RandomTarget.builder().acceptedGroups(Collections.singleton(0)).coordFactor(1).negativeDepthFactor(10000).positiveDepthFactor(80).weightMaximum(100).noLink(false).noLinkBack(false).newRiftWeight(1).build()), Optional.of(LinkProperties.builder().groups(new HashSet<>(Arrays.asList(0, 1))).linksRemaining(1).build())), AlwaysTrueCondition.INSTANCE)))
));
private static final DoorData DEFAULT_OAK_DIMENSIONAL_DOOR = new DoorData(
"dimdoors:oak_dimensional_door",
new DoorData.UnbakedItemSettings(
Optional.empty(),
OptionalInt.of(1),
OptionalInt.empty(),
Optional.of(Rarity.UNCOMMON),
OptionalBool.FALSE
),
new DoorData.UnbakedBlockSettings(
"minecraft:oak_door",
OptionalInt.of(10)
), new RiftDataList(Util.make(new LinkedList<>(), list -> list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(RandomTarget.builder().acceptedGroups(Collections.singleton(0)).coordFactor(1).negativeDepthFactor(80).positiveDepthFactor(Double.MAX_VALUE).weightMaximum(100).noLink(false).newRiftWeight(0).build()), Optional.empty()), AlwaysTrueCondition.INSTANCE)))
));
private static final DoorData DEFAULT_QUARTZ_DIMENSIONAL_DOOR = new DoorData(
"dimdoors:gold_dimensional_door",
new DoorData.UnbakedItemSettings(
Optional.empty(),
OptionalInt.of(1),
OptionalInt.empty(),
Optional.of(Rarity.UNCOMMON),
OptionalBool.FALSE
),
new DoorData.UnbakedBlockSettings(
"dimdoors:quartz_door",
OptionalInt.of(10)
), new RiftDataList(Util.make(new LinkedList<>(), list -> {
WorldMatchCondition condition = new WorldMatchCondition(ModDimensions.PERSONAL);
list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(new PrivatePocketExitTarget()), Optional.empty()), condition));
list.add(new Pair<>(new RiftDataList.OptRiftData(Optional.of(new PrivatePocketTarget()), Optional.empty()), new InverseCondition(condition)));
})
));
public static void read() {
try {
Path doorDir = DimensionalDoorsInitializer.getConfigRoot().resolve("doors");
if (Files.notExists(doorDir)) {
writeDefault(doorDir);
return;
}
if (Files.isDirectory(doorDir)) {
for (Path p : Files.list(doorDir).collect(Collectors.toList())) {
if (!Files.isDirectory(p) && Files.isRegularFile(p)) {
String jsonStr = new String(Files.readAllBytes(p), StandardCharsets.UTF_8);
JsonObject json = GSON.fromJson(jsonStr, JsonObject.class);
try (DoorData ignored = DoorData.fromJson(json)) {
LOGGER.info("Loading door json from {}", p.toAbsolutePath().toString());
}
}
}
} else {
Files.delete(doorDir);
writeDefault(doorDir);
}
} catch (IOException | RuntimeException e) {
LOGGER.error("Error leading door json", e);
e.printStackTrace();
}
}
private static void writeDefault(Path root) throws IOException {
writeDefault(root.resolve("iron_dimensional_door.json"), DEFAULT_IRON_DIMENSIONAL_DOOR);
writeDefault(root.resolve("gold_dimensional_door.json"), DEFAULT_GOLD_DIMENSIONAL_DOOR);
writeDefault(root.resolve("oak_dimensional_door.json"), DEFAULT_OAK_DIMENSIONAL_DOOR);
writeDefault(root.resolve("quartz_dimensional_door.json"), DEFAULT_QUARTZ_DIMENSIONAL_DOOR);
}
private static void writeDefault(Path path, DoorData doorData) throws IOException {
Files.createFile(path);
String json = GSON.toJson(doorData.toJson(new JsonObject()));
Files.write(path, json.getBytes(StandardCharsets.UTF_8));
}
}

26
src/main/java/org/dimdev/dimdoors/block/door/RiftDataList.java
View file

@ -1,7 +1,9 @@
package org.dimdev.dimdoors.block.door;
import java.util.LinkedList;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
@ -24,7 +26,8 @@ public class RiftDataList {
for (JsonElement json : jsonArray) {
JsonObject jsonObject = json.getAsJsonObject();
OptRiftData riftData = OptRiftData.fromJson(jsonObject.getAsJsonObject("data"));
Condition condition = Condition.fromJson(jsonObject.getAsJsonObject("data"));
Condition condition = Condition.fromJson(jsonObject.getAsJsonObject("condition"));
riftDataConditions.add(new Pair<>(riftData, condition));
}
return new RiftDataList(riftDataConditions);
}
@ -37,6 +40,19 @@ public class RiftDataList {
return riftDataConditions.stream().filter(pair -> pair.getRight().matches(rift)).findFirst().orElseThrow(() -> new RuntimeException("Could not find any matching rift data")).getLeft();
}
public JsonArray toJson() {
JsonArray jsonArray = new JsonArray();
for (Map.Entry<OptRiftData, Condition> entry : this.riftDataConditions.stream().collect(Collectors.toMap(Pair::getLeft, Pair::getRight)).entrySet()) {
OptRiftData riftData = entry.getKey();
Condition condition = entry.getValue();
JsonObject jsonInner = new JsonObject();
jsonInner.add("data", riftData.toJson(new JsonObject()));
jsonInner.add("condition", condition.toJson(new JsonObject()));
jsonArray.add(jsonInner);
}
return jsonArray;
}
@SuppressWarnings("OptionalUsedAsFieldOrParameterType")
public static class OptRiftData {
private final Optional<VirtualTarget> destination;
@ -44,7 +60,7 @@ public class RiftDataList {
public static OptRiftData fromJson(JsonObject json) {
Optional<VirtualTarget> destination = Optional.ofNullable(json.get("destination")).map(JsonElement::getAsJsonObject).map(j -> JsonOps.INSTANCE.convertTo(NbtOps.INSTANCE, j)).map(CompoundTag.class::cast).map(VirtualTarget::fromTag);
Optional<LinkProperties> linkProperties = Optional.ofNullable(json.get("destination")).map(JsonElement::getAsJsonObject).map(j -> JsonOps.INSTANCE.convertTo(NbtOps.INSTANCE, j)).map(CompoundTag.class::cast).map(LinkProperties::fromTag);
Optional<LinkProperties> linkProperties = Optional.ofNullable(json.get("properties")).map(JsonElement::getAsJsonObject).map(j -> JsonOps.INSTANCE.convertTo(NbtOps.INSTANCE, j)).map(CompoundTag.class::cast).map(LinkProperties::fromTag);
return new OptRiftData(destination, linkProperties);
}
@ -53,6 +69,12 @@ public class RiftDataList {
this.linkProperties = linkProperties;
}
public JsonObject toJson(JsonObject json) {
this.destination.ifPresent(s -> json.add("destination", NbtOps.INSTANCE.convertTo(JsonOps.INSTANCE, VirtualTarget.toTag(s))));
this.linkProperties.ifPresent(s -> json.add("properties", NbtOps.INSTANCE.convertTo(JsonOps.INSTANCE, LinkProperties.toTag(s))));
return json;
}
public Optional<LinkProperties> getProperties() {
return linkProperties;
}

22
src/main/java/org/dimdev/dimdoors/block/door/condition/AlwaysTrueCondition.java Normal file
View file

@ -0,0 +1,22 @@
package org.dimdev.dimdoors.block.door.condition;
import com.google.gson.JsonObject;
import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
public enum AlwaysTrueCondition implements Condition {
INSTANCE;
@Override
public boolean matches(EntranceRiftBlockEntity rift) {
return true;
}
@Override
public void toJsonInner(JsonObject json) {
}
@Override
public Condition.ConditionType<?> getType() {
return null;
}
}

6
src/main/java/org/dimdev/dimdoors/block/door/condition/Condition.java
View file

@ -35,6 +35,7 @@ public interface Condition {
}
interface ConditionType<T extends Condition> {
ConditionType<AlwaysTrueCondition> ALWAYS_TRUE = register("always_true", j -> AlwaysTrueCondition.INSTANCE);
ConditionType<AllCondition> ALL = register("all", AllCondition::fromJson);
ConditionType<AnyCondition> ANY = register("any", AnyCondition::fromJson);
ConditionType<InverseCondition> INVERSE = register("inverse", InverseCondition::fromJson);
@ -45,7 +46,10 @@ public interface Condition {
JsonObject toJson(T t, JsonObject json);
default String getId() {
return REGISTRY.getId(this).toString();
return String.valueOf(REGISTRY.getId(this));
}
static void register() {
}
static <T extends Condition> ConditionType<T> register(String name, Function<JsonObject, T> fromJson) {

4
src/main/java/org/dimdev/dimdoors/block/entity/ModBlockEntityTypes.java
View file

@ -1,6 +1,8 @@
package org.dimdev.dimdoors.block.entity;
import org.apache.commons.lang3.ArrayUtils;
import org.dimdev.dimdoors.block.ModBlocks;
import org.dimdev.dimdoors.block.door.DoorData;
import org.dimdev.dimdoors.client.DetachedRiftBlockEntityRenderer;
import org.dimdev.dimdoors.client.EntranceRiftBlockEntityRenderer;
@ -23,7 +25,7 @@ public class ModBlockEntityTypes {
public static final BlockEntityType<EntranceRiftBlockEntity> ENTRANCE_RIFT = register(
"dimdoors:entrance_rift",
EntranceRiftBlockEntity::new,
ModBlocks.OAK_DIMENSIONAL_DOOR, ModBlocks.IRON_DIMENSIONAL_DOOR, ModBlocks.GOLD_DIMENSIONAL_DOOR, ModBlocks.QUARTZ_DIMENSIONAL_DOOR, ModBlocks.DIMENSIONAL_PORTAL);
ArrayUtils.add(DoorData.DOORS.toArray(new Block[0]), ModBlocks.DIMENSIONAL_PORTAL));
private static <E extends BlockEntity> BlockEntityType<E> register(String id, FabricBlockEntityTypeBuilder.Factory<E> factory, Block... blocks) {
return Registry.register(Registry.BLOCK_ENTITY_TYPE, id, FabricBlockEntityTypeBuilder.create(factory, blocks).build());

2
src/main/java/org/dimdev/dimdoors/client/wthit/WthitPlugin.java
View file

@ -3,7 +3,7 @@ package org.dimdev.dimdoors.client.wthit;
import mcp.mobius.waila.api.IRegistrar;
import mcp.mobius.waila.api.IWailaPlugin;
import mcp.mobius.waila.api.TooltipPosition;
import org.dimdev.dimdoors.block.DimensionalDoorBlock;
import org.dimdev.dimdoors.block.door.DimensionalDoorBlock;
public class WthitPlugin implements IWailaPlugin {
@Override

118
src/main/java/org/dimdev/dimdoors/item/ModItems.java
View file

@ -47,53 +47,53 @@ public final class ModItems {
@RegistryObject("quartz_door")
public static final Item QUARTZ_DOOR = create(ModBlocks.QUARTZ_DOOR);
@RegistryObject("quartz_dimensional_door")
public static final Item QUARTZ_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
ModBlocks.QUARTZ_DIMENSIONAL_DOOR,
new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
rift -> {
if (ModDimensions.isPrivatePocketDimension(rift.getWorld())) {
rift.setDestination(new PrivatePocketExitTarget()); // exit
} else {
rift.setDestination(new PrivatePocketTarget()); // entrances
}
}
));
// @RegistryObject("quartz_dimensional_door")
// public static final Item QUARTZ_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
// ModBlocks.QUARTZ_DIMENSIONAL_DOOR,
// new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
// rift -> {
// if (ModDimensions.isPrivatePocketDimension(rift.getWorld())) {
// rift.setDestination(new PrivatePocketExitTarget()); // exit
// } else {
// rift.setDestination(new PrivatePocketTarget()); // entrances
// }
// }
// ));
@RegistryObject("gold_door")
public static final Item GOLD_DOOR = create(ModBlocks.GOLD_DOOR);
@RegistryObject("gold_dimensional_door")
public static final Item GOLD_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
ModBlocks.GOLD_DIMENSIONAL_DOOR,
new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
rift -> {
rift.setProperties(LinkProperties.builder()
.groups(new HashSet<>(Arrays.asList(0, 1)))
.linksRemaining(1).build());
rift.setDestination(RandomTarget.builder()
.acceptedGroups(Collections.singleton(0))
.coordFactor(1)
.negativeDepthFactor(10000)
.positiveDepthFactor(80)
.weightMaximum(100)
.noLink(false)
.noLinkBack(false)
.newRiftWeight(1).build());
}
));
@RegistryObject("iron_dimensional_door")
public static final Item IRON_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
ModBlocks.IRON_DIMENSIONAL_DOOR,
new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
rift -> {
PublicPocketTarget destination = new PublicPocketTarget();
rift.setDestination(destination);
}
));
/*
// @RegistryObject("gold_dimensional_door")
// public static final Item GOLD_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
// ModBlocks.GOLD_DIMENSIONAL_DOOR,
// new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
// rift -> {
// rift.setProperties(LinkProperties.builder()
// .groups(new HashSet<>(Arrays.asList(0, 1)))
// .linksRemaining(1).build());
//
// rift.setDestination(RandomTarget.builder()
// .acceptedGroups(Collections.singleton(0))
// .coordFactor(1)
// .negativeDepthFactor(10000)
// .positiveDepthFactor(80)
// .weightMaximum(100)
// .noLink(false)
// .noLinkBack(false)
// .newRiftWeight(1).build());
// }
// ));
//
// @RegistryObject("iron_dimensional_door")
// public static final Item IRON_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
// ModBlocks.IRON_DIMENSIONAL_DOOR,
// new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
// rift -> {
// PublicPocketTarget destination = new PublicPocketTarget();
// rift.setDestination(destination);
// }
// ));
/* TODO
@RegistryObject("unstable_dimensional_door")
public static final Item UNSTABLE_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
ModBlocks.IRON_DIMENSIONAL_DOOR,
@ -109,22 +109,22 @@ public final class ModItems {
.newRiftWeight(0.5F).build())
));
*/
@RegistryObject("oak_dimensional_door")
public static final Item OAK_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
ModBlocks.OAK_DIMENSIONAL_DOOR,
new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
rift -> rift.setDestination(
RandomTarget.builder()
.acceptedGroups(Collections.singleton(0))
.coordFactor(1)
.negativeDepthFactor(80)
.positiveDepthFactor(Double.MAX_VALUE)
.weightMaximum(100)
.noLink(false)
.newRiftWeight(0)
.build()
)
));
// @RegistryObject("oak_dimensional_door")
// public static final Item OAK_DIMENSIONAL_DOOR = create(new DimensionalDoorItem(
// ModBlocks.OAK_DIMENSIONAL_DOOR,
// new Item.Settings().group(DIMENSIONAL_DOORS).maxCount(1),
// rift -> rift.setDestination(
// RandomTarget.builder()
// .acceptedGroups(Collections.singleton(0))
// .coordFactor(1)
// .negativeDepthFactor(80)
// .positiveDepthFactor(Double.MAX_VALUE)
// .weightMaximum(100)
// .noLink(false)
// .newRiftWeight(0)
// .build()
// )
// ));
@RegistryObject("wood_dimensional_trapdoor")
public static final Item OAK_DIMENSIONAL_TRAPDOOR = create(new DimensionalTrapdoorItem(

8
src/main/java/org/dimdev/dimdoors/pockets/modifier/DimensionalDoorModifier.java
View file

@ -19,7 +19,7 @@ import net.minecraft.util.registry.Registry;
import com.google.common.base.MoreObjects;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.dimdev.dimdoors.block.DimensionalDoorBlock;
import org.dimdev.dimdoors.block.door.DimensionalDoorBlock;
import org.dimdev.dimdoors.block.ModBlocks;
import org.dimdev.dimdoors.block.entity.EntranceRiftBlockEntity;
import org.dimdev.dimdoors.block.entity.ModBlockEntityTypes;
@ -56,15 +56,13 @@ public class DimensionalDoorModifier implements LazyCompatibleModifier {
String facingString = tag.getString("facing");
facing = Direction.byName(tag.getString("facing"));
if (facing == null || facing.getAxis().isVertical()) {
LOGGER.error("Could not interpret facing direction \"" + facingString + "\"");
facing = Direction.NORTH;
throw new RuntimeException("Could not interpret facing direction \"" + facingString + "\"");
}
doorTypeString = tag.getString("door_type");
Block doorBlock = Registry.BLOCK.get(Identifier.tryParse(doorTypeString));
if (!(doorBlock instanceof DimensionalDoorBlock)) {
LOGGER.error("Could not interpret door type \"" + doorTypeString + "\"");
doorBlock = ModBlocks.IRON_DIMENSIONAL_DOOR;
throw new RuntimeException("Could not interpret door type \"" + doorTypeString + "\"");
}
doorType = (DimensionalDoorBlock) doorBlock;

4
src/main/java/org/dimdev/dimdoors/pockets/modifier/Modifier.java
View file

@ -56,11 +56,11 @@ public interface Modifier {
static void register() {
}
static <U extends Modifier> ModifierType<U> register(Identifier id, Supplier<U> constructor) {
static <U extends Modifier> ModifierType<U> register(Identifier id, Supplier<U> factory) {
return Registry.register(REGISTRY, id, new ModifierType<U>() {
@Override
public Modifier fromTag(CompoundTag tag) {
return constructor.get().fromTag(tag);
return factory.get().fromTag(tag);
}
@Override

4
src/main/java/org/dimdev/dimdoors/util/OptionalBool.java
View file

@ -10,6 +10,8 @@ import it.unimi.dsi.fastutil.booleans.BooleanConsumer;
public final class OptionalBool {
private static final OptionalBool EMPTY = new OptionalBool();
public static final OptionalBool TRUE = new OptionalBool(true);
public static final OptionalBool FALSE = new OptionalBool(false);
private final boolean present;
private final boolean value;
@ -28,7 +30,7 @@ public final class OptionalBool {
}
public static OptionalBool of(boolean value) {
return new OptionalBool(value);
return value ? TRUE : FALSE;
}
public boolean getAsBool() {

22
src/main/java/org/dimdev/dimdoors/world/limbo/LimboDecay.java
View file

@ -17,9 +17,11 @@ import com.google.gson.JsonObject;
import com.mojang.serialization.Codec;
import com.mojang.serialization.JsonOps;
import com.mojang.serialization.codecs.UnboundedMapCodec;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.dimdev.dimdoors.DimensionalDoorsInitializer;
import org.dimdev.dimdoors.block.door.DoorData;
import net.minecraft.block.Block;
import net.minecraft.block.BlockState;
@ -84,12 +86,8 @@ import static net.minecraft.block.Blocks.SPRUCE_WOOD;
import static net.minecraft.block.Blocks.STONE;
import static net.minecraft.block.Blocks.STONE_BRICKS;
import static org.dimdev.dimdoors.block.ModBlocks.DETACHED_RIFT;
import static org.dimdev.dimdoors.block.ModBlocks.DIMENSIONAL_PORTAL;
import static org.dimdev.dimdoors.block.ModBlocks.ETERNAL_FLUID;
import static org.dimdev.dimdoors.block.ModBlocks.GOLD_DIMENSIONAL_DOOR;
import static org.dimdev.dimdoors.block.ModBlocks.GOLD_DOOR;
import static org.dimdev.dimdoors.block.ModBlocks.IRON_DIMENSIONAL_DOOR;
import static org.dimdev.dimdoors.block.ModBlocks.OAK_DIMENSIONAL_DOOR;
import static org.dimdev.dimdoors.block.ModBlocks.QUARTZ_DOOR;
import static org.dimdev.dimdoors.block.ModBlocks.UNRAVELLED_FABRIC;
@ -134,7 +132,7 @@ public final class LimboDecay {
}
}
private static final Random random = new Random();
private static final Random RANDOM = new Random();
private static Block[] blocksImmuneToDecay = null;
public static Map<Block, Block> getDecaySequence() {
@ -143,17 +141,7 @@ public final class LimboDecay {
public static Block[] getBlocksImmuneToDecay() {
if (blocksImmuneToDecay == null) {
blocksImmuneToDecay = new Block[]{
UNRAVELLED_FABRIC,
ETERNAL_FLUID,
DIMENSIONAL_PORTAL,
IRON_DIMENSIONAL_DOOR,
OAK_DIMENSIONAL_DOOR,
DETACHED_RIFT,
GOLD_DOOR,
QUARTZ_DOOR,
GOLD_DIMENSIONAL_DOOR
};
blocksImmuneToDecay = ArrayUtils.addAll(DoorData.DOORS.toArray(new Block[0]), UNRAVELLED_FABRIC, ETERNAL_FLUID, DETACHED_RIFT, GOLD_DOOR, QUARTZ_DOOR);
}
return blocksImmuneToDecay;
@ -166,7 +154,7 @@ public final class LimboDecay {
public static void applySpreadDecay(World world, BlockPos pos) {
//Check if we randomly apply decay spread or not. This can be used to moderate the frequency of
//full spread decay checks, which can also shift its performance impact on the game.
if (random.nextDouble() < DimensionalDoorsInitializer.getConfig().getLimboConfig().decaySpreadChance) {
if (RANDOM.nextDouble() < DimensionalDoorsInitializer.getConfig().getLimboConfig().decaySpreadChance) {
//Apply decay to the blocks above, below, and on all four sides.
//World.getBlockId() implements bounds checking, so we don't have to worry about reaching out of the world
boolean flag = decayBlock(world, pos.up());