com.mojang.serialization.Dynamic Java Examples

protected <A, B> TypeRewriteRule writeFixAndRead(final String name, final Type<A> type, final Type<B> newType, final Function<Dynamic<?>, Dynamic<?>> fix) {
    return fixTypeEverywhere(name, type, newType, ops -> input -> {
        final Optional<? extends Dynamic<?>> written = type.writeDynamic(ops, input).resultOrPartial(LOGGER::error);
        if (!written.isPresent()) {
            throw new RuntimeException("Could not write the object in " + name);
        }
        final Optional<? extends Pair<Typed<B>, ?>> read = newType.readTyped(fix.apply(written.get())).resultOrPartial(LOGGER::error);
        if (!read.isPresent()) {
            throw new RuntimeException("Could not read the new object in " + name);
        }
        return read.get().getFirst().getValue();
    });
}
 

public static String reverseLookupStateBlock(int stateId) {
    if (stateId < 0 || stateId >= IDS_TO_OLD_STATES.length)
        return "minecraft:air";
    Dynamic<?> val = IDS_TO_OLD_STATES[stateId];
    if (val == null)
        return "minecraft:air";
    return val.get("Name").asString("");
}
 

@Inject(method = "putStates", at = @At("RETURN"))
private static void onPutStates(int id, String newState, String[] oldStates, CallbackInfo ci) {
    Dynamic<?> oldState = BlockStateFlattening.parseState(oldStates.length == 0 ? newState : oldStates[0]);
    BlockStateReverseFlattening.IDS_TO_OLD_STATES[id] = oldState;
    for (String old : oldStates) {
        handleOldState(old);
    }
}
 

@Unique
private static void handleOldState(String old) {
    Dynamic<?> oldState = BlockStateFlattening.parseState(old);
    Identifier id = new Identifier(oldState.get("Name").asString(""));
    Map<String, String> properties = oldState.get("Properties").asMap(k -> k.asString(""), v -> v.asString(""));
    BlockStateReverseFlattening.OLD_PROPERTIES.computeIfAbsent(id, k -> properties.keySet().stream().sorted().collect(Collectors.toList()));
    properties.forEach((name, value) -> {
        List<String> values = BlockStateReverseFlattening.OLD_PROPERTY_VALUES.computeIfAbsent(Pair.of(id, name), k -> new ArrayList<>());
        if (!values.contains(value))
            values.add(value);
    });
}
 

public static Dynamic<?> reverseLookupState(int stateId) {
    if (stateId < 0 || stateId >= IDS_TO_OLD_STATES.length)
        return IDS_TO_OLD_STATES[0];
    Dynamic<?> ret = IDS_TO_OLD_STATES[stateId];
    if (ret == null)
        return IDS_TO_OLD_STATES[0];
    return ret;
}
 

@Override
public <T> Dynamic<T> update(final DSL.TypeReference type, final Dynamic<T> input, final int version, final int newVersion) {
    if (version < newVersion) {
        final Type<?> dataType = getType(type, version);
        final DataResult<T> read = dataType.readAndWrite(input.getOps(), getType(type, newVersion), getRule(version, newVersion), OPTIMIZATION_RULE, input.getValue());
        final T result = read.resultOrPartial(LOGGER::error).orElse(input.getValue());
        return new Dynamic<>(input.getOps(), result);
    }
    return input;
}
 

public static NBTTagCompound convert(TypeReference type, NBTTagCompound cmp, int sourceVer, int targetVer) {
    if (sourceVer >= targetVer) {
        return cmp;
    }
    return (NBTTagCompound) INSTANCE.fixer.update(type, new Dynamic<>(OPS_NBT, cmp), sourceVer, targetVer).getValue();
}
 

private static String fixName(String key, int srcVer, TypeReference type) {
    return INSTANCE.fixer.update(type, new Dynamic<>(OPS_NBT, NBTTagString.a(key)), srcVer, DATA_VERSION)
            .getValue().asString();
}
 

private String fixBlockState(String blockState, int srcVer) {
    NBTTagCompound stateNBT = stateToNBT(blockState);
    Dynamic<NBTBase> dynamic = new Dynamic<>(OPS_NBT, stateNBT);
    NBTTagCompound fixed = (NBTTagCompound) INSTANCE.fixer.update(DataConverterTypes.BLOCK_STATE, dynamic, srcVer, DATA_VERSION).getValue();
    return nbtToState(fixed);
}
 

static OpticFinder<Dynamic<?>> remainderFinder() {
    return Instances.REMAINDER_FINDER;
}
 

static Type<Dynamic<?>> remainderType() {
    return Instances.EMPTY_PASSTHROUGH;
}
 

public <T> DataResult<Pair<Typed<A>, T>> readTyped(final Dynamic<T> input) {
    return readTyped(input.getOps(), input.getValue());
}
 

public final <T> DataResult<Dynamic<T>> writeDynamic(final DynamicOps<T> ops, final A value) {
    return write(ops, value).map(result -> new Dynamic<>(ops, result));
}
 

public final <T> DataResult<Pair<A, Dynamic<T>>> read(final Dynamic<T> input) {
    return codec().decode(input.getOps(), input.getValue()).map(v -> v.mapSecond(t -> new Dynamic<>(input.getOps(), t)));
}
 

@Override
public Codec<Dynamic<?>> buildCodec() {
    return Codec.PASSTHROUGH;
}
 

@Override
public Optional<Dynamic<?>> point(final DynamicOps<?> ops) {
    return Optional.of(new Dynamic<>(ops));
}
 

public DataResult<? extends Dynamic<?>> write() {
    return type.writeDynamic(ops, value);
}
 

<T> Dynamic<T> update(DSL.TypeReference type, Dynamic<T> input, int version, int newVersion);