有关袭击加强的思路及讨论

本文基于 CC BY 发表，本文开发环境 1.16.5 Forge，Java 8。
本文基于袭击正常打法和正常模组环境下，请勿与袭击塔或各种神仙武器比较。
袭击在原版中强度还是算比较高的，但放在整合包中，又显得如此力不从心，因此本文基于这一点提供一些强化袭击的方案。
仅仅对面板数值的强化显得毫无意义，因此本文将从以下方面加强袭击：

• 任意玩家死亡算作袭击失败。
• 袭击仅能在主世界发起。
• 袭击的波数从原先的7+1波提升至固定15波。
• 袭击进行时所有实现了ITickableTileEntity接口的方块实体停止工作。
• 所有袭击者在袭击的时候免疫摔落、魔法、爆炸和其他袭击者的伤害。
• 袭击生成时所有袭击者分散开。
  

1.玩家死亡时袭击失败
这一点比较好实现，LivingDeathEvent即可实现，需要注意的是，在死亡的时候获取袭击记得判断是否为空。
当玩家死亡的时候使用Raid#stop即可停止袭击。
但这是停止袭击，而不是袭击失败。袭击状态是private的，因此我们需要将其改为public的。

1. public net.minecraft.world.raid.Raid$WaveMember field_221286_h
   
2. public net.minecraft.world.raid.Raid$Status
   
3. public net.minecraft.world.raid.Raid field_221360_x
   
4. public net.minecraft.world.raid.Raid field_221347_k

复制代码

后文还有其他要用到的，这里就一起修改访问权限了。

1. @Mod.EventBusSubscriber(bus=Mod.EventBusSubscriber.Bus.FORGE)
   
2. public class PlayerDeathEvent {
   
3.     @SubscribeEvent
   
4.     public static void playerDeathEvent(LivingDeathEvent event){
   
5.         LivingEntity livingEntity = event.getEntityLiving();
   
6.         if(livingEntity.level.isClientSide) return;
   
7.         if(livingEntity instanceof PlayerEntity){
   
8.             MinecraftServer server = livingEntity.level.getServer();
   
9.             ServerWorld world = server.overworld();
   
10.             BlockPos deathPos = new BlockPos(livingEntity.position());
    
11.             Raid raid = world.getRaidAt(deathPos);
    
12.             if(raid != null){
    
13.                 raid.status = Raid.Status.LOSS;
    
14.             }
    
15.         }
    
16.     }
    
17. }

复制代码

2.袭击仅能在主世界发起：
这个也比较简单，在PlayerTickEvent判断玩家这里有不有袭击，有的话是不是主世界，不是停止即可。

1. @Mod.EventBusSubscriber(bus=Mod.EventBusSubscriber.Bus.FORGE)
   
2. public class PlayerTickEvent {
   
3.     @SubscribeEvent
   
4.     public static void playerTickEvent(TickEvent.PlayerTickEvent event) {
   
5.         PlayerEntity player = event.getPlayer();
   
6.         if(player.level.isClientSide()) return;
   
7.         if(!player.level.dimension().equals(World.OVERWORLD)){
   
8.             if(world.isRaided(playerPos)){
   
9.                 world.getRaidAt(playerPos).stop();
   
10.             }
    
11.         }
    
12.     }
    
13. }

复制代码

3.拓展袭击波数
原版的袭击默认情况最高7波，当不祥之兆等级大于等于1会额外增加一波，因此最多是8波。
从原版的生成袭击者的方法来看，是从一个int[]数组中获取值，然后加上附加数量，但是这个数组只有八个，也就是索引最多到7，直接获取会越界。
根据以上分析，我们需要重写其生成时候的方法了，同时将原有的不祥之兆大于1级时的额外波数取消掉。
首先，拓展袭击波数：

1. @Mixin(Raid.class)
   
2. public abstract class RaidMixin{
   
3.     @Inject(method = "getNumGroups",at = @At("HEAD"),cancellable = true)
   
4.     public void getGroups(Difficulty p_221306_1_, CallbackInfoReturnable<Integer> cir){
   
5.         cir.setReturnValue(15);
   
6.         cir.cancel();
   
7.     }
   
8. 
   
9.     @Inject(method = "hasBonusWave",at = @At("HEAD"),cancellable = true)
   
10.     public void moreWave(CallbackInfoReturnable<Boolean> cir){
    
11.         cir.setReturnValue(false);
    
12.         cir.cancel();
    
13.     }
    
14. }

复制代码

然后来干预袭击生成者的数量，从第9波开始，每波数量为第8波数量加上i-8波的数量（i为当前波数）

1. @Shadow
   
2. public int groupsSpawned;  //我们在上文修改了它的访问权限，因此直接通过 (Raid)(Object)this 来获取也行
   
3. 
   
4. @Inject(method = "getDefaultNumSpawns",at = @At("HEAD"),cancellable = true)
   
5. public void getDefaultNumSpawns(Raid.WaveMember p_221330_1_, int p_221330_2_, boolean p_221330_3_, CallbackInfoReturnable<Integer> cir){
   
6.     if(groupsSpawned >= 7){
   
7.         int i =  groupsSpawned - 7;
   
8.         List<Raid.WaveMember> members = new ArrayList<>(Arrays.asList(Raid.WaveMember.values()));
   
9.         for(Raid.WaveMember m : members){
   
10.             cir.setReturnValue(m.spawnsPerWaveBeforeBonus[i] + m.spawnsPerWaveBeforeBonus[7]);
    
11.             cir.cancel();
    
12.         }
    
13.     }
    
14. }

复制代码

同样的，getPotentialBonusSpawns方法与上面类似，注意不要太多了，不然会变成神仙打架。

另外一点，袭击如果40分钟没有分出胜负将自动停止，因此我们需要把这个机制去掉：

1. @Inject(method = "tick",at = @At(value = "INVOKE",target = "Lnet/minecraft/world/raid/Raid;stop()V",ordinal = 2),cancellable = true)
   
2. public void tick(CallbackInfo ci){
   
3.     ci.cancel();
   
4. }

复制代码

4.所有tick的方块实体停机
这个在袭击中还是比较重要的，对于植物魔法等模组，存在范围攻击、静止生物、生命恢复的功能花。
当world tick方块实体的时候，判断这个方块实体在不在袭击范围内，如果在的话将它放到不加载的Set中。
同时，袭击结束后得从不加载的Set中删除，并重新放到加载集合中。
注意，星辉魔法的仪式基座（效应放大器）会存在一些问题，建议将其排除在外，通过其他手段禁用。

1. import hellfirepvp.astralsorcery.common.tile.base.TileEntitySynchronized;
   
2. 
   
3. @Mixin(World.class)
   
4. public abstract class WorldMixin {
   
5.     @Shadow
   
6.     @Final
   
7.     protected final Set<TileEntity> blockEntitiesToUnload = java.util.Collections.newSetFromMap(new java.util.IdentityHashMap<>());
   
8. 
   
9.     private final Set<TileEntity> ban = new HashSet<>();
   
10. 
    
11.     @Inject(method = "tickBlockEntities",at = @At("HEAD"))
    
12.     public void tickEntities(CallbackInfo ci){
    
13.         World world = (World)(Object)this;
    
14.         MinecraftServer server = world.getServer();
    
15.         if(server == null) return;
    
16.         ServerWorld serverWorld = server.overworld();
    
17.         if(ban.size() != 0){
    
18.             for(TileEntity entity:ban){
    
19.                 if(!world.tickableBlockEntities.contains(entity) && !serverWorld.isRaided(entity.getBlockPos())){
    
20.                     world.tickableBlockEntities.add(entity);
    
21.                 }
    
22.             }
    
23.         }
    
24.         for(TileEntity tileEntity : world.tickableBlockEntities){
    
25.             Raid raid = serverWorld.getRaidAt(tileEntity.getBlockPos());
    
26.             blockEntitiesToUnload.remove(tileEntity);
    
27.             if(raid != null && tileEntity instanceof ITickableTileEntity && !(tileEntity instanceof TileEntitySynchronized)){
    
28.                 blockEntitiesToUnload.add(tileEntity);
    
29.                 ban.add(tileEntity);
    
30.             }
    
31.         }
    
32.     }
    
33. }

复制代码

5.让袭击者在袭击期间免疫杂项伤害：
这个也很简单，LivingDamageEvent事件就可以解决了，首先判断是否在袭击里面，然后判断伤害源就行，在这里就不多赘述了。

1. @Mod.EventBusSubscriber(bus=Mod.EventBusSubscriber.Bus.FORGE)
   
2. public class LDEvent {
   
3.     @SubscribeEvent
   
4.     public static void livingDamageEvent(LivingDamageEvent event){
   
5.         LivingEntity entity = event.getEntityLiving();
   
6.         float damage = event.getAmount();
   
7.         DamageSource source = event.getSource();
   
8.         if(entity.level.isClientSide) return;
   
9.         if(entity instanceof AbstractRaiderEntity){
   
10.             MinecraftServer server = entity.getServer();
    
11.             if(server == null) return;
    
12.             Raid raid = server.overworld().getRaidAt(entity.blockPosition());
    
13.             damage *= raid != null && (source.getDirectEntity() instanceof AbstractRaiderEntity || source.isFire() || source.isExplosion() || source.equals(DamageSource.FALL)) ? 0 : 1;
    
14.             if(raid != null && source.getDirectEntity() instanceof ProjectileEntity){
    
15.                 ProjectileEntity entity1 = (ProjectileEntity) source.getDirectEntity();
    
16.                 damage *= entity1.getOwner() instanceof AbstractRaiderEntity ? 0 : 1;
    
17.             }
    
18.         }
    
19.         event.setAmount(damage);
    
20.     }
    
21. }

复制代码

6.让袭击生成袭击者的时候随机生成
这个点相较于上面的来说复杂一点，因为需要考虑各种情况。
原有的袭击生成是选定一个点，然后在这里生成袭击者，因此我们要根据这个点和袭击中心点来获取一个随机的坐标。
同时这个坐标需要合法，不能卡在方块里，或者直接从天上掉下来。
首先，根据x和z坐标来获取这个位置的最上面一个方块。（因为我们不让袭击在其他维度发起，也不需要考虑下界顶层了）

1. public class RaidUtils {
   
2.     private final BlockPos center;
   
3.     private final Raid raid;
   
4.     private final World world;
   
5. 
   
6.     public RaidUtils(@Nonnull Raid raid){
   
7.         this.raid = raid;
   
8.         this.center = raid.center;
   
9.         this.world = raid.getLevel();
   
10.     }
    
11. 
    
12.     private BlockPos getHighestBlock(BlockPos pos){
    
13.         return getHighestBlock(pos.getX(), pos.getZ());
    
14.     }
    
15. 
    
16.     private BlockPos getHighestBlock(int x,int z){
    
17.         for (int i = 255; i > 1; i--) {
    
18.             BlockPos pos = new BlockPos(x,i,z);
    
19.             BlockPos next = new BlockPos(x,i-1,z);
    
20.             if(isAir(pos) && !isAir(next)){
    
21.                 return next;
    
22.             }
    
23.         }
    
24.         return null;
    
25.     }
    
26. 
    
27.     private boolean isAir(BlockPos pos){
    
28.         return world.getBlockState(pos).getBlock().equals(Blocks.AIR);
    
29.     }
    
30. }

复制代码

然后我们根据六个int值，获取其中的随机值：

1. private static class PosRange{
   
2.     private final int xmin;
   
3.     private final int xmax;
   
4.     private final int ymin;
   
5.     private final int ymax;
   
6.     private final int zmin;
   
7.     private final int zmax;
   
8. 
   
9.     private PosRange(float a,float a1,float a2,float a3,float a4,float a5){
   
10.         xmin = (int) a;
    
11.         xmax = (int) a1;
    
12.         ymin = (int) a2;
    
13.         ymax = (int) a3;
    
14.         zmin = (int) a4;
    
15.         zmax = (int) a5;
    
16.     }
    
17. 
    
18.     private BlockPos getRandPos(){
    
19.         return new BlockPos(getRangeRandom(xmin,xmax),getRangeRandom(ymin,ymax),getRangeRandom(zmin,zmax));
    
20.     }
    
21. 
    
22.     private static int getRangeRandom(int min,int max){
    
23.         if(min == max) return min;
    
24.         int m1 = min;
    
25.         int m2 = max;
    
26.         if(m2 < m1){
    
27.             m1 = max;
    
28.             m2 = min;
    
29.         }  //分步改写了，便于阅读
    
30.         int r;
    
31.         do {
    
32.             r = getRandom(m2);
    
33.         } while (r < m1);
    
34.         return r;
    
35.     }
    
36. }

复制代码

接下来我们根据生成点，袭击中心点来获取实际的生成坐标，分为以下四个阶段：

• 对整个范围生成，尝试生成3次。
• 如果找不到1生成点，将缩小一半范围，尝试生成3次。
• 如果找不到2生成点，将选定随机村民，并生成在村民的位置上。
• 如果受到其他模组干预，第三点生成失败，返回空值，袭击停止。
  

1. public BlockPos getRandomPos(BlockPos i){
   
2.     PosRange range = new PosRange(i.getX(),2*center.getX()-i.getX(),i.getY(),2*center.getY()-i.getY(),i.getZ(),2*center.getZ()-i.getZ());
   
3.     for (int j = 0; j < 3; j++) {
   
4.         BlockPos rand = range.getRandPos();
   
5.         BlockPos pos1 = getHighestBlock(rand);
   
6.         if(pos1 != null){
   
7.             return pos1;
   
8.         }
   
9.     }
   
10.     PosRange range1 = new PosRange(0.5f*(i.getX()+center.getX()),1.5f*i.getX()-0.5f*center.getX(),0.5f*(i.getY()+center.getY()),1.5f*i.getY()-0.5f*center.getY(),0.5f*(i.getZ()+center.getZ()),1.5f*i.getZ()-0.5f*center.getZ());
    
11.     for (int j = 0; j < 3; j++) {
    
12.         BlockPos rand = range1.getRandPos();
    
13.         BlockPos pos2 = getHighestBlock(rand);
    
14.         if(pos2 != null){
    
15.             return pos2;
    
16.         }
    
17.     }
    
18.     if(getVillager().size() >= 1){
    
19.         VillagerEntity randomVillager = getVillager().get((int) (Math.random() * getVillager().size()));
    
20.         return randomVillager.blockPosition();
    
21.     }
    
22.     return null;
    
23. }
    
24. 
    
25.     public List<VillagerEntity> getVillager(){
    
26.         MinecraftServer server = world.getServer();
    
27.         List<VillagerEntity> villagers = new ArrayList<>();
    
28.         World world = raid.getLevel();
    
29.         BlockPos pos = raid.getCenter();
    
30.         int x = pos.getX();
    
31.         int y = pos.getY();
    
32.         int z = pos.getZ();
    
33.         AxisAlignedBB aabb = new AxisAlignedBB(x+96,Math.min(256,y+96),z+96,x-96,Math.max(0,y-96),z-96);
    
34.         for(VillagerEntity v : world.getLoadedEntitiesOfClass(VillagerEntity.class,aabb)){
    
35.             BlockPos villagerPos = v.blockPosition();
    
36.             if(server != null && server.overworld().getRaidAt(villagerPos) != null && server.overworld().getRaidAt(pos).getId() == raid.getId()){
    
37.                 villagers.add(v);
    
38.             }
    
39.         }
    
40.         return villagers;
    
41.     }
    
42. }

复制代码

获取到了随机坐标后，我们修改加入袭击的方法，从而改变其生成的坐标。
将其后半段重写即可，同时我们可以略微修改部分参数。

1. @Mutable
   
2. @Shadow
   
3. @Final
   
4. private final ServerWorld level;
   
5.    
   
6. protected RaidMixin(ServerWorld level) {
   
7.         this.level = level;
   
8. }
   
9. 
   
10. @Inject(method = "joinRaid",at = @At(value = "INVOKE",target = "Lnet/minecraft/entity/monster/AbstractRaiderEntity;setPos(DDD)V"),cancellable = true)
    
11. public void spawn(int p_221317_1_, AbstractRaiderEntity p_221317_2_, BlockPos p_221317_3_, boolean p_221317_4_, CallbackInfo ci){
    
12.     Raid raid = (Raid) (Object) this;
    
13.     BlockPos pos = new RaidUtils(raid).getRandomPos(p_221317_3_);
    
14.     if(pos == null){
    
15.         raid.stop();
    
16.         ci.cancel();
    
17.         return;
    
18.     }
    
19.     p_221317_2_.setPos((double)pos.getX() + 0.5D, (double)pos.getY() + 1.0D, (double)pos.getZ() + 0.5D);
    
20.     p_221317_2_.finalizeSpawn(this.level, this.level.getCurrentDifficultyAt(p_221317_3_), SpawnReason.EVENT, (ILivingEntityData)null, (CompoundNBT)null);
    
21.     p_221317_2_.applyRaidBuffs(p_221317_1_, false);
    
22.     p_221317_2_.setOnGround(true);
    
23.     this.level.addFreshEntity(p_221317_2_);
    
24.     ci.cancel();
    
25. }

复制代码

好了，这也只是我突发奇想随便想想的思路，如果有更好的点子不妨分享出来。