[1.15] Updating from older Versions

[TheidenHD]

Hey guys!

Recently I started modding with trying to update a mod (from 1.12/1.13 to 1.15)that i like.  

I now have the problem that a lot of stuff changed. I figure out most of them(hopefully) but there are a few that i can't figure out.
Is there documentation that lists all major changes? I'm bored of looking for mods that exist in both versions and using the exact same features and seeing how they did it.

[Choonster]

williewillus has an explanation of the changes in 1.13/1.14 here and 1.15 here.

[TheidenHD]

Ok it's nice, but is there something more in depth.

The problems I have are very specific.

For context this are the mods i work at:

https://github.com/TheidenHD/RecurrentComplex

https://github.com/TheidenHD/IvToolkit

https://github.com/TheidenHD/MCOpts

 

[Ugdhar]

2 hours ago, TheidenHD said:

The problems I have are very specific.

You should elaborate on this, you will likely get a better response

[TheidenHD]

Ok so this is from the first library.

This is a library for multible mods. I did not  create any part of it, so I don't know what some parts.

 

 

   public static Field findField(Class<?> clazz, String srg)
    {
        try {
            String remapped = ObfuscationReflectionHelper.remapName(srg);

            Field f = clazz.getDeclaredField(remapped);
            f.setAccessible(true);
            return f;
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

The method remapName(INameMappingService.Domain, String) in the type ObfuscationReflectionHelper is not applicable for the arguments (String)

 

 public IvWorldData(CompoundNBT compound, MCRegistry registry)
    {
        compound = compound.copy(); // Copy since ID fix tags are being removed when being applied
        final DataFixer fixer = DataFixesManager.getDataFixer();

        blockCollection = new IvBlockCollection(compound.getCompound("blockCollection"), registry);

        tileEntities = new ArrayList<>();
        tileEntities.addAll(NBTTagLists.compoundsFrom(compound, "tileEntities"));
        tileEntities.forEach(teCompound -> NBTStateInjector.recursivelyApply(teCompound, registry, false));
        tileEntities.replaceAll(teCompound -> NBTUtil.update(fixer, TypeReferences.BLOCK_ENTITY, teCompound, 0));

        entities = new ArrayList<>();
        entities.addAll(NBTTagLists.compoundsFrom(compound, "entities"));
        entities.forEach(entityCompound -> NBTStateInjector.recursivelyApply(entityCompound, registry, false));
        tileEntities.replaceAll(teCompound -> NBTUtil.update(fixer, TypeReferences.ENTITY, teCompound, 0));
    }

The method update(DataFixer, DefaultTypeReferences, CompoundNBT, int) in the type NBTUtil is not applicable for the arguments (DataFixer, DSL.TypeReference, CompoundNBT, int)

 

public static void moveEntityDefault(Entity entity, BlockPos dist)
    {
        if (entity instanceof EntityHanging)
        {
            EntityHanging entityHanging = (EntityHanging) entity;
            BlockPos hangingPosition = entityHanging.getHangingPosition().add(dist);
            entityHanging.setPosition(hangingPosition.getX(), hangingPosition.getY(), hangingPosition.getZ());
        }
        else
        {
            entity.setPosition(entity.getPosX() + dist.getX(), entity.getPosY() + dist.getY(), entity.getPosZ() + dist.getZ());
        }

        if (entity instanceof CreatureEntity)
        {
        	CreatureEntity entityCreature = (CreatureEntity) entity;
            EntityCreatureAccessor.setHomePosition(entityCreature, entityCreature.getHomePosition().add(dist));
        }
    }

EntityHanging cannot be resolved to a type

 

public static List<ServerPlayerEntity> getPlayersWatchingChunk(World world, int chunkX, int chunkZ)
    {
        if (world.isRemote || !(world instanceof ServerWorld))
        {
            return Collections.emptyList();
        }

        ArrayList<ServerPlayerEntity> playersWatching = new ArrayList<>();

        ServerWorld server = (ServerWorld) world;
        PlayerChunkMap playerManager = server.getPlayerChunkMap();

        List<ServerPlayerEntity> mpplayers = server.getPlayers();

        playersWatching.addAll(mpplayers.stream().filter(player -> playerManager.isPlayerWatchingChunk(player, chunkX, chunkZ)).collect(Collectors.toList()));

        return playersWatching;
    }

PlayerChunkMap cannot be resolved to a type

The method getPlayerChunkMap() is undefined for the type ServerWorld

 

    public static Effect[] readNBTPotions(String id, CompoundNBT compound)
    {
        if (compound.contains(id))
        {
        	ListNBT nbtTagList = compound.getList(id, Constants.NBT.TAG_STRING);
            Effect[] potions = new Effect[nbtTagList.size()];

            for (int i = 0; i < potions.length; i++)
                potions[i] = Effect.read(nbtTagList.getCompound(i));

            return potions;
        }

        return null;
    }

    public static void writeNBTPotions(String id, Effect[] potions, CompoundNBT compound)
    {
        if (potions != null)
        {
            ListNBT nbtTagList = new ListNBT();

            for (Effect p : potions)
                nbtTagList.add(p.write(new CompoundNBT()));

            compound.put(id, nbtTagList);
        }
    }

The method read(CompoundNBT) is undefined for the type Effect

The method write(CompoundNBT) is undefined for the type Effect

 

@Override
        public boolean removeEntity(Entity entity)
        {
            world.removeEntity(entity);
            return true;
        }

The method removeEntity(Entity) is undefined for the type World

 

@Override
        public List<Entity> getEntities(AxisAlignedBB bounds, @Nullable Predicate<? super Entity> predicate)
        {
            return worldData.entities.stream()
                    .filter(nbt ->
                    {
                    	ListNBT pos = nbt.getList("Pos", 6);
                        return bounds.contains(new Vec3d(pos.getDouble(0), pos.getDouble(1), pos.getDouble(2)));
                    })
                    .map(nbt -> EntityType.create(nbt, IvTileEntityHelper.getAnyWorld()))
                    .filter(predicate)
                    .collect(Collectors.toList());
        }

Cannot infer type argument(s) for <R> map(Function<? super T,? extends R>)