扫帚女巫：
我的守护伙伴

SimonMinecraft.java → onInitialize() 内新增

com.malaoshi.simon.witch.WitchContent.register();

SimonMinecraftClient.java → onInitializeClient() 内新增

com.malaoshi.simon.witch.client.WitchCompanionRenderer.registerResources();
EntityRendererRegistry.register(
    com.malaoshi.simon.witch.WitchContent.WITCH,
    com.malaoshi.simon.witch.client.WitchCompanionRenderer::new
);

src/main/java/com/malaoshi/simon/witch/client/WitchCompanionRenderer.java

package com.malaoshi.simon.witch.client;

import com.google.gson.*;
import com.malaoshi.simon.SimonMinecraft;
import com.malaoshi.simon.witch.WitchCompanionEntity;
import net.fabricmc.fabric.api.resource.*;
import net.minecraft.client.render.*;
import net.minecraft.client.render.entity.*;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.resource.*;
import net.minecraft.util.Identifier;
import net.minecraft.util.math.RotationAxis;
import org.joml.Vector3f;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

/** 网页原模型逐面导出，保留 64 个方块、原 UV、旋转及 6 张纹理。 */
public class WitchCompanionRenderer extends EntityRenderer<WitchCompanionEntity> {
    private record Face(String part, int texture, float[][] points, float[][] uv, float[] normal) {}
    private static volatile List<Face> faces = List.of();
    private static final Identifier MESH = new Identifier(SimonMinecraft.MOD_ID, "witch/mesh.json");
    private static final Identifier[] TEXTURES = new Identifier[6];
    static { for (int i = 0; i < 6; i++) TEXTURES[i] = new Identifier(SimonMinecraft.MOD_ID, "textures/entity/witch/texture_" + i + ".png"); }

    public WitchCompanionRenderer(EntityRendererFactory.Context context) { super(context); shadowRadius = 0.4f; }
    public static void registerResources() {
        ResourceManagerHelper.get(ResourceType.CLIENT_RESOURCES).registerReloadListener(new SimpleSynchronousResourceReloadListener() {
            @Override public Identifier getFabricId() { return new Identifier(SimonMinecraft.MOD_ID, "witch_mesh"); }
            @Override public void reload(ResourceManager manager) {
                try (Reader reader = new InputStreamReader(manager.getResourceOrThrow(MESH).getInputStream(), StandardCharsets.UTF_8)) {
                    JsonObject json = JsonParser.parseReader(reader).getAsJsonObject();
                    List<Face> loaded = new ArrayList<>();
                    for (JsonElement item : json.getAsJsonArray("faces")) {
                        JsonObject face = item.getAsJsonObject();
                        loaded.add(new Face(face.get("part").getAsString(), face.get("texture").getAsInt(),
                            matrix(face.getAsJsonArray("points")), matrix(face.getAsJsonArray("uv")), array(face.getAsJsonArray("normal"))));
                    }
                    faces = List.copyOf(loaded);
                    SimonMinecraft.LOGGER.info("Witch mesh loaded: {} textured faces", faces.size());
                } catch (IOException | RuntimeException error) {
                    throw new IllegalStateException("女巫模型加载失败: " + MESH, error);
                }
            }
        });
    }
    private static float[] array(JsonArray values) {
        float[] result = new float[values.size()];
        for (int i = 0; i < values.size(); i++) result[i] = values.get(i).getAsFloat();
        return result;
    }
    private static float[][] matrix(JsonArray values) {
        float[][] result = new float[values.size()][];
        for (int i = 0; i < values.size(); i++) result[i] = array(values.get(i).getAsJsonArray());
        return result;
    }
    @Override public Identifier getTexture(WitchCompanionEntity entity) { return TEXTURES[0]; }

    @Override public void render(WitchCompanionEntity entity, float yaw, float delta, MatrixStack matrices, VertexConsumerProvider buffers, int light) {
        matrices.push();
        matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(180 - yaw));
        matrices.scale(0.0625f, 0.0625f, 0.0625f);
        matrices.translate(0, 10, 0);
        float time = entity.age + delta;
        float step = (float)Math.sin(time * 0.65) * Math.min(1, (float)entity.getVelocity().horizontalLength() * 8) * 28;
        for (Face face : faces) {
            matrices.push();
            if (face.part.equals("broom") && entity.isBroomFlying()) {
                // 源扫帚已有 -57° 旋转，再转 -33° 即成为水平扫帚。
                matrices.translate(-5.5, -3, 0);
                pivot(matrices, 5.5f, 2.7f, .775f, -33, 0, 0);
            } else if (face.part.equals("right_leg") || face.part.equals("left_leg")) {
                float side = face.part.equals("right_leg") ? 1 : -1;
                pivot(matrices, side * 1.9f, 2, 0, entity.isBroomFlying() ? -65 : step * side, 0, 0);
            } else if (face.part.equals("right_arm") || face.part.equals("left_arm")) {
                float side = face.part.equals("right_arm") ? 1 : -1;
                pivot(matrices, side * 5, 13, 0, entity.isBroomFlying() ? -40 : -step * side * .6f, 0, side * 2);
            } else if (face.part.equals("cape")) {
                pivot(matrices, 0, 15, -6, entity.isBroomFlying() ? 15 : (float)Math.sin(time * .08) * 3, 0, 0);
            }
            MatrixStack.Entry entry = matrices.peek();
            VertexConsumer consumer = buffers.getBuffer(RenderLayer.getEntityCutoutNoCull(TEXTURES[face.texture]));
            Vector3f normal = new Vector3f(face.normal[0], face.normal[1], face.normal[2]).normalize();
            for (int i = 0; i < 4; i++) {
                float[] p = face.points[i], uv = face.uv[i];
                consumer.vertex(entry.getPositionMatrix(), p[0], p[1], p[2])
                    .color(255, 255, 255, 255).texture(uv[0], uv[1])
                    .overlay(OverlayTexture.DEFAULT_UV).light(light)
                    .normal(entry.getNormalMatrix(), normal.x, normal.y, normal.z).next();
            }
            matrices.pop();
        }
        matrices.pop();
        super.render(entity, yaw, delta, matrices, buffers, light);
    }
    private static void pivot(MatrixStack matrices, float x, float y, float z, float rx, float ry, float rz) {
        matrices.translate(x, y, z);
        matrices.multiply(RotationAxis.POSITIVE_Z.rotationDegrees(rz));
        matrices.multiply(RotationAxis.POSITIVE_Y.rotationDegrees(ry));
        matrices.multiply(RotationAxis.POSITIVE_X.rotationDegrees(rx));
        matrices.translate(-x, -y, -z);
    }
}

src/main/java/com/malaoshi/simon/witch/WitchContent.java

package com.malaoshi.simon.witch;

import com.malaoshi.simon.SimonMinecraft;
import net.fabricmc.fabric.api.object.builder.v1.entity.FabricDefaultAttributeRegistry;
import net.fabricmc.fabric.api.object.builder.v1.entity.FabricEntityTypeBuilder;
import net.minecraft.entity.*;
import net.minecraft.registry.*;
import net.minecraft.util.Identifier;

public final class WitchContent {
    public static final EntityType<WitchCompanionEntity> WITCH = Registry.register(
        Registries.ENTITY_TYPE, new Identifier(SimonMinecraft.MOD_ID, "witch_companion"),
        FabricEntityTypeBuilder.create(SpawnGroup.CREATURE, WitchCompanionEntity::new)
            .dimensions(EntityDimensions.fixed(0.65f, 1.95f))
            .trackRangeBlocks(80).trackedUpdateRate(2).build());

    public static void register() {
        FabricDefaultAttributeRegistry.register(WITCH, WitchCompanionEntity.attributes());
        WitchCompanions.register();
        SimonMinecraft.LOGGER.info("Witch companion ready: /witch help");
    }
}

src/main/java/com/malaoshi/simon/witch/WitchCompanionEntity.java

package com.malaoshi.simon.witch;

import net.minecraft.entity.*;
import net.minecraft.entity.attribute.*;
import net.minecraft.entity.data.*;
import net.minecraft.entity.mob.PathAwareEntity;
import net.minecraft.entity.mob.ZombieEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.ai.goal.SwimGoal;
import net.minecraft.nbt.NbtCompound;
import net.minecraft.particle.ParticleTypes;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.sound.SoundEvents;
import net.minecraft.text.Text;
import net.minecraft.util.*;
import net.minecraft.util.math.*;
import net.minecraft.world.World;
import java.util.*;

public class WitchCompanionEntity extends PathAwareEntity {
    public static final double GUARD_RADIUS = 16.0;
    public static final float MAGIC_DAMAGE = 6.0f;
    public static final int ATTACK_INTERVAL = 20; // 20 游戏刻约等于 1 秒
    private static final TrackedData<Boolean> FLYING = DataTracker.registerData(WitchCompanionEntity.class, TrackedDataHandlerRegistry.BOOLEAN);
    private static final TrackedData<Integer> MODE = DataTracker.registerData(WitchCompanionEntity.class, TrackedDataHandlerRegistry.INTEGER);
    private UUID ownerUuid;
    private int attackCooldown;
    private int stuckTicks;
    private Vec3d lastPosition = Vec3d.ZERO;

    public WitchCompanionEntity(EntityType<? extends PathAwareEntity> type, World world) {
        super(type, world);
        setPersistent(); setCustomName(Text.literal("扫帚女巫 · 守护伙伴"));
        setCustomNameVisible(true);
    }
    public static DefaultAttributeContainer.Builder attributes() {
        return createMobAttributes().add(EntityAttributes.GENERIC_MAX_HEALTH, 40)
            .add(EntityAttributes.GENERIC_MOVEMENT_SPEED, 0.30)
            .add(EntityAttributes.GENERIC_FOLLOW_RANGE, 32);
    }
    @Override protected void initGoals() { goalSelector.add(0, new SwimGoal(this)); }
    @Override protected void initDataTracker() {
        super.initDataTracker(); dataTracker.startTracking(FLYING, false); dataTracker.startTracking(MODE, 0);
    }
    public UUID getOwnerUuid() { return ownerUuid; }
    public void setOwnerUuid(UUID owner) { ownerUuid = owner; }
    public boolean isBroomFlying() { return dataTracker.get(FLYING); }
    public int getMode() { return dataTracker.get(MODE); }
    public void setMode(int mode) { dataTracker.set(MODE, MathHelper.clamp(mode, 0, 2)); }
    public static String modeName(int mode) { return new String[]{"自动陪伴", "步行跟随", "扫帚飞行"}[MathHelper.clamp(mode, 0, 2)]; }

    /** 找有地板、无液体、身体放得下的位置；若没有就悬停，避免卡进墙。 */
    public void recall(PlayerEntity owner) {
        navigation.stop(); setVelocity(Vec3d.ZERO);
        BlockPos center = owner.getBlockPos();
        for (int dy = 1; dy >= -2; dy--) for (int dx = -3; dx <= 3; dx++) for (int dz = -3; dz <= 3; dz++) {
            if (Math.abs(dx) + Math.abs(dz) < 2) continue;
            BlockPos feet = center.add(dx, dy, dz);
            if (!getWorld().getBlockState(feet.down()).isSolidBlock(getWorld(), feet.down())) continue;
            Vec3d pos = Vec3d.ofBottomCenter(feet);
            Box box = getDimensions(getPose()).getBoxAt(pos);
            if (getWorld().isSpaceEmpty(this, box) && !getWorld().containsFluid(box)) {
                refreshPositionAndAngles(pos.x, pos.y, pos.z, owner.getYaw(), 0);
                fallDistance = 0; stuckTicks = 0; return;
            }
        }
        Box box = getDimensions(getPose()).getBoxAt(owner.getPos());
        if (getWorld().isSpaceEmpty(this, box)) refreshPositionAndAngles(owner.getX(), owner.getY(), owner.getZ(), owner.getYaw(), 0);
        dataTracker.set(FLYING, true); setNoGravity(true); fallDistance = 0;
    }

    @Override public void tick() {
        super.tick();
        if (!(getWorld() instanceof ServerWorld world) || ownerUuid == null) return;
        var state = WitchCompanionState.get(world.getServer());
        // 被卸载的旧伙伴重新加载时退出，避免远距离传送后出现重复伙伴。
        if (state.disabled.contains(ownerUuid) || !getUuid().equals(state.companions.get(ownerUuid))) { discard(); return; }
        ServerPlayerEntity owner = world.getServer().getPlayerManager().getPlayer(ownerUuid);
        if (owner == null || owner.getWorld() != world || !owner.isAlive() || owner.isSpectator()) {
            navigation.stop(); setVelocity(Vec3d.ZERO); setTarget(null); return;
        }
        if (squaredDistanceTo(owner) > 28 * 28) recall(owner);
        if (attackCooldown > 0) attackCooldown--;
        if (age % 10 == 0) {
            ZombieEntity nearest = null; double best = Double.MAX_VALUE;
            if (world.isNight()) for (ZombieEntity zombie : world.getEntitiesByClass(ZombieEntity.class,
                owner.getBoundingBox().expand(GUARD_RADIUS), z -> z.isAlive() && z.squaredDistanceTo(owner) <= GUARD_RADIUS * GUARD_RADIUS)) {
                double d = squaredDistanceTo(zombie);
                if (d < best) { nearest = zombie; best = d; }
            }
            setTarget(nearest);
        }
        LivingEntity enemy = getTarget();
        if (enemy != null && (!world.isNight() || !enemy.isAlive() || enemy.squaredDistanceTo(owner) > GUARD_RADIUS * GUARD_RADIUS)) {
            setTarget(null); enemy = null;
        }
        boolean fly = getMode() == 2 || (getMode() == 0 && (age / 400) % 2 == 1);
        dataTracker.set(FLYING, fly); setNoGravity(fly); fallDistance = 0;
        Vec3d destination;
        if (enemy != null) {
            destination = enemy.getPos().add(0, fly ? 2.5 : 0, 0);
            getLookControl().lookAt(enemy, 30, 30);
            if (squaredDistanceTo(enemy) <= 12 * 12 && canSee(enemy) && attackCooldown == 0) {
                attackCooldown = ATTACK_INTERVAL;
                enemy.damage(getDamageSources().indirectMagic(this, this), MAGIC_DAMAGE);
                Vec3d from = getPos().add(0, 1.5, 0), to = enemy.getPos().add(0, 1, 0);
                for (int i = 0; i <= 16; i++) {
                    Vec3d p = from.lerp(to, i / 16.0);
                    world.spawnParticles(ParticleTypes.WITCH, p.x, p.y, p.z, 1, 0.03, 0.03, 0.03, 0.01);
                }
                playSound(SoundEvents.ENTITY_EVOKER_CAST_SPELL, 0.55f, 1.3f);
            }
        } else {
            double angle = fly ? age * 0.018 : Math.toRadians(owner.getYaw() + 110);
            destination = owner.getPos().add(Math.cos(angle) * 3, fly ? 2.5 + Math.sin(age * 0.08) * 0.25 : 0, Math.sin(angle) * 3);
            getLookControl().lookAt(owner, 30, 30);
        }
        if (fly) {
            navigation.stop();
            Vec3d delta = destination.subtract(getPos());
            Vec3d desired = delta.length() < 0.3 ? Vec3d.ZERO : delta.normalize().multiply(Math.min(0.32, delta.length() * 0.15));
            if (horizontalCollision) desired = desired.add(0, 0.18, 0);
            setVelocity(getVelocity().lerp(desired, 0.25)); velocityDirty = true;
            if (desired.horizontalLengthSquared() > 0.002) {
                setYaw((float)(Math.toDegrees(Math.atan2(desired.z, desired.x)) - 90)); bodyYaw = getYaw();
            }
            if (age % 6 == 0) world.spawnParticles(ParticleTypes.END_ROD, getX(), getY() + 0.2, getZ(), 1, 0.1, 0.05, 0.1, 0);
        } else if (age % 10 == 0) {
            if (getPos().squaredDistanceTo(destination) > 2.5 && (enemy == null || squaredDistanceTo(enemy) > 7 * 7 || !canSee(enemy)))
                navigation.startMovingTo(destination.x, destination.y, destination.z, 1.1);
            else navigation.stop();
        }
        if (age % 20 == 0) {
            boolean wantsMove = getPos().squaredDistanceTo(destination) > 16;
            stuckTicks = wantsMove && getPos().squaredDistanceTo(lastPosition) < 0.04 ? stuckTicks + 20 : 0;
            lastPosition = getPos();
            if (stuckTicks >= 100) recall(owner);
            if (getHealth() < getMaxHealth()) heal(1);
        }
    }

    @Override public void travel(Vec3d input) {
        if (isBroomFlying()) { move(MovementType.SELF, getVelocity()); setVelocity(getVelocity().multiply(0.95)); }
        else super.travel(input);
    }
    @Override public boolean handleFallDamage(float distance, float multiplier, net.minecraft.entity.damage.DamageSource source) { return false; }
    @Override protected ActionResult interactMob(PlayerEntity player, Hand hand) {
        if (!player.getUuid().equals(ownerUuid)) return ActionResult.PASS;
        if (player instanceof ServerPlayerEntity serverPlayer) {
            WitchCompanions.setMode(serverPlayer, (getMode() + 1) % 3);
            player.sendMessage(Text.literal("伙伴模式：" + modeName(getMode())), true);
        }
        return ActionResult.success(getWorld().isClient);
    }
    @Override public void writeCustomDataToNbt(NbtCompound nbt) {
        super.writeCustomDataToNbt(nbt);
        if (ownerUuid != null) nbt.putUuid("WitchOwner", ownerUuid);
        nbt.putInt("WitchMode", getMode());
    }
    @Override public void readCustomDataFromNbt(NbtCompound nbt) {
        super.readCustomDataFromNbt(nbt);
        if (nbt.containsUuid("WitchOwner")) ownerUuid = nbt.getUuid("WitchOwner");
        setMode(nbt.getInt("WitchMode"));
    }
}

src/main/java/com/malaoshi/simon/witch/WitchCompanionState.java

package com.malaoshi.simon.witch;

import net.minecraft.nbt.NbtCompound;
import net.minecraft.nbt.NbtList;
import net.minecraft.server.MinecraftServer;
import net.minecraft.world.PersistentState;
import java.util.*;

/** 每个玩家只保留一个伙伴编号；关闭和模式选择也会随世界保存。 */
public final class WitchCompanionState extends PersistentState {
    public final Map<UUID, UUID> companions = new HashMap<>();
    public final Map<UUID, Integer> modes = new HashMap<>();
    public final Set<UUID> disabled = new HashSet<>();

    public static WitchCompanionState get(MinecraftServer server) {
        return server.getOverworld().getPersistentStateManager().getOrCreate(
            WitchCompanionState::read, WitchCompanionState::new, "simon_witch_companions");
    }

    private static WitchCompanionState read(NbtCompound nbt) {
        WitchCompanionState state = new WitchCompanionState();
        NbtList list = nbt.getList("Players", 10);
        for (int i = 0; i < list.size(); i++) {
            NbtCompound row = list.getCompound(i);
            if (!row.containsUuid("Owner")) continue;
            UUID owner = row.getUuid("Owner");
            if (row.containsUuid("Companion")) state.companions.put(owner, row.getUuid("Companion"));
            state.modes.put(owner, Math.max(0, Math.min(2, row.getInt("Mode"))));
            if (row.getBoolean("Disabled")) state.disabled.add(owner);
        }
        return state;
    }

    @Override public NbtCompound writeNbt(NbtCompound nbt) {
        NbtList list = new NbtList();
        Set<UUID> owners = new HashSet<>(companions.keySet());
        owners.addAll(disabled); owners.addAll(modes.keySet());
        for (UUID owner : owners) {
            NbtCompound row = new NbtCompound();
            row.putUuid("Owner", owner);
            if (companions.containsKey(owner)) row.putUuid("Companion", companions.get(owner));
            row.putInt("Mode", modes.getOrDefault(owner, 0));
            row.putBoolean("Disabled", disabled.contains(owner));
            list.add(row);
        }
        nbt.put("Players", list);
        return nbt;
    }
}

src/main/java/com/malaoshi/simon/witch/WitchCompanions.java

package com.malaoshi.simon.witch;

import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
import net.minecraft.entity.Entity;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.text.Text;
import java.util.UUID;
import static net.minecraft.server.command.CommandManager.literal;

/** 服务器负责生成、跨维度重建和指令；客户端只负责显示。 */
public final class WitchCompanions {
    public static void register() {
        ServerTickEvents.END_SERVER_TICK.register(server -> {
            if (server.getTicks() % 20 != 0) return;
            for (ServerPlayerEntity player : server.getPlayerManager().getPlayerList()) {
                if (player.isAlive() && !player.isSpectator()) ensure(player);
            }
        });
        CommandRegistrationCallback.EVENT.register((dispatcher, registry, environment) -> {
            var root = literal("witch").requires(source -> source.getEntity() instanceof ServerPlayerEntity)
                .executes(ctx -> help(ctx.getSource().getPlayerOrThrow()));
            root.then(literal("help").executes(ctx -> help(ctx.getSource().getPlayerOrThrow())));
            root.then(literal("summon").executes(ctx -> {
                var player = ctx.getSource().getPlayerOrThrow();
                var state = WitchCompanionState.get(player.getServer());
                state.disabled.remove(player.getUuid()); state.markDirty();
                ensure(player); tell(player, "女巫伙伴已开启。右键她切换模式。"); return 1;
            }));
            root.then(literal("recall").executes(ctx -> {
                var player = ctx.getSource().getPlayerOrThrow();
                var witch = ensure(player);
                if (witch != null) witch.recall(player);
                tell(player, witch == null ? "伙伴已关闭，请先输入 /witch summon。" : "伙伴回到你身边了。"); return 1;
            }));
            root.then(literal("remove").executes(ctx -> {
                var player = ctx.getSource().getPlayerOrThrow();
                var state = WitchCompanionState.get(player.getServer());
                state.disabled.add(player.getUuid());
                var witch = find(player.getServer(), state.companions.remove(player.getUuid()));
                if (witch != null) witch.discard();
                state.markDirty(); tell(player, "伙伴已关闭；/witch summon 可以重新开启。"); return 1;
            }));
            var mode = literal("mode");
            String[] names = {"auto", "walk", "fly"};
            for (int i = 0; i < names.length; i++) {
                final int selected = i;
                mode.then(literal(names[i]).executes(ctx -> {
                    var player = ctx.getSource().getPlayerOrThrow();
                    setMode(player, selected);
                    tell(player, "伙伴模式：" + WitchCompanionEntity.modeName(selected)); return 1;
                }));
            }
            root.then(mode); dispatcher.register(root);
        });
    }

    private static int help(ServerPlayerEntity player) {
        tell(player, "女巫伙伴：/witch mode auto|walk|fly；/witch recall；/witch remove；/witch summon。夜晚会攻击你附近的僵尸。");
        return 1;
    }
    private static void tell(ServerPlayerEntity player, String message) {
        player.sendMessage(Text.literal(message), false);
    }
    public static void setMode(ServerPlayerEntity player, int mode) {
        var state = WitchCompanionState.get(player.getServer());
        state.modes.put(player.getUuid(), mode); state.markDirty();
        var witch = ensure(player);
        if (witch != null) witch.setMode(mode);
    }
    public static WitchCompanionEntity find(MinecraftServer server, UUID uuid) {
        if (uuid == null) return null;
        for (ServerWorld world : server.getWorlds()) {
            Entity entity = world.getEntity(uuid);
            if (entity instanceof WitchCompanionEntity witch && witch.isAlive()) return witch;
        }
        return null;
    }
    public static WitchCompanionEntity ensure(ServerPlayerEntity player) {
        var state = WitchCompanionState.get(player.getServer());
        UUID owner = player.getUuid();
        if (state.disabled.contains(owner)) return null;
        var witch = find(player.getServer(), state.companions.get(owner));
        if (witch != null && witch.getWorld() != player.getWorld()) {
            witch.discard(); witch = null;
        }
        if (witch == null) {
            witch = WitchContent.WITCH.create(player.getServerWorld());
            if (witch == null) return null;
            witch.setOwnerUuid(owner);
            witch.setMode(state.modes.getOrDefault(owner, 0));
            // 初始位置必须在主人身边；召回找不到空位时也不会留在 (0,0,0)。
            witch.refreshPositionAndAngles(player.getX(), player.getY(), player.getZ(), player.getYaw(), 0);
            witch.recall(player);
            if (!player.getServerWorld().spawnEntity(witch)) return null;
            state.companions.put(owner, witch.getUuid()); state.markDirty();
        }
        return witch;
    }
}