282 lines
11 KiB
Java
282 lines
11 KiB
Java
/*
|
|
* Super Lead rope mod
|
|
* Copyright (C) 2025 R3944Realms
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
package top.r3944realms.superleadrope.util.capability;
|
|
|
|
import net.minecraft.core.BlockPos;
|
|
import net.minecraft.world.entity.Entity;
|
|
import net.minecraft.world.phys.Vec3;
|
|
import org.jetbrains.annotations.ApiStatus;
|
|
import org.jetbrains.annotations.NotNull;
|
|
import top.r3944realms.superleadrope.api.SLPCapability;
|
|
import top.r3944realms.superleadrope.api.type.capabilty.ILeashState;
|
|
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.Optional;
|
|
import java.util.UUID;
|
|
|
|
@SuppressWarnings("unused")
|
|
@ApiStatus.Internal
|
|
public final class LeashStateInnerAPI {
|
|
|
|
private LeashStateInnerAPI() {
|
|
} // 防止实例化
|
|
|
|
public static @NotNull Optional<ILeashState> getLeashState(@NotNull Entity entity) {
|
|
Objects.requireNonNull(entity, "Entity cannot be null");
|
|
return entity.getCapability(SLPCapability.LEASH_STATE_CAP).resolve();
|
|
}
|
|
|
|
// ==================== 查询操作 ====================
|
|
|
|
public static final class Query {
|
|
private Query() {
|
|
}
|
|
public static boolean hasLeashState(Entity entity) {
|
|
return getLeashState(entity).map(ILeashState::hasLeashState).orElse(false);
|
|
}
|
|
|
|
public static Map<UUID, ILeashState.LeashState> getAllUUIDStates(Entity entity) {
|
|
return getLeashState(entity)
|
|
.map(ILeashState::getHolderLeashStates)
|
|
.orElse(Map.of());
|
|
}
|
|
|
|
public static Map<BlockPos, ILeashState.LeashState> getAllBlockPosStates(Entity entity) {
|
|
return getLeashState(entity)
|
|
.map(ILeashState::getKnotLeashStates)
|
|
.orElse(Map.of());
|
|
}
|
|
|
|
public static Optional<ILeashState.LeashState> getState(Entity entity, Entity holder) {
|
|
return getLeashState(entity).flatMap(state -> state.getLeashState(holder));
|
|
}
|
|
|
|
public static Optional<ILeashState.LeashState> getState(Entity entity, UUID holderUUID) {
|
|
return getLeashState(entity).flatMap(state -> state.getLeashState(holderUUID));
|
|
}
|
|
|
|
public static Optional<ILeashState.LeashState> getState(Entity entity, BlockPos knotPos) {
|
|
return getLeashState(entity).flatMap(state -> state.getLeashState(knotPos));
|
|
}
|
|
|
|
public static boolean hasState(Entity entity) {
|
|
return getLeashState(entity).isPresent();
|
|
}
|
|
|
|
public static boolean hasStateFor(Entity entity, Entity holder) {
|
|
return getState(entity, holder).isPresent();
|
|
}
|
|
|
|
public static boolean hasStateFor(Entity entity, UUID holderUUID) {
|
|
return getState(entity, holderUUID).isPresent();
|
|
}
|
|
|
|
public static boolean hasStateFor(Entity entity, BlockPos knotPos) {
|
|
return getState(entity, knotPos).isPresent();
|
|
}
|
|
}
|
|
|
|
// ==================== 偏移量操作 ====================
|
|
|
|
public static final class Offset {
|
|
private Offset() {
|
|
}
|
|
|
|
// ---------------------- 重置操作 ----------------------
|
|
public static void resetAllHolder(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::resetAllLeashHolderLocationsOffset);
|
|
}
|
|
|
|
public static void resetHolderFor(Entity entity, Entity holder) {
|
|
getLeashState(entity).ifPresent(state -> state.resetLeashHolderLocationOffset(holder));
|
|
}
|
|
|
|
public static void resetHolderFor(Entity entity, UUID holderUUID) {
|
|
getLeashState(entity).ifPresent(state -> state.resetLeashHolderLocationOffset(holderUUID));
|
|
}
|
|
|
|
public static void resetHolderFor(Entity entity, BlockPos knotPos) {
|
|
getLeashState(entity).ifPresent(state -> state.resetLeashHolderLocationOffset(knotPos));
|
|
}
|
|
|
|
// ---------------------- 设置操作 ----------------------
|
|
public static void setHolderFor(Entity entity, Entity holder, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.setLeashHolderLocationOffset(holder, offset));
|
|
}
|
|
|
|
public static void setHolderFor(Entity entity, UUID holderUUID, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.setLeashHolderLocationOffset(holderUUID, offset));
|
|
}
|
|
|
|
public static void setHolderFor(Entity entity, BlockPos knotPos, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.setLeashHolderLocationOffset(knotPos, offset));
|
|
}
|
|
|
|
public static void setHolderFor(Entity entity, BlockPos knotPos) {
|
|
getLeashState(entity).ifPresent(state -> state.setLeashHolderLocationOffset(knotPos, null));
|
|
}
|
|
public static void setHolderFor(Entity entity, Entity holder) {
|
|
getLeashState(entity).ifPresent(state -> state.setLeashHolderLocationOffset(holder, null));
|
|
}
|
|
|
|
public static void setHolderFor(Entity entity, UUID holderUUID) {
|
|
getLeashState(entity).ifPresent(state -> state.setLeashHolderLocationOffset(holderUUID, null));
|
|
}
|
|
|
|
// ---------------------- 添加操作 ----------------------
|
|
public static void addHolderTo(Entity entity, Entity holder, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.addLeashHolderLocationOffset(holder, offset));
|
|
}
|
|
|
|
public static void addHolderTo(Entity entity, UUID holderUUID, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.addLeashHolderLocationOffset(holderUUID, offset));
|
|
}
|
|
|
|
public static void addHolderTo(Entity entity, BlockPos knotPos, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.addLeashHolderLocationOffset(knotPos, offset));
|
|
}
|
|
|
|
// ---------------------- 移除操作 ----------------------
|
|
public static void removeHolderFor(Entity entity, Entity holder) {
|
|
getLeashState(entity).ifPresent(state -> state.removeLeashHolderLocationOffset(holder));
|
|
}
|
|
|
|
public static void removeHolderFor(Entity entity, UUID holderUUID) {
|
|
getLeashState(entity).ifPresent(state -> state.removeLeashHolderLocationOffset(holderUUID));
|
|
}
|
|
|
|
public static void removeHolderFor(Entity entity, BlockPos knotPos) {
|
|
getLeashState(entity).ifPresent(state -> state.removeLeashHolderLocationOffset(knotPos));
|
|
}
|
|
|
|
public static void removeHolderAll(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::removeAllLeashHolderLocationOffset);
|
|
}
|
|
|
|
public static void removeAllHolderUUIDs(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::removeAllLeashHolderUUIDLocationOffset);
|
|
}
|
|
|
|
public static void removeAllHolderBlockPoses(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::removeAllLeashHolderBlockPosLocationOffset);
|
|
}
|
|
public static Optional<Vec3> getApplyEntityOffset(Entity entity) {
|
|
return getLeashState(entity).flatMap(ILeashState::getLeashApplyEntityLocationOffset);
|
|
}
|
|
|
|
public static Vec3 getDefaultApplyEntityOffset(Entity entity) {
|
|
return getLeashState(entity)
|
|
.map(ILeashState::getDefaultLeashApplyEntityLocationOffset)
|
|
.orElse(Vec3.ZERO);
|
|
}
|
|
|
|
public static void resetApplyEntityAll(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::resetAllLeashApplyEntityLocationsOffset);
|
|
}
|
|
|
|
public static void removeApplyEntity(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::removeLeashApplyEntityLocationOffset);
|
|
}
|
|
|
|
public static void setApplyEntity(Entity entity, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.setLeashApplyEntityLocationOffset(offset));
|
|
}
|
|
|
|
public static void addApplyEntity(Entity entity, Vec3 offset) {
|
|
getLeashState(entity).ifPresent(state -> state.addLeashApplyEntityLocationOffset(offset));
|
|
}
|
|
}
|
|
|
|
|
|
// ==================== 同步操作 ====================
|
|
|
|
public static final class Sync {
|
|
private Sync() {
|
|
}
|
|
|
|
public static void mark(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::markForSync);
|
|
}
|
|
|
|
public static void immediate(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::immediateSync);
|
|
}
|
|
|
|
public static void check(Entity entity) {
|
|
getLeashState(entity).ifPresent(ILeashState::checkSync);
|
|
}
|
|
}
|
|
|
|
// ==================== 高级操作 ====================
|
|
|
|
public static final class Operations {
|
|
private Operations() {
|
|
}
|
|
|
|
public static void attach(Entity leashed, Entity holder) {
|
|
getLeashState(leashed).ifPresent(state ->
|
|
state.setLeashHolderLocationOffset(holder,
|
|
null)
|
|
);
|
|
}
|
|
|
|
public static void detach(Entity leashed, Entity holder) {
|
|
Offset.removeHolderFor(leashed, holder);
|
|
}
|
|
|
|
public static void detach(Entity leashed, UUID holderUUID) {
|
|
Offset.removeHolderFor(leashed, holderUUID);
|
|
}
|
|
|
|
public static void detach(Entity leashed, BlockPos knotPos) {
|
|
Offset.removeHolderFor(leashed, knotPos);
|
|
}
|
|
|
|
public static void transfer(Entity leashed, Entity oldHolder, Entity newHolder) {
|
|
getLeashState(leashed).ifPresent(state -> {
|
|
state.removeLeashHolderLocationOffset(oldHolder);
|
|
state.setLeashHolderLocationOffset(newHolder,
|
|
null);
|
|
});
|
|
}
|
|
|
|
public static void transfer(Entity leashed, UUID oldHolderUUID, Entity newHolder) {
|
|
getLeashState(leashed).ifPresent(state -> {
|
|
state.removeLeashHolderLocationOffset(oldHolderUUID);
|
|
state.setLeashHolderLocationOffset(newHolder,
|
|
null);
|
|
});
|
|
}
|
|
|
|
public static void transfer(Entity leashed, BlockPos oldKnotPos, Entity newHolder) {
|
|
getLeashState(leashed).ifPresent(state -> {
|
|
state.removeLeashHolderLocationOffset(oldKnotPos);
|
|
state.setLeashHolderLocationOffset(newHolder,
|
|
null);
|
|
});
|
|
}
|
|
|
|
public static void copy(Entity source, Entity target) {
|
|
getLeashState(source).ifPresent(sourceState ->
|
|
getLeashState(target).ifPresent(targetState ->
|
|
targetState.copy(sourceState, target)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|