ParticleUnflatteningFix.java

net.minecraft.util.datafix.fixes.ParticleUnflatteningFix

信息

• 全限定名：net.minecraft.util.datafix.fixes.ParticleUnflatteningFix
• 类型：public class
• 包：net.minecraft.util.datafix.fixes
• 源码路径：src/main/java/net/minecraft/util/datafix/fixes/ParticleUnflatteningFix.java
• 起始行号：L23
• 继承：DataFix
• 职责：

  TODO

字段/常量

• LOGGER
  • 类型: Logger
  • 修饰符: private static final
  • 源码定位: L24
  • 说明:

    TODO

内部类/嵌套类型

• 无

构造器

public ParticleUnflatteningFix(Schema outputSchema) @ L26

• 构造器名：ParticleUnflatteningFix
• 源码定位：L26
• 修饰符：public

参数:

• outputSchema: Schema

说明:

TODO

方法

下面的方法块按源码顺序生成。

protected TypeRewriteRule makeRule() @ L30

• 方法名：makeRule
• 源码定位：L30
• 返回类型：TypeRewriteRule
• 修饰符：protected

参数:

• 无

说明:

TODO

private <T> Dynamic<T> fix(Dynamic<T> input) @ L37

• 方法名：fix
• 源码定位：L37
• 返回类型： Dynamic
• 修饰符：private

参数:

• input: Dynamic

说明:

TODO

private <T> Dynamic<T> updateItem(Dynamic<T> result, String contents) @ L62

• 方法名：updateItem
• 源码定位：L62
• 返回类型： Dynamic
• 修饰符：private

参数:

• result: Dynamic
• contents: String

说明:

TODO

private static <T> Dynamic<T> parseTag(DynamicOps<T> ops, String contents) @ L78

• 方法名：parseTag
• 源码定位：L78
• 返回类型： Dynamic
• 修饰符：private static

参数:

• ops: DynamicOps
• contents: String

说明:

TODO

private <T> Dynamic<T> updateBlock(Dynamic<T> result, String contents) @ L87

• 方法名：updateBlock
• 源码定位：L87
• 返回类型： Dynamic
• 修饰符：private

参数:

• result: Dynamic
• contents: String

说明:

TODO

private static <T> Map<Dynamic<T>,Dynamic<T>> parseBlockProperties(Dynamic<T> dynamic, String contents) @ L103

• 方法名：parseBlockProperties
• 源码定位：L103
• 返回类型： Map<Dynamic,Dynamic>
• 修饰符：private static

参数:

• dynamic: Dynamic
• contents: String

说明:

TODO

private static <T> Dynamic<T> readVector(Dynamic<T> result, StringReader reader) @ L136

• 方法名：readVector
• 源码定位：L136
• 返回类型： Dynamic
• 修饰符：private static

参数:

• result: Dynamic
• reader: StringReader

说明:

TODO

private <T> Dynamic<T> updateDust(Dynamic<T> result, String contents) @ L145

• 方法名：updateDust
• 源码定位：L145
• 返回类型： Dynamic
• 修饰符：private

参数:

• result: Dynamic
• contents: String

说明:

TODO

private <T> Dynamic<T> updateDustTransition(Dynamic<T> result, String contents) @ L158

• 方法名：updateDustTransition
• 源码定位：L158
• 返回类型： Dynamic
• 修饰符：private

参数:

• result: Dynamic
• contents: String

说明:

TODO

private <T> Dynamic<T> updateSculkCharge(Dynamic<T> result, String contents) @ L173

• 方法名：updateSculkCharge
• 源码定位：L173
• 返回类型： Dynamic
• 修饰符：private

参数:

• result: Dynamic
• contents: String

说明:

TODO

private <T> Dynamic<T> updateVibration(Dynamic<T> result, String contents) @ L184

• 方法名：updateVibration
• 源码定位：L184
• 返回类型： Dynamic
• 修饰符：private

参数:

• result: Dynamic
• contents: String

说明:

TODO

private <T> Dynamic<T> updateShriek(Dynamic<T> result, String contents) @ L205

• 方法名：updateShriek
• 源码定位：L205
• 返回类型： Dynamic
• 修饰符：private

参数:

• result: Dynamic
• contents: String

说明:

TODO

代码

public class ParticleUnflatteningFix extends DataFix {
    private static final Logger LOGGER = LogUtils.getLogger();
 
    public ParticleUnflatteningFix(Schema outputSchema) {
        super(outputSchema, true);
    }
 
    @Override
    protected TypeRewriteRule makeRule() {
        Type<?> oldType = this.getInputSchema().getType(References.PARTICLE);
        Type<?> newType = this.getOutputSchema().getType(References.PARTICLE);
        return this.writeFixAndRead("ParticleUnflatteningFix", oldType, newType, this::fix);
    }
 
    private <T> Dynamic<T> fix(Dynamic<T> input) {
        Optional<String> maybeString = input.asString().result();
        if (maybeString.isEmpty()) {
            return input;
        } else {
            String particleDescription = maybeString.get();
            String[] parts = particleDescription.split(" ", 2);
            String id = NamespacedSchema.ensureNamespaced(parts[0]);
            Dynamic<T> result = input.createMap(Map.of(input.createString("type"), input.createString(id)));
 
            return switch (id) {
                case "minecraft:item" -> parts.length > 1 ? this.updateItem(result, parts[1]) : result;
                case "minecraft:block", "minecraft:block_marker", "minecraft:falling_dust", "minecraft:dust_pillar" -> parts.length > 1
                    ? this.updateBlock(result, parts[1])
                    : result;
                case "minecraft:dust" -> parts.length > 1 ? this.updateDust(result, parts[1]) : result;
                case "minecraft:dust_color_transition" -> parts.length > 1 ? this.updateDustTransition(result, parts[1]) : result;
                case "minecraft:sculk_charge" -> parts.length > 1 ? this.updateSculkCharge(result, parts[1]) : result;
                case "minecraft:vibration" -> parts.length > 1 ? this.updateVibration(result, parts[1]) : result;
                case "minecraft:shriek" -> parts.length > 1 ? this.updateShriek(result, parts[1]) : result;
                default -> result;
            };
        }
    }
 
    private <T> Dynamic<T> updateItem(Dynamic<T> result, String contents) {
        int tagPartStart = contents.indexOf("{");
        Dynamic<T> itemStack = result.createMap(Map.of(result.createString("Count"), result.createInt(1)));
        if (tagPartStart == -1) {
            itemStack = itemStack.set("id", result.createString(contents));
        } else {
            itemStack = itemStack.set("id", result.createString(contents.substring(0, tagPartStart)));
            Dynamic<T> itemTag = parseTag(result.getOps(), contents.substring(tagPartStart));
            if (itemTag != null) {
                itemStack = itemStack.set("tag", itemTag);
            }
        }
 
        return result.set("item", itemStack);
    }
 
    private static <T> @Nullable Dynamic<T> parseTag(DynamicOps<T> ops, String contents) {
        try {
            return new Dynamic<>(ops, TagParser.create(ops).parseFully(contents));
        } catch (Exception var3) {
            LOGGER.warn("Failed to parse tag: {}", contents, var3);
            return null;
        }
    }
 
    private <T> Dynamic<T> updateBlock(Dynamic<T> result, String contents) {
        int statePartStart = contents.indexOf("[");
        Dynamic<T> blockState = result.emptyMap();
        if (statePartStart == -1) {
            blockState = blockState.set("Name", result.createString(NamespacedSchema.ensureNamespaced(contents)));
        } else {
            blockState = blockState.set("Name", result.createString(NamespacedSchema.ensureNamespaced(contents.substring(0, statePartStart))));
            Map<Dynamic<T>, Dynamic<T>> properties = parseBlockProperties(result, contents.substring(statePartStart));
            if (!properties.isEmpty()) {
                blockState = blockState.set("Properties", result.createMap(properties));
            }
        }
 
        return result.set("block_state", blockState);
    }
 
    private static <T> Map<Dynamic<T>, Dynamic<T>> parseBlockProperties(Dynamic<T> dynamic, String contents) {
        try {
            Map<Dynamic<T>, Dynamic<T>> result = new HashMap<>();
            StringReader reader = new StringReader(contents);
            reader.expect('[');
            reader.skipWhitespace();
 
            while (reader.canRead() && reader.peek() != ']') {
                reader.skipWhitespace();
                String key = reader.readString();
                reader.skipWhitespace();
                reader.expect('=');
                reader.skipWhitespace();
                String value = reader.readString();
                reader.skipWhitespace();
                result.put(dynamic.createString(key), dynamic.createString(value));
                if (reader.canRead()) {
                    if (reader.peek() != ',') {
                        break;
                    }
 
                    reader.skip();
                }
            }
 
            reader.expect(']');
            return result;
        } catch (Exception var6) {
            LOGGER.warn("Failed to parse block properties: {}", contents, var6);
            return Map.of();
        }
    }
 
    private static <T> Dynamic<T> readVector(Dynamic<T> result, StringReader reader) throws CommandSyntaxException {
        float x = reader.readFloat();
        reader.expect(' ');
        float y = reader.readFloat();
        reader.expect(' ');
        float z = reader.readFloat();
        return result.createList(Stream.of(x, y, z).map(result::createFloat));
    }
 
    private <T> Dynamic<T> updateDust(Dynamic<T> result, String contents) {
        try {
            StringReader reader = new StringReader(contents);
            Dynamic<T> vector = readVector(result, reader);
            reader.expect(' ');
            float scale = reader.readFloat();
            return result.set("color", vector).set("scale", result.createFloat(scale));
        } catch (Exception var6) {
            LOGGER.warn("Failed to parse particle options: {}", contents, var6);
            return result;
        }
    }
 
    private <T> Dynamic<T> updateDustTransition(Dynamic<T> result, String contents) {
        try {
            StringReader reader = new StringReader(contents);
            Dynamic<T> from = readVector(result, reader);
            reader.expect(' ');
            float scale = reader.readFloat();
            reader.expect(' ');
            Dynamic<T> to = readVector(result, reader);
            return result.set("from_color", from).set("to_color", to).set("scale", result.createFloat(scale));
        } catch (Exception var7) {
            LOGGER.warn("Failed to parse particle options: {}", contents, var7);
            return result;
        }
    }
 
    private <T> Dynamic<T> updateSculkCharge(Dynamic<T> result, String contents) {
        try {
            StringReader reader = new StringReader(contents);
            float roll = reader.readFloat();
            return result.set("roll", result.createFloat(roll));
        } catch (Exception var5) {
            LOGGER.warn("Failed to parse particle options: {}", contents, var5);
            return result;
        }
    }
 
    private <T> Dynamic<T> updateVibration(Dynamic<T> result, String contents) {
        try {
            StringReader reader = new StringReader(contents);
            float destX = (float)reader.readDouble();
            reader.expect(' ');
            float destY = (float)reader.readDouble();
            reader.expect(' ');
            float destZ = (float)reader.readDouble();
            reader.expect(' ');
            int arrivalInTicks = reader.readInt();
            Dynamic<T> blockPos = (Dynamic<T>)result.createIntList(IntStream.of(Mth.floor(destX), Mth.floor(destY), Mth.floor(destZ)));
            Dynamic<T> positionSource = result.createMap(
                Map.of(result.createString("type"), result.createString("minecraft:block"), result.createString("pos"), blockPos)
            );
            return result.set("destination", positionSource).set("arrival_in_ticks", result.createInt(arrivalInTicks));
        } catch (Exception var10) {
            LOGGER.warn("Failed to parse particle options: {}", contents, var10);
            return result;
        }
    }
 
    private <T> Dynamic<T> updateShriek(Dynamic<T> result, String contents) {
        try {
            StringReader reader = new StringReader(contents);
            int delay = reader.readInt();
            return result.set("delay", result.createInt(delay));
        } catch (Exception var5) {
            LOGGER.warn("Failed to parse particle options: {}", contents, var5);
            return result;
        }
    }
}

引用的其他类

• TagParser

  • 引用位置: 方法调用
  • 关联成员: TagParser.create()

• Schema

  • 引用位置: 参数

• Mth

  • 引用位置: 方法调用
  • 关联成员: Mth.floor()

• NamespacedSchema

  • 引用位置: 方法调用
  • 关联成员: NamespacedSchema.ensureNamespaced()

• ResolvableProfile

  • 引用位置: 参数/返回值