Examples with CrashReport net.minecraft.crash.CrashReport used on opensource projects

Example 16 with CrashReport

use of net.minecraft.crash.CrashReport in project Wurst-MC-1.12 by Wurst-Imperium.

the class EventManager method add.

public <L extends Listener> void add(Class<L> type, L listener) {
    try {
        @SuppressWarnings("unchecked") ArrayList<L> listeners = (ArrayList<L>) listenerMap.get(type);
        if (listeners == null) {
            listeners = new ArrayList<>(Arrays.asList(listener));
            listenerMap.put(type, listeners);
            return;
        }
        listeners.add(listener);
    } catch (Throwable e) {
        e.printStackTrace();
        CrashReport report = CrashReport.makeCrashReport(e, "Adding Wurst event listener");
        CrashReportCategory category = report.makeCategory("Affected listener");
        category.setDetail("Listener type", () -> type.getName());
        category.setDetail("Listener class", () -> listener.getClass().getName());
        throw new ReportedException(report);
    }
}

Example 17 with CrashReport

use of net.minecraft.crash.CrashReport in project takumicraft by TNTModders.

the class TakumiBiomeProvider method areBiomesViable.

/**
 * checks given Chunk's Biomes against List of allowed ones
 */
@Override
public boolean areBiomesViable(int x, int z, int radius, List<Biome> allowed) {
    IntCache.resetIntCache();
    int i = x - radius >> 2;
    int j = z - radius >> 2;
    int k = x + radius >> 2;
    int l = z + radius >> 2;
    int i1 = k - i + 1;
    int j1 = l - j + 1;
    int[] aint = this.genBiomes.getInts(i, j, i1, j1);
    try {
        for (int k1 = 0; k1 < i1 * j1; ++k1) {
            Biome biome = Biome.getBiome(aint[k1]);
            if (!allowed.contains(biome)) {
                return false;
            }
        }
        return true;
    } catch (Throwable throwable) {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Invalid Biome id");
        CrashReportCategory crashreportcategory = crashreport.makeCategory("Layer");
        crashreportcategory.addCrashSection("Layer", this.genBiomes.toString());
        crashreportcategory.addCrashSection("x", x);
        crashreportcategory.addCrashSection("z", z);
        crashreportcategory.addCrashSection("radius", radius);
        crashreportcategory.addCrashSection("allowed", allowed);
        throw new ReportedException(crashreport);
    }
}

Example 18 with CrashReport

use of net.minecraft.crash.CrashReport in project Galacticraft by micdoodle8.

the class BlockVec3Dim method getBlockID_noChunkLoad.

/**
 * Get block ID at the BlockVec3 coordinates without forcing a chunk load.
 *
 * @return the block ID, or null if the y-coordinate is less than 0 or
 * greater than 256 or the x or z is outside the Minecraft worldmap.
 * Returns Blocks.bedrock if the coordinates being checked are in an
 * unloaded chunk
 */
public Block getBlockID_noChunkLoad() {
    if (this.y < 0 || this.y >= 256 || this.x < -30000000 || this.z < -30000000 || this.x >= 30000000 || this.z >= 30000000) {
        return null;
    }
    World world = getWorldForId(this.dim);
    if (world == null)
        return null;
    int chunkx = this.x >> 4;
    int chunkz = this.z >> 4;
    try {
        if (world.getChunkProvider().chunkExists(chunkx, chunkz)) {
            // this will be within the same chunk
            if (BlockVec3Dim.chunkCacheX == chunkx && BlockVec3Dim.chunkCacheZ == chunkz && BlockVec3Dim.chunkCacheDim == world.provider.getDimensionId() && BlockVec3Dim.chunkCached.isLoaded()) {
                return BlockVec3Dim.chunkCached.getBlock(this.x & 15, this.y, this.z & 15);
            } else {
                Chunk chunk = null;
                chunk = world.getChunkFromChunkCoords(chunkx, chunkz);
                BlockVec3Dim.chunkCached = chunk;
                BlockVec3Dim.chunkCacheDim = world.provider.getDimensionId();
                BlockVec3Dim.chunkCacheX = chunkx;
                BlockVec3Dim.chunkCacheZ = chunkz;
                return chunk.getBlock(this.x & 15, this.y, this.z & 15);
            }
        }
        // Chunk doesn't exist - meaning, it is not loaded
        return Blocks.bedrock;
    } catch (Throwable throwable) {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Oxygen Sealer thread: Exception getting block type in world");
        CrashReportCategory crashreportcategory = crashreport.makeCategory("Requested block coordinates");
        crashreportcategory.addCrashSection("Location", CrashReportCategory.getCoordinateInfo(new BlockPos(this.x, this.y, this.z)));
        throw new ReportedException(crashreport);
    }
}

Example 19 with CrashReport

use of net.minecraft.crash.CrashReport in project Galacticraft by micdoodle8.

the class BlockVec3Dim method getBlockID.

/**
 * Get block ID at the BlockVec3Dim coordinates, with a forced chunk load if
 * the coordinates are unloaded.  Only works server-side.
 *
 * @return the block ID, or null if the y-coordinate is less than 0 or
 * greater than 256 or the x or z is outside the Minecraft worldmap.
 */
public Block getBlockID() {
    if (this.y < 0 || this.y >= 256 || this.x < -30000000 || this.z < -30000000 || this.x >= 30000000 || this.z >= 30000000) {
        return null;
    }
    World world = getWorldForId(this.dim);
    if (world == null)
        return null;
    int chunkx = this.x >> 4;
    int chunkz = this.z >> 4;
    try {
        // this will be within the same chunk
        if (BlockVec3Dim.chunkCacheX == chunkx && BlockVec3Dim.chunkCacheZ == chunkz && BlockVec3Dim.chunkCacheDim == world.provider.getDimensionId() && BlockVec3Dim.chunkCached.isLoaded()) {
            return BlockVec3Dim.chunkCached.getBlock(this.x & 15, this.y, this.z & 15);
        } else {
            Chunk chunk = null;
            chunk = world.getChunkFromChunkCoords(chunkx, chunkz);
            BlockVec3Dim.chunkCached = chunk;
            BlockVec3Dim.chunkCacheDim = world.provider.getDimensionId();
            BlockVec3Dim.chunkCacheX = chunkx;
            BlockVec3Dim.chunkCacheZ = chunkz;
            return chunk.getBlock(this.x & 15, this.y, this.z & 15);
        }
    } catch (Throwable throwable) {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Oxygen Sealer thread: Exception getting block type in world");
        CrashReportCategory crashreportcategory = crashreport.makeCategory("Requested block coordinates");
        crashreportcategory.addCrashSection("Location", CrashReportCategory.getCoordinateInfo(new BlockPos(this.x, this.y, this.z)));
        throw new ReportedException(crashreport);
    }
}

Example 20 with CrashReport

use of net.minecraft.crash.CrashReport in project Wizardry by TeamWizardry.

the class PotionTimeSlow method entityMove.

@SubscribeEvent
public void entityMove(EntityMoveEvent event) {
    if (!(event.entity instanceof EntityLivingBase))
        return;
    EntityLivingBase base = (EntityLivingBase) event.entity;
    if (!base.isPotionActive(ModPotions.TIME_SLOW))
        return;
    PotionEffect effect = base.getActivePotionEffect(ModPotions.TIME_SLOW);
    if (effect == null)
        return;
    ModuleEffectTimeSlow slow = (ModuleEffectTimeSlow) ModuleRegistry.INSTANCE.getModule("effect_time_slow");
    SpellData data = new SpellData(event.entity.world);
    data.processEntity(event.entity, false);
    SpellRing ring = new SpellRing(slow);
    ring.getModule().sendRenderPacket(data, ring);
    event.override = true;
    Entity entity = event.entity;
    double amp = effect.getAmplifier();
    double x = event.x / amp;
    double y = event.y / amp;
    double z = event.z / amp;
    MoverType type = event.type;
    if (entity.noClip) {
        entity.setEntityBoundingBox(entity.getEntityBoundingBox().offset(x, y, z));
        entity.resetPositionToBB();
    } else {
        entity.world.profiler.startSection("move");
        double d10 = entity.posX;
        double d11 = entity.posY;
        double d1 = entity.posZ;
        double d2 = x;
        double d3 = y;
        double d4 = z;
        if ((type == MoverType.SELF || type == MoverType.PLAYER) && entity.onGround && entity.isSneaking() && entity instanceof EntityPlayer) {
            for (; x != 0.0D && entity.world.getCollisionBoxes(entity, entity.getEntityBoundingBox().offset(x, (double) (-entity.stepHeight), 0.0D)).isEmpty(); d2 = x) {
                if (x < 0.05D && x >= -0.05D) {
                    x = 0.0D;
                } else if (x > 0.0D) {
                    x -= 0.05D;
                } else {
                    x += 0.05D;
                }
            }
            for (; z != 0.0D && entity.world.getCollisionBoxes(entity, entity.getEntityBoundingBox().offset(0.0D, (double) (-entity.stepHeight), z)).isEmpty(); d4 = z) {
                if (z < 0.05D && z >= -0.05D) {
                    z = 0.0D;
                } else if (z > 0.0D) {
                    z -= 0.05D;
                } else {
                    z += 0.05D;
                }
            }
            for (; x != 0.0D && z != 0.0D && entity.world.getCollisionBoxes(entity, entity.getEntityBoundingBox().offset(x, (double) (-entity.stepHeight), z)).isEmpty(); d4 = z) {
                if (x < 0.05D && x >= -0.05D) {
                    x = 0.0D;
                } else if (x > 0.0D) {
                    x -= 0.05D;
                } else {
                    x += 0.05D;
                }
                d2 = x;
                if (z < 0.05D && z >= -0.05D) {
                    z = 0.0D;
                } else if (z > 0.0D) {
                    z -= 0.05D;
                } else {
                    z += 0.05D;
                }
            }
        }
        List<AxisAlignedBB> list1 = entity.world.getCollisionBoxes(entity, entity.getEntityBoundingBox().offset(x, y, z));
        AxisAlignedBB axisalignedbb = entity.getEntityBoundingBox();
        if (y != 0.0D) {
            int k = 0;
            for (int l = list1.size(); k < l; ++k) {
                y = list1.get(k).calculateYOffset(entity.getEntityBoundingBox(), y);
            }
            entity.setEntityBoundingBox(entity.getEntityBoundingBox().offset(0.0D, y, 0.0D));
        }
        if (x != 0.0D) {
            int j5 = 0;
            for (int l5 = list1.size(); j5 < l5; ++j5) {
                x = list1.get(j5).calculateXOffset(entity.getEntityBoundingBox(), x);
            }
            if (x != 0.0D) {
                entity.setEntityBoundingBox(entity.getEntityBoundingBox().offset(x, 0.0D, 0.0D));
            }
        }
        if (z != 0.0D) {
            int k5 = 0;
            for (int i6 = list1.size(); k5 < i6; ++k5) {
                z = list1.get(k5).calculateZOffset(entity.getEntityBoundingBox(), z);
            }
            if (z != 0.0D) {
                entity.setEntityBoundingBox(entity.getEntityBoundingBox().offset(0.0D, 0.0D, z));
            }
        }
        boolean flag = entity.onGround || d3 != y && d3 < 0.0D;
        if (entity.stepHeight > 0.0F && flag && (d2 != x || d4 != z)) {
            double d14 = x;
            double d6 = y;
            double d7 = z;
            AxisAlignedBB axisalignedbb1 = entity.getEntityBoundingBox();
            entity.setEntityBoundingBox(axisalignedbb);
            y = (double) entity.stepHeight;
            List<AxisAlignedBB> list = entity.world.getCollisionBoxes(entity, entity.getEntityBoundingBox().offset(d2, y, d4));
            AxisAlignedBB axisalignedbb2 = entity.getEntityBoundingBox();
            AxisAlignedBB axisalignedbb3 = axisalignedbb2.offset(d2, 0.0D, d4);
            double d8 = y;
            int j1 = 0;
            for (int k1 = list.size(); j1 < k1; ++j1) {
                d8 = list.get(j1).calculateYOffset(axisalignedbb3, d8);
            }
            axisalignedbb2 = axisalignedbb2.offset(0.0D, d8, 0.0D);
            double d18 = d2;
            int l1 = 0;
            for (int i2 = list.size(); l1 < i2; ++l1) {
                d18 = list.get(l1).calculateXOffset(axisalignedbb2, d18);
            }
            axisalignedbb2 = axisalignedbb2.offset(d18, 0.0D, 0.0D);
            double d19 = d4;
            int j2 = 0;
            for (int k2 = list.size(); j2 < k2; ++j2) {
                d19 = list.get(j2).calculateZOffset(axisalignedbb2, d19);
            }
            axisalignedbb2 = axisalignedbb2.offset(0.0D, 0.0D, d19);
            AxisAlignedBB axisalignedbb4 = entity.getEntityBoundingBox();
            double d20 = y;
            int l2 = 0;
            for (int i3 = list.size(); l2 < i3; ++l2) {
                d20 = list.get(l2).calculateYOffset(axisalignedbb4, d20);
            }
            axisalignedbb4 = axisalignedbb4.offset(0.0D, d20, 0.0D);
            double d21 = d2;
            int j3 = 0;
            for (int k3 = list.size(); j3 < k3; ++j3) {
                d21 = list.get(j3).calculateXOffset(axisalignedbb4, d21);
            }
            axisalignedbb4 = axisalignedbb4.offset(d21, 0.0D, 0.0D);
            double d22 = d4;
            int l3 = 0;
            for (int i4 = list.size(); l3 < i4; ++l3) {
                d22 = list.get(l3).calculateZOffset(axisalignedbb4, d22);
            }
            axisalignedbb4 = axisalignedbb4.offset(0.0D, 0.0D, d22);
            double d23 = d18 * d18 + d19 * d19;
            double d9 = d21 * d21 + d22 * d22;
            if (d23 > d9) {
                x = d18;
                z = d19;
                y = -d8;
                entity.setEntityBoundingBox(axisalignedbb2);
            } else {
                x = d21;
                z = d22;
                y = -d20;
                entity.setEntityBoundingBox(axisalignedbb4);
            }
            int j4 = 0;
            for (int k4 = list.size(); j4 < k4; ++j4) {
                y = list.get(j4).calculateYOffset(entity.getEntityBoundingBox(), y);
            }
            entity.setEntityBoundingBox(entity.getEntityBoundingBox().offset(0.0D, y, 0.0D));
            if (d14 * d14 + d7 * d7 >= x * x + z * z) {
                x = d14;
                y = d6;
                z = d7;
                entity.setEntityBoundingBox(axisalignedbb1);
            }
        }
        entity.world.profiler.endSection();
        entity.world.profiler.startSection("rest");
        entity.resetPositionToBB();
        entity.collidedHorizontally = d2 != x || d4 != z;
        entity.collidedVertically = d3 != y;
        entity.onGround = entity.collidedVertically && d3 < 0.0D;
        entity.collided = entity.collidedHorizontally || entity.collidedVertically;
        int j6 = MathHelper.floor(entity.posX);
        int i1 = MathHelper.floor(entity.posY - 0.20000000298023224D);
        int k6 = MathHelper.floor(entity.posZ);
        BlockPos blockpos = new BlockPos(j6, i1, k6);
        IBlockState iblockstate = entity.world.getBlockState(blockpos);
        if (iblockstate.getMaterial() == Material.AIR) {
            BlockPos blockpos1 = blockpos.down();
            IBlockState iblockstate1 = entity.world.getBlockState(blockpos1);
            Block block1 = iblockstate1.getBlock();
            if (block1 instanceof BlockFence || block1 instanceof BlockWall || block1 instanceof BlockFenceGate) {
                iblockstate = iblockstate1;
                blockpos = blockpos1;
            }
        }
        if (d2 != x) {
            entity.motionX = 0.0D;
        }
        if (d4 != z) {
            entity.motionZ = 0.0D;
        }
        Block block = iblockstate.getBlock();
        if (d3 != y) {
            block.onLanded(entity.world, entity);
        }
        if ((!entity.onGround || !entity.isSneaking() || !(entity instanceof EntityPlayer)) && !entity.isRiding()) {
            double d15 = entity.posX - d10;
            double d16 = entity.posY - d11;
            double d17 = entity.posZ - d1;
            if (block != Blocks.LADDER) {
                d16 = 0.0D;
            }
            if (block != null && entity.onGround) {
                block.onEntityWalk(entity.world, blockpos, entity);
            }
            entity.distanceWalkedModified = (float) ((double) entity.distanceWalkedModified + (double) MathHelper.sqrt(d15 * d15 + d17 * d17) * 0.6D);
            entity.distanceWalkedOnStepModified = (float) ((double) entity.distanceWalkedOnStepModified + (double) MathHelper.sqrt(d15 * d15 + d16 * d16 + d17 * d17) * 0.6D);
        }
        try {
            AxisAlignedBB bb = entity.getEntityBoundingBox();
            BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos = BlockPos.PooledMutableBlockPos.retain(bb.minX + 0.001D, bb.minY + 0.001D, bb.minZ + 0.001D);
            BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos1 = BlockPos.PooledMutableBlockPos.retain(bb.maxX - 0.001D, bb.maxY - 0.001D, bb.maxZ - 0.001D);
            BlockPos.PooledMutableBlockPos blockpos$pooledmutableblockpos2 = BlockPos.PooledMutableBlockPos.retain();
            if (entity.world.isAreaLoaded(blockpos$pooledmutableblockpos, blockpos$pooledmutableblockpos1)) {
                for (int i = blockpos$pooledmutableblockpos.getX(); i <= blockpos$pooledmutableblockpos1.getX(); ++i) {
                    for (int j = blockpos$pooledmutableblockpos.getY(); j <= blockpos$pooledmutableblockpos1.getY(); ++j) {
                        for (int k = blockpos$pooledmutableblockpos.getZ(); k <= blockpos$pooledmutableblockpos1.getZ(); ++k) {
                            blockpos$pooledmutableblockpos2.setPos(i, j, k);
                            IBlockState state = entity.world.getBlockState(blockpos$pooledmutableblockpos2);
                            try {
                                state.getBlock().onEntityCollidedWithBlock(entity.world, blockpos$pooledmutableblockpos2, state, entity);
                            } catch (Throwable throwable) {
                                CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Colliding entity with block");
                                CrashReportCategory crashreportcategory = crashreport.makeCategory("Block being collided with");
                                CrashReportCategory.addBlockInfo(crashreportcategory, blockpos$pooledmutableblockpos2, state);
                                throw new ReportedException(crashreport);
                            }
                        }
                    }
                }
            }
            blockpos$pooledmutableblockpos.release();
            blockpos$pooledmutableblockpos1.release();
            blockpos$pooledmutableblockpos2.release();
        } catch (Throwable throwable) {
            CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Checking entity block collision");
            CrashReportCategory crashreportcategory = crashreport.makeCategory("Entity being checked for collision");
            entity.addEntityCrashInfo(crashreportcategory);
            throw new ReportedException(crashreport);
        }
        entity.world.profiler.endSection();
    }
}