mirror of
https://github.com/HbmMods/Hbm-s-Nuclear-Tech-GIT.git
synced 2026-01-25 10:32:49 +00:00
extremely crappy MK5 prototype that i wasted all day on
This commit is contained in:
Bob
parent
42ebdbb3c6
commit
41b980a26a
@ -135,6 +135,7 @@ public class TestBombAdvanced extends BlockContainer {
|
||||
}*/
|
||||
|
||||
world.setBlock(x, y, z, Blocks.air);
|
||||
world.spawnEntityInWorld(EntityNukeExplosionNT.statFacMKV(world, x + 0.5, y + 0.5, z + 0.5, 50));
|
||||
world.spawnEntityInWorld(EntityNukeExplosionNT.statFacMKV(world, x + 0.5, y + 0.5, z + 0.5, 100));
|
||||
//world.spawnEntityInWorld(EntityNukeExplosionMK4.statFacNoRad(world, 50, x, y, z));
|
||||
}
|
||||
}
|
||||
|
||||
@ -125,7 +125,7 @@ public class WorldConfig {
|
||||
barrelStructure = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.12_barrelSpawn", "Spawn waste tank on every nTH chunk", 5000);
|
||||
broadcaster = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.13_broadcasterSpawn", "Spawn corrupt broadcaster on every nTH chunk", 5000);
|
||||
minefreq = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.14_landmineSpawn", "Spawn AP landmine on every nTH chunk", 64);
|
||||
radfreq = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.15_radHotsoptSpawn", "Spawn radiation hotspot on every nTH chunk", 5000);
|
||||
radfreq = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.15_radHotspotSpawn", "Spawn radiation hotspot on every nTH chunk", 5000);
|
||||
vaultfreq = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.16_vaultSpawn", "Spawn locked safe on every nTH chunk", 2500);
|
||||
geyserWater = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.17_geyserWaterSpawn", "Spawn water geyser on every nTH chunk", 3000);
|
||||
geyserChlorine = CommonConfig.createConfigInt(config, CATEGORY_DUNGEON, "4.18_geyserChlorineSpawn", "Spawn poison geyser on every nTH chunk", 3000);
|
||||
|
||||
@ -2,6 +2,7 @@ package com.hbm.entity.logic;
|
||||
|
||||
import com.hbm.explosion.nt.IExplosionLogic;
|
||||
import com.hbm.explosion.nt.Mark5;
|
||||
import com.hbm.explosion.nt.Mark5Ausf2;
|
||||
|
||||
import net.minecraft.entity.Entity;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
@ -22,20 +23,22 @@ public class EntityNukeExplosionNT extends Entity {
|
||||
|
||||
@Override
|
||||
public void onUpdate() {
|
||||
|
||||
if(this.explosion == null || this.explosion.isDone()) {
|
||||
System.out.println(this.ticksExisted + " explosion done.");
|
||||
this.setDead();
|
||||
return;
|
||||
|
||||
if(!worldObj.isRemote) {
|
||||
if(this.explosion == null || this.explosion.isDone()) {
|
||||
System.out.println(this.ticksExisted + " explosion done.");
|
||||
this.setDead();
|
||||
return;
|
||||
}
|
||||
|
||||
this.explosion.updateLogic();
|
||||
}
|
||||
|
||||
this.explosion.updateLogic();
|
||||
}
|
||||
|
||||
public static EntityNukeExplosionNT statFacMKV(World world, double x, double y, double z, float power) {
|
||||
EntityNukeExplosionNT essploshun = new EntityNukeExplosionNT(world);
|
||||
essploshun.setPositionAndRotation(x, y, z, 0, 0);
|
||||
essploshun.loadLogic(new Mark5(world, power, (float) x, (float) y, (float) z));
|
||||
essploshun.loadLogic(new Mark5Ausf2(world, power, (float) x, (float) y, (float) z));
|
||||
return essploshun;
|
||||
}
|
||||
|
||||
|
||||
449
src/main/java/com/hbm/explosion/nt/Mark5Ausf2.java
Normal file
449
src/main/java/com/hbm/explosion/nt/Mark5Ausf2.java
Normal file
@ -0,0 +1,449 @@
|
||||
package com.hbm.explosion.nt;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.init.Blocks;
|
||||
import net.minecraft.util.Vec3;
|
||||
import net.minecraft.world.World;
|
||||
|
||||
public class Mark5Ausf2 implements IExplosionLogic {
|
||||
|
||||
//holds rays after being calculated up to where the blocks get removed
|
||||
private HorizontalSegment[] segments;
|
||||
private HorizontalSegment[] repopulatedSegments;
|
||||
//buffered blocks marked for deletion
|
||||
private Set<BlockPos> buffer = new HashSet();
|
||||
|
||||
private World world;
|
||||
private float strength;
|
||||
float originX;
|
||||
float originY;
|
||||
float originZ;
|
||||
float length;
|
||||
|
||||
//0: calculate blocks to destroy
|
||||
//1: destroy blocks
|
||||
//2: generate new rays
|
||||
int phase = 0;
|
||||
|
||||
public Mark5Ausf2(World world, float strength, float x, float y, float z) {
|
||||
this.world = world;
|
||||
this.strength = strength;
|
||||
this.originX = x;
|
||||
this.originY = y;
|
||||
this.originZ = z;
|
||||
|
||||
this.initRays();
|
||||
}
|
||||
|
||||
private double getResolutionMult() {
|
||||
return 5D;
|
||||
}
|
||||
|
||||
private void initRays() {
|
||||
|
||||
this.length = 5F; //how long the current rays are
|
||||
|
||||
double bow = length * Math.PI; //one "bow", the distance between the poles along the circumference ( U/2 )
|
||||
int bowCount = (int) Math.ceil(bow * getResolutionMult()); //how many segments we want along one bow, usually 1 per block + a resolution multiplier
|
||||
double bowDelta = (Math.PI / (double) (bowCount - 1)); //the angular difference (pitch) between where each segment is
|
||||
|
||||
segments = new HorizontalSegment[bowCount];
|
||||
|
||||
for(int i = 0; i < bowCount; i++) {
|
||||
double currBow = bowDelta * i; //the current angle along the bow (i.e. the pitch of the horizontal ring)
|
||||
double ringRadius = Math.sin(currBow) * length; //the radius of the current ring
|
||||
double ringCircumference = 2D * ringRadius * Math.PI; //the circumference for the ring
|
||||
int ringCount = (int) Math.max(Math.ceil(ringCircumference * getResolutionMult()), 1); //how many rays we want per ring (1 per block plus extra resolution)
|
||||
double ringDelta = ((Math.PI * 2D) / (double) (ringCount - 1)); //the angular difference (yaw) between rays in a ring
|
||||
|
||||
HorizontalSegment seg = new HorizontalSegment(ringCount);
|
||||
float pitch = (float) currBow;
|
||||
|
||||
for(int j = 0; j < ringCount; j++) {
|
||||
float yaw = (float)(ringDelta * j);
|
||||
|
||||
//if(yaw < Math.PI * 0.5 && pitch < Math.PI)
|
||||
seg.rays[j] = new MVRay(strength, originX, originY, originZ, yaw, pitch, length);
|
||||
}
|
||||
|
||||
segments[i] = seg;
|
||||
}
|
||||
|
||||
/*System.out.println("Initialized with" + segments.length + " segments!");
|
||||
|
||||
for(HorizontalSegment seg : segments) {
|
||||
|
||||
if(seg == null) {
|
||||
System.out.println("NULL");
|
||||
} else {
|
||||
System.out.println(seg.rays.length);
|
||||
}
|
||||
}*/
|
||||
System.out.println("STOP");
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateLogic() {
|
||||
|
||||
switch(this.phase) {
|
||||
case 0: processRays(50000); break;
|
||||
case 1: breakBlocks(2000); break;
|
||||
case 2: repopulate(); break;
|
||||
}
|
||||
}
|
||||
|
||||
private int processBow = 0;
|
||||
private int processRing = 0;
|
||||
|
||||
private void endPhaseZero() {
|
||||
this.processBow = 0;
|
||||
this.processRing = 0;
|
||||
this.phase = 1;
|
||||
System.out.println("Ending phase 0");
|
||||
}
|
||||
|
||||
private void processRays(int amount) {
|
||||
|
||||
while(true) {
|
||||
|
||||
if(amount < 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if(this.segments[processBow] == null || this.processRing >= this.segments[processBow].rays.length) {
|
||||
this.processRing = 0;
|
||||
this.processBow++;
|
||||
|
||||
if(this.processBow >= this.segments.length) {
|
||||
endPhaseZero();
|
||||
return;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if(this.processBow >= this.segments.length) {
|
||||
endPhaseZero();
|
||||
return;
|
||||
}
|
||||
|
||||
MVRay ray = this.segments[processBow].rays[this.processRing];
|
||||
|
||||
if(ray != null) {
|
||||
|
||||
Vec3 vec = Vec3.createVectorHelper(1, 0, 0);
|
||||
vec.rotateAroundZ(ray.pitch);
|
||||
vec.rotateAroundY(ray.yaw);
|
||||
|
||||
double finalX = 0;
|
||||
double finalY = 0;
|
||||
double finalZ = 0;
|
||||
|
||||
for(float i = 0; i < ray.length; i += 0.5F) {
|
||||
|
||||
finalX = ray.x + vec.xCoord * i;
|
||||
finalY = ray.y + vec.yCoord * i;
|
||||
finalZ = ray.z + vec.zCoord * i;
|
||||
int x = (int)Math.floor(finalX);
|
||||
int y = (int)Math.floor(finalY);
|
||||
int z = (int)Math.floor(finalZ);
|
||||
|
||||
//System.out.println(ray.pitch + " " + ray.yaw + " / " + x + " " + y + " " + z);
|
||||
|
||||
BlockPos pos = new BlockPos(x, y, z);
|
||||
|
||||
if(y > 255 || y < 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
Block b = world.getBlock(x, y, z);
|
||||
|
||||
float res = (b.getMaterial().isLiquid() ? (float)Math.pow(Blocks.air.getExplosionResistance(null), 1.25) : (float)Math.pow(b.getExplosionResistance(null), 1.25));
|
||||
|
||||
ray.power -= res;
|
||||
|
||||
if(ray.power <= 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
if(b != Blocks.air)
|
||||
this.buffer.add(pos);
|
||||
}
|
||||
|
||||
if(ray.power <= 0 || finalY < 0 || finalY > 255 || this.length > this.strength) {
|
||||
this.segments[processBow].rays[this.processRing] = null;
|
||||
}
|
||||
ray.x = (float) finalX;
|
||||
ray.y = (float) finalY;
|
||||
ray.z = (float) finalZ;
|
||||
}
|
||||
|
||||
amount--;
|
||||
this.processRing++;
|
||||
}
|
||||
}
|
||||
|
||||
private void breakBlocks(int amount) {
|
||||
|
||||
if(this.phase == 1 && this.buffer.isEmpty()) {
|
||||
this.phase = 2;
|
||||
System.out.println("Ending phase 1");
|
||||
return;
|
||||
}
|
||||
|
||||
int rem = 0;
|
||||
|
||||
List<BlockPos> toRem = new ArrayList();
|
||||
|
||||
for(BlockPos pos : this.buffer) {
|
||||
world.setBlock(pos.x, pos.y, pos.z, Blocks.air, 0, 3);
|
||||
|
||||
toRem.add(pos);
|
||||
rem++;
|
||||
|
||||
if(rem == amount)
|
||||
break;
|
||||
}
|
||||
|
||||
this.buffer.removeAll(toRem);
|
||||
|
||||
if(this.buffer.isEmpty()) {
|
||||
this.phase = 2;
|
||||
System.out.println("Ending phase 1");
|
||||
}
|
||||
}
|
||||
|
||||
private void repopulate() {
|
||||
|
||||
boolean didYouDoLiterallyAnything = false;
|
||||
this.length += 5;
|
||||
|
||||
double bow = length * Math.PI;
|
||||
int bowCount = (int) Math.ceil(bow * getResolutionMult());
|
||||
double bowDelta = (Math.PI / (double) (bowCount - 1));
|
||||
|
||||
repopulatedSegments = new HorizontalSegment[bowCount];
|
||||
|
||||
for(int i = 0; i < bowCount; i++) {
|
||||
|
||||
double currBow = bowDelta * i;
|
||||
double ringRadius = Math.sin(currBow) * length;
|
||||
double ringCircumference = 2D * ringRadius * Math.PI;
|
||||
int ringCount = (int) Math.max(Math.ceil(ringCircumference * getResolutionMult()), 1);
|
||||
double ringDelta = ((Math.PI * 2D) / (double) (ringCount - 1));
|
||||
|
||||
float pitch = (float) currBow;
|
||||
HorizontalSegment parentSegment = fromAngle(pitch);
|
||||
|
||||
if(parentSegment != null) {
|
||||
|
||||
HorizontalSegment seg = new HorizontalSegment(ringCount);
|
||||
|
||||
for(int j = 0; j < ringCount; j++) {
|
||||
float yaw = (float)(ringDelta * j);
|
||||
|
||||
MVRay parentRay = parentSegment.fromAngle(yaw);
|
||||
|
||||
if(parentRay != null && parentRay.power > 0) {
|
||||
|
||||
/*Vec3 newDest = Vec3.createVectorHelper(length, 0D, 0D);
|
||||
newDest.rotateAroundZ(pitch);
|
||||
newDest.rotateAroundY(yaw);
|
||||
Vec3 delta = Vec3.createVectorHelper(newDest.xCoord - parentRay.x, newDest.yCoord - parentRay.y, newDest.zCoord - parentRay.z);
|
||||
|
||||
double deltaLen = delta.lengthVector();
|
||||
float pLen = parentRay.length;
|
||||
|
||||
double s_deltaLen = Math.sqrt(delta.xCoord * delta.xCoord + delta.yCoord * delta.yCoord);
|
||||
double s_alpha0 = parentRay.pitch;
|
||||
double s_delta = Math.acos((pLen * pLen + s_deltaLen * s_deltaLen - length * length) / (2 * pLen * s_deltaLen));
|
||||
double newPitch = s_alpha0 + (Math.PI - s_delta);
|
||||
|
||||
double r_deltaLen = Math.sqrt(delta.xCoord * delta.xCoord + delta.zCoord * delta.zCoord);
|
||||
double r_alpha0 = parentRay.yaw;
|
||||
double r_delta = Math.acos((pLen * pLen + r_deltaLen * r_deltaLen - length * length) / (2 * pLen * r_deltaLen));
|
||||
double newYaw = r_alpha0 + (Math.PI - r_delta);*/
|
||||
|
||||
/*System.out.println("deltaLen: " + deltaLen);
|
||||
System.out.println("pLen: " + pLen);
|
||||
System.out.println("s_deltaLen: " + s_deltaLen);
|
||||
System.out.println("s_alpha0: " + s_alpha0);
|
||||
System.out.println("s_delta: " + s_delta);
|
||||
System.out.println("newPitch: " + newPitch);
|
||||
System.out.println("r_deltaLen: " + r_deltaLen);
|
||||
System.out.println("r_alpha0: " + r_alpha0);
|
||||
System.out.println("r_delta: " + r_delta);
|
||||
System.out.println("newYaw: " + newYaw);*/
|
||||
/*System.out.println("(pLen * pLen + s_deltaLen * s_deltaLen - length * length) / (2 * pLen * s_deltaLen)");
|
||||
System.out.println("" + (pLen * pLen + s_deltaLen * s_deltaLen - length * length) / (2 * pLen * s_deltaLen));
|
||||
System.out.println("(pLen * pLen + r_deltaLen * r_deltaLen - length * length) / (2 * pLen * r_deltaLen)");
|
||||
System.out.println("" + (pLen * pLen + r_deltaLen * r_deltaLen - length * length) / (2 * pLen * r_deltaLen));*/
|
||||
|
||||
Vec3 len = Vec3.createVectorHelper(parentRay.x - originX, parentRay.y - originY, parentRay.z - originZ);
|
||||
double totalLen = len.lengthVector();
|
||||
Vec3 normal = Vec3.createVectorHelper(totalLen, 0D, 0D);
|
||||
normal.rotateAroundZ(pitch);
|
||||
normal.rotateAroundY(yaw);
|
||||
|
||||
//double surface = 4 * Math.PI * this.length * this.length;
|
||||
//double prevSurface = 4 * Math.PI * totalLen * totalLen;
|
||||
float newPower = parentRay.power;
|
||||
|
||||
MVRay newRay = new MVRay(newPower,
|
||||
(float)(this.originX - normal.xCoord),
|
||||
(float)(this.originY - normal.yCoord),
|
||||
(float)(this.originZ - normal.zCoord),
|
||||
yaw, pitch, (float) (this.length - totalLen));
|
||||
|
||||
seg.rays[j] = newRay;
|
||||
repopulatedSegments[i] = seg;
|
||||
didYouDoLiterallyAnything = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.segments = this.repopulatedSegments;
|
||||
this.repopulatedSegments = null;
|
||||
|
||||
System.out.println("Ending phase 2");
|
||||
|
||||
System.out.println("Initialized with" + segments.length + " segments!");
|
||||
|
||||
/*for(HorizontalSegment seg : segments) {
|
||||
|
||||
if(seg == null) {
|
||||
System.out.println("NULL");
|
||||
} else {
|
||||
System.out.println(seg.rays.length);
|
||||
}
|
||||
}
|
||||
System.out.println("STOP");*/
|
||||
|
||||
this.phase = 0;
|
||||
|
||||
if(!didYouDoLiterallyAnything) {
|
||||
System.out.println("Done!");
|
||||
this.isDone = true;
|
||||
}
|
||||
}
|
||||
|
||||
private HorizontalSegment fromAngle(float pitch) {
|
||||
int size = this.segments.length;
|
||||
int index = (int)Math.floor((pitch * size) / Math.PI) % this.segments.length;
|
||||
|
||||
if(index >= this.segments.length || index < 0)
|
||||
return null;
|
||||
|
||||
return this.segments[index];
|
||||
}
|
||||
|
||||
private boolean isDone = false;
|
||||
|
||||
@Override
|
||||
public boolean isDone() {
|
||||
return isDone;
|
||||
}
|
||||
|
||||
public static class HorizontalSegment {
|
||||
|
||||
MVRay[] rays;
|
||||
|
||||
private HorizontalSegment(int size) {
|
||||
rays = new MVRay[size];
|
||||
}
|
||||
|
||||
private MVRay fromAngle(float yaw) {
|
||||
int size = rays.length;
|
||||
int index = (int)Math.floor((yaw * size) / (Math.PI * 2)) % this.rays.length;
|
||||
|
||||
if(index >= this.rays.length || index < 0)
|
||||
return null;
|
||||
|
||||
return rays[index];
|
||||
}
|
||||
}
|
||||
|
||||
public static class MVRay {
|
||||
|
||||
//initiated with starting power, once processed it shows the power left
|
||||
float power;
|
||||
//once calculated, this becomes true
|
||||
boolean collected = false;
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
float yaw;
|
||||
float pitch;
|
||||
float length;
|
||||
boolean tracked;
|
||||
|
||||
public MVRay(float power, float x, float y, float z, float yaw, float pitch, float length) {
|
||||
this.power = power;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
this.yaw = yaw;
|
||||
this.pitch = pitch;
|
||||
this.length = length;
|
||||
}
|
||||
|
||||
public MVRay(float power, float x, float y, float z, Vec3 dir, float length) {
|
||||
|
||||
double len = dir.lengthVector();
|
||||
|
||||
float yaw = (float)Math.atan2(dir.zCoord, dir.xCoord);
|
||||
float pitch = (float)Math.asin(dir.yCoord / len);
|
||||
|
||||
this.power = power;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
this.yaw = yaw;
|
||||
this.pitch = pitch;
|
||||
this.length = length;
|
||||
}
|
||||
}
|
||||
|
||||
public static class BlockPos {
|
||||
|
||||
int x;
|
||||
int y;
|
||||
int z;
|
||||
|
||||
public BlockPos(int x, int y, int z) {
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
result = prime * result + x;
|
||||
result = prime * result + y;
|
||||
result = prime * result + z;
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
|
||||
if(this == obj) return true;
|
||||
if(obj == null) return false;
|
||||
if(getClass() != obj.getClass()) return false;
|
||||
|
||||
BlockPos other = (BlockPos) obj;
|
||||
if(x != other.x) return false;
|
||||
if(y != other.y) return false;
|
||||
if(z != other.z) return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -117,26 +117,26 @@ public class SILEXRecipes {
|
||||
// LEP //
|
||||
recipes.put(new ComparableStack(ModItems.rbmk_pellet_lep, 1, i), new SILEXRecipe(600, 100)
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nugget_plutonium_fuel), 90 - i * 15))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 7 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 3 + 5 * i)) );
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 7 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 3 + 5 * i)) );
|
||||
|
||||
recipes.put(new ComparableStack(ModItems.rbmk_pellet_lep, 1, i + 5), new SILEXRecipe(600, 100)
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.powder_xe135_tiny), 1))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nugget_plutonium_fuel), 89 - i * 15))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 7 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 3 + 5 * i)) );
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 7 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 3 + 5 * i)) );
|
||||
|
||||
// MEP //
|
||||
recipes.put(new ComparableStack(ModItems.rbmk_pellet_mep, 1, i), new SILEXRecipe(600, 100)
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nugget_plutonium_fuel), 85 - i * 20))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 10 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 5 + 5 * i)) );
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 10 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 5 + 5 * i)) );
|
||||
|
||||
recipes.put(new ComparableStack(ModItems.rbmk_pellet_mep, 1, i + 5), new SILEXRecipe(600, 100)
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.powder_xe135_tiny), 1))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nugget_pu_mix), 84 - i * 20))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 10 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_long_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 5 + 5 * i)) );
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM239.ordinal()), 10 + 10 * i))
|
||||
.addOut(new WeightedRandomObject(new ItemStack(ModItems.nuclear_waste_short_tiny, 1, ItemWasteShort.WasteClass.PLUTONIUM240.ordinal()), 5 + 5 * i)) );
|
||||
|
||||
// HEP239 //
|
||||
recipes.put(new ComparableStack(ModItems.rbmk_pellet_hep239, 1, i), new SILEXRecipe(600, 100)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user