All checks were successful
continuous-integration/drone/push Build is passing
section to the installer. UPDATE REQUIRED, even if you aren't gonna use shaders.
194 lines
6.8 KiB
JavaScript
194 lines
6.8 KiB
JavaScript
global.temperatures = {
|
|
'minecraft:blue_ice': 200,
|
|
'minecraft:ice': 260,
|
|
'minecraft:magma_block': 1300,
|
|
'minecraft:packed_ice': 240,
|
|
'minecraft:snow': 273,
|
|
}
|
|
|
|
global.cobblegen = {
|
|
'getSlots': (be) => {
|
|
let iih = be.getCapability(ForgeCapabilities.ITEM_HANDLER, Direction.NORTH).orElse(null);
|
|
return iih.getSlots();
|
|
},
|
|
'serverTick': (quantity) => (be) => {
|
|
let count = be.persistentData.getInt('count')
|
|
be.persistentData.putInt('count', Math.min(count + quantity, global.cobblegen.getSlots(be) * 64))
|
|
},
|
|
'tiers': ['andesite_alloy', 'brass'],
|
|
'getStackInSlot': (be, slot) => {
|
|
if (slot > global.cobblegen.getSlots(be)) return Item.getEmpty();
|
|
|
|
let count = be.persistentData.getInt('count');
|
|
let offset = (slot - 1) * 64;
|
|
|
|
if (count <= offset) return Item.getEmpty();
|
|
|
|
return Item.of('minecraft:cobblestone').withCount(Math.min(count - offset, 64))
|
|
},
|
|
'insertItem': (be, slot, stack, simulate) => {
|
|
return false;
|
|
},
|
|
'extractItem': (be, slot, amount, simulate) => {
|
|
if (slot > global.cobblegen.getSlots(be)) return Item.getEmpty();
|
|
|
|
let count = be.persistentData.getInt('count');
|
|
let offset = (slot - 1) * 64;
|
|
if (count <= offset) return Item.getEmpty();
|
|
|
|
let result = Item.of('minecraft:cobblestone').withCount(Math.min(64, amount, count - offset));
|
|
|
|
if (!simulate) {
|
|
be.persistentData.putInt('count', count - result.getCount())
|
|
}
|
|
|
|
return result;
|
|
},
|
|
'isItemValid': (be, slot, stack) => {
|
|
return ((slot <= global.cobblegen.getSlots(be)) && (stack.areItemsEqual(Item.of('minecraft:cobblestone'))))
|
|
},
|
|
}
|
|
|
|
global.thermoelectricgen = {
|
|
'calculateEnergyOutput': (be) => {
|
|
let energy = 0;
|
|
|
|
let directions = [Direction.DOWN, Direction.NORTH, Direction.WEST];
|
|
|
|
directions.forEach((fd) => {
|
|
let block0 = be.getBlock().offset(fd);
|
|
let block1 = be.getBlock().offset(fd, -1);
|
|
|
|
if (block0.equals('minecraft:air') || block1.equals('minecraft:air')) return;
|
|
|
|
let temp0 = global.thermoelectricgen.getTemperature(block0);
|
|
let temp1 = global.thermoelectricgen.getTemperature(block1);
|
|
|
|
if (temp0 < 0 || temp1 < 0) return;
|
|
|
|
let diff = Math.abs(temp0 - temp1);
|
|
energy += Math.floor(Math.sqrt(diff) * 2.0);
|
|
})
|
|
|
|
return energy;
|
|
},
|
|
'generateEnergy': (be) => {
|
|
let energy = be.persistentData.getInt('energy');
|
|
energy += global.thermoelectricgen.calculateEnergyOutput(be);
|
|
energy = Math.min(energy, 5000);
|
|
be.persistentData.putInt('energy', energy);
|
|
return energy;
|
|
},
|
|
'getTemperature': (block) => {
|
|
let block_id = block.getId();
|
|
|
|
if (Object.keys(global.temperatures).includes(block_id)) {
|
|
return global.temperatures[block_id]
|
|
}
|
|
|
|
let f = block.getBlockState().getFluidState();
|
|
|
|
if (!(f.isEmpty())) {
|
|
return f.getFluidType().getTemperature(f, block.getLevel(), block.getPos());
|
|
}
|
|
return -1;
|
|
},
|
|
'extractEnergy': (be, amount, simulate) => {
|
|
let energy = be.persistentData.getInt('energy');
|
|
let extracted = Math.min(energy, amount)
|
|
if (!simulate) {
|
|
be.persistentData.putInt('energy', energy - extracted)
|
|
}
|
|
return extracted
|
|
},
|
|
'serverTick': (be) => {
|
|
let energy = global.thermoelectricgen.generateEnergy(be);
|
|
|
|
Object.values(Direction.ALL).forEach((side) => {
|
|
let te = be.getBlock().offset(side).getEntity();
|
|
if (te == null) return;
|
|
|
|
let ies = te.getCapability(ForgeCapabilities.ENERGY, side.getOpposite()).orElse(null);
|
|
if (ies == null) return;
|
|
|
|
let amount = ies.receiveEnergy(energy, false);
|
|
energy -= amount;
|
|
})
|
|
|
|
be.persistentData.putInt('energy', energy);
|
|
},
|
|
}
|
|
|
|
StartupEvents.registry('block', (event) => {
|
|
event.create('skapa:sturdy_metal_block')
|
|
.displayName('Sturdy Metal Block')
|
|
.hardness(30.0)
|
|
.soundType('anvil')
|
|
.tagBlock('minecraft:mineable/pickaxe')
|
|
.tagBlock('minecraft:needs_iron_tool')
|
|
.tagBlock('create:wrench_pickup')
|
|
.requiresTool(true)
|
|
.lightLevel(0)
|
|
.textureAll('minecraft:block/smithing_table_top')
|
|
|
|
event.create('skapa:andesite_cobblestone_generator')
|
|
.displayName('Andesite Cobblestone Generator')
|
|
.tagBlock('minecraft:mineable/pickaxe')
|
|
.tagBlock('minecraft:needs_iron_tool')
|
|
.tagBlock('create:wrench_pickup')
|
|
.blockEntity((info) => {
|
|
info.serverTick(20, 0, global.cobblegen.serverTick(4))
|
|
|
|
info.attachCapability(
|
|
CapabilityBuilder.ITEM.blockEntity()
|
|
.getSlots((be) => 8)
|
|
.getStackInSlot(global.cobblegen.getStackInSlot)
|
|
.insertItem(global.cobblegen.insertItem)
|
|
.extractItem(global.cobblegen.extractItem)
|
|
.getSlotLimit((be) => 64)
|
|
.isItemValid(global.cobblegen.isItemValid)
|
|
)
|
|
})
|
|
|
|
event.create('skapa:brass_cobblestone_generator')
|
|
.displayName('Brass Cobblestone Generator')
|
|
.tagBlock('minecraft:mineable/pickaxe')
|
|
.tagBlock('minecraft:needs_iron_tool')
|
|
.tagBlock('create:wrench_pickup')
|
|
.blockEntity((info) => {
|
|
info.serverTick(20, 0, global.cobblegen.serverTick(64))
|
|
|
|
info.attachCapability(
|
|
CapabilityBuilder.ITEM.blockEntity()
|
|
.getSlots((be) => 32)
|
|
.getStackInSlot(global.cobblegen.getStackInSlot)
|
|
.insertItem(global.cobblegen.insertItem)
|
|
.extractItem(global.cobblegen.extractItem)
|
|
.getSlotLimit((be) => 64)
|
|
.isItemValid(global.cobblegen.isItemValid)
|
|
)
|
|
})
|
|
|
|
event.create('skapa:thermoelectric_generator')
|
|
.displayName('Thermoelectric Generator')
|
|
.hardness(15.0)
|
|
.soundType('metal')
|
|
.tagBlock('minecraft:mineable/pickaxe')
|
|
.tagBlock('minecraft:needs_iron_tool')
|
|
.tagBlock('create:wrench_pickup')
|
|
.requiresTool(true)
|
|
.lightLevel(0)
|
|
.blockEntity((info) => {
|
|
info.serverTick(global.thermoelectricgen.serverTick);
|
|
|
|
info.attachCapability(CapabilityBuilder.ENERGY.customBlockEntity()
|
|
.canExtract(() => true)
|
|
.canReceive(() => false)
|
|
.extractEnergy(global.thermoelectricgen.extractEnergy)
|
|
.getEnergyStored((be) => {
|
|
return be.persistentData.getInt('energy')
|
|
})
|
|
.getMaxEnergyStored(() => 5000)
|
|
);
|
|
})
|
|
}) |