From cbbe4ecb5e05c48e552119e6036f58e23b889800 Mon Sep 17 00:00:00 2001 From: Calclavia Date: Mon, 24 Feb 2014 22:54:52 +0800 Subject: [PATCH] Initial work on Quantum Gate --- .../electrical/Electrical.java | 12 ++ .../electrical/tesla/TileTesla.java | 141 ++++++++------- .../quantum/gate/BlockGlyph.java | 55 ++++++ .../quantum/gate/BlockQuantumGate.java | 125 ++++++++++++++ .../quantum/gate/QuantumGateManager.java | 108 ++++++++++++ .../quantum/gate/TileQuantumGate.java | 163 ++++++++++++++++++ .../languages/en_US.properties | 7 + .../textures/blocks/glyph_0.png | Bin 0 -> 971 bytes .../textures/blocks/glyph_1.png | Bin 0 -> 853 bytes .../textures/blocks/glyph_2.png | Bin 0 -> 957 bytes .../textures/blocks/quantumGate.png | Bin 0 -> 1317 bytes 11 files changed, 540 insertions(+), 71 deletions(-) create mode 100644 electrical/src/main/java/resonantinduction/quantum/gate/BlockGlyph.java create mode 100644 electrical/src/main/java/resonantinduction/quantum/gate/BlockQuantumGate.java create mode 100644 electrical/src/main/java/resonantinduction/quantum/gate/QuantumGateManager.java create mode 100644 electrical/src/main/java/resonantinduction/quantum/gate/TileQuantumGate.java create mode 100644 src/main/resources/assets/resonantinduction/textures/blocks/glyph_0.png create mode 100644 src/main/resources/assets/resonantinduction/textures/blocks/glyph_1.png create mode 100644 src/main/resources/assets/resonantinduction/textures/blocks/glyph_2.png create mode 100644 src/main/resources/assets/resonantinduction/textures/blocks/quantumGate.png diff --git a/electrical/src/main/java/resonantinduction/electrical/Electrical.java b/electrical/src/main/java/resonantinduction/electrical/Electrical.java index d298d597..c35bdee0 100644 --- a/electrical/src/main/java/resonantinduction/electrical/Electrical.java +++ b/electrical/src/main/java/resonantinduction/electrical/Electrical.java @@ -29,8 +29,12 @@ import resonantinduction.electrical.tesla.TileTesla; import resonantinduction.electrical.transformer.ItemTransformer; import resonantinduction.electrical.wire.EnumWireMaterial; import resonantinduction.electrical.wire.ItemWire; +import resonantinduction.quantum.gate.BlockGlyph; +import resonantinduction.quantum.gate.BlockQuantumGate; +import resonantinduction.quantum.gate.TileQuantumGate; import calclavia.lib.content.ContentRegistry; import calclavia.lib.network.PacketHandler; +import calclavia.lib.prefab.item.ItemBlockMetadata; import calclavia.lib.recipe.UniversalRecipe; import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.Mod; @@ -89,6 +93,10 @@ public class Electrical public static Block blockArmbot; public static Item itemDisk; + // Quantum + public static Block blockGlyph; + public static Block blockQuantumGate; + @EventHandler public void preInit(FMLPreInitializationEvent evt) { @@ -115,6 +123,10 @@ public class Electrical blockGenerator = contentRegistry.createTile(BlockGenerator.class, TileGenerator.class); blockThermopile = contentRegistry.createTile(BlockThermopile.class, TileThermopile.class); + // Quantum + blockGlyph = contentRegistry.createBlock(BlockGlyph.class, ItemBlockMetadata.class); + blockQuantumGate = contentRegistry.createTile(BlockQuantumGate.class, TileQuantumGate.class); + Settings.save(); OreDictionary.registerOre("wire", itemWire); diff --git a/electrical/src/main/java/resonantinduction/electrical/tesla/TileTesla.java b/electrical/src/main/java/resonantinduction/electrical/tesla/TileTesla.java index e8f499c6..cf57a539 100644 --- a/electrical/src/main/java/resonantinduction/electrical/tesla/TileTesla.java +++ b/electrical/src/main/java/resonantinduction/electrical/tesla/TileTesla.java @@ -9,6 +9,7 @@ import java.util.Comparator; import java.util.EnumSet; import java.util.HashSet; import java.util.List; +import java.util.PriorityQueue; import java.util.Set; import net.minecraft.entity.EntityLivingBase; @@ -24,6 +25,8 @@ import resonantinduction.core.Reference; import resonantinduction.core.ResonantInduction; import resonantinduction.core.Settings; import resonantinduction.electrical.Electrical; +import resonantinduction.mechanical.fluid.transport.TileGrate; +import resonantinduction.mechanical.fluid.transport.TileGrate.ComparableVector; import universalelectricity.api.energy.EnergyStorageHandler; import universalelectricity.api.vector.Vector3; import universalelectricity.api.vector.VectorWorld; @@ -144,36 +147,7 @@ public class TileTesla extends TileElectrical implements IMultiBlockStructure transferTeslaCoils = new ArrayList(); - - for (ITesla teslaReceiver : TeslaGrid.instance().get()) - { - if (new Vector3((TileEntity) teslaReceiver).distance(new Vector3(this)) < this.getRange()) - { - if (teslaReceiver instanceof TileTesla) - { - if (((TileTesla) teslaReceiver).getHeight() <= 1) - { - continue; - } - - teslaReceiver = ((TileTesla) teslaReceiver).getMultiBlock().get(); - } - - /** - * Make sure Tesla is not part of this tower. - */ - if (!this.connectedTeslas.contains(teslaReceiver) && teslaReceiver.canTeslaTransfer(this)) - { - transferTeslaCoils.add(teslaReceiver); - } - } - } - - /** - * Sort by distance. - */ - Collections.sort(transferTeslaCoils, new Comparator() + PriorityQueue teslaToTransfer = new PriorityQueue(1024, new Comparator() { public int compare(ITesla o1, ITesla o2) { @@ -199,55 +173,80 @@ public class TileTesla extends TileElectrical implements IMultiBlockStructure 0) + for (ITesla teslaReceiver : TeslaGrid.instance().get()) { - long transferEnergy = this.energy.getEnergy() / transferTeslaCoils.size(); - int count = 0; - boolean sentPacket = false; - for (ITesla tesla : transferTeslaCoils) + if (new Vector3((TileEntity) teslaReceiver).distance(new Vector3(this)) < this.getRange() && teslaReceiver != this) { - if (this.zapCounter % 5 == 0 && Settings.SOUND_FXS) + if (teslaReceiver instanceof TileTesla) { - this.worldObj.playSoundEffect(this.xCoord + 0.5, this.yCoord + 0.5, this.zCoord + 0.5, Reference.PREFIX + "electricshock", (float) this.energy.getEnergy() / (float) TRANSFER_CAP, 1.3f - 0.5f * (this.dyeID / 16f)); - } - - Vector3 targetVector = new Vector3((TileEntity) tesla); - - if (tesla instanceof TileTesla) - { - getMultiBlock().get().outputBlacklist.add(this); - targetVector = new Vector3(((TileTesla) tesla).getTopTelsa()); - } - - double distance = topTeslaVector.distance(targetVector); - - Electrical.proxy.renderElectricShock(this.worldObj, new Vector3(topTesla).translate(new Vector3(0.5)), targetVector.translate(new Vector3(0.5)), EnumColor.DYES[this.dyeID].toColor()); - - this.transfer(tesla, Math.min(transferEnergy, TRANSFER_CAP)); - - if (!sentPacket && transferEnergy > 0) - { - this.sendPacket(3); - } - - if (this.attackEntities && this.zapCounter % 5 == 0) - { - MovingObjectPosition mop = topTeslaVector.clone().translate(0.5).rayTraceEntities(this.worldObj, targetVector.clone().translate(0.5)); - - if (mop != null && mop.entityHit != null) + if (((TileTesla) teslaReceiver).getHeight() <= 1) { - if (mop.entityHit instanceof EntityLivingBase) + continue; + } + + teslaReceiver = ((TileTesla) teslaReceiver).getMultiBlock().get(); + } + + /** + * Make sure Tesla is not part of this tower. + */ + if (!this.connectedTeslas.contains(teslaReceiver) && teslaReceiver.canTeslaTransfer(this)) + { + teslaToTransfer.add(teslaReceiver); + } + } + } + + if (teslaToTransfer.size() > 0) + { + long transferEnergy = this.energy.getEnergy() / teslaToTransfer.size(); + + boolean sentPacket = false; + + for (int count = 0; count < 10; count++) + { + if (!teslaToTransfer.isEmpty()) + { + ITesla tesla = teslaToTransfer.poll(); + + if (this.zapCounter % 5 == 0 && Settings.SOUND_FXS) + { + this.worldObj.playSoundEffect(this.xCoord + 0.5, this.yCoord + 0.5, this.zCoord + 0.5, Reference.PREFIX + "electricshock", (float) this.energy.getEnergy() / (float) TRANSFER_CAP, 1.3f - 0.5f * (this.dyeID / 16f)); + } + + Vector3 targetVector = new Vector3((TileEntity) tesla); + + if (tesla instanceof TileTesla) + { + getMultiBlock().get().outputBlacklist.add(this); + targetVector = new Vector3(((TileTesla) tesla).getTopTelsa()); + } + + double distance = topTeslaVector.distance(targetVector); + + Electrical.proxy.renderElectricShock(this.worldObj, new Vector3(topTesla).translate(new Vector3(0.5)), targetVector.translate(new Vector3(0.5)), EnumColor.DYES[this.dyeID].toColor()); + + this.transfer(tesla, Math.min(transferEnergy, TRANSFER_CAP)); + + if (!sentPacket && transferEnergy > 0) + { + this.sendPacket(3); + } + + if (this.attackEntities && this.zapCounter % 5 == 0) + { + MovingObjectPosition mop = topTeslaVector.clone().translate(0.5).rayTraceEntities(this.worldObj, targetVector.clone().translate(0.5)); + + if (mop != null && mop.entityHit != null) { - mop.entityHit.attackEntityFrom(CustomDamageSource.electrocution, 4); - Electrical.proxy.renderElectricShock(this.worldObj, new Vector3(topTesla).clone().translate(0.5), new Vector3(mop.entityHit)); + if (mop.entityHit instanceof EntityLivingBase) + { + mop.entityHit.attackEntityFrom(CustomDamageSource.electrocution, 4); + Electrical.proxy.renderElectricShock(this.worldObj, new Vector3(topTesla).clone().translate(0.5), new Vector3(mop.entityHit)); + } } } } - - if (count++ > 1) - { - break; - } } } } diff --git a/electrical/src/main/java/resonantinduction/quantum/gate/BlockGlyph.java b/electrical/src/main/java/resonantinduction/quantum/gate/BlockGlyph.java new file mode 100644 index 00000000..c7d63d2e --- /dev/null +++ b/electrical/src/main/java/resonantinduction/quantum/gate/BlockGlyph.java @@ -0,0 +1,55 @@ +package resonantinduction.quantum.gate; + +import java.util.List; + +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.ItemStack; +import net.minecraft.util.Icon; +import resonantinduction.core.Reference; +import calclavia.lib.prefab.block.BlockAdvanced; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class BlockGlyph extends BlockAdvanced +{ + public static final int MAX_GLYPH = 4; + public static final Icon[] icons = new Icon[MAX_GLYPH]; + + public BlockGlyph(int id) + { + super(id, Material.iron); + setHardness(32F); + setResistance(1000F); + } + + @Override + @SideOnly(Side.CLIENT) + public Icon getIcon(int side, int meta) + { + return icons[meta]; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IconRegister register) + { + for (int i = 0; i < icons.length; i++) + { + icons[i] = register.registerIcon(Reference.PREFIX + "glyph_" + i); + } + + this.blockIcon = icons[0]; + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List) + { + for (int i = 0; i < icons.length; i++) + { + par3List.add(new ItemStack(par1, 1, i)); + } + } +} diff --git a/electrical/src/main/java/resonantinduction/quantum/gate/BlockQuantumGate.java b/electrical/src/main/java/resonantinduction/quantum/gate/BlockQuantumGate.java new file mode 100644 index 00000000..567f4013 --- /dev/null +++ b/electrical/src/main/java/resonantinduction/quantum/gate/BlockQuantumGate.java @@ -0,0 +1,125 @@ +package resonantinduction.quantum.gate; + +import java.util.Random; + +import resonantinduction.core.ResonantInduction; +import resonantinduction.electrical.Electrical; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Icon; +import net.minecraft.world.World; +import net.minecraftforge.common.ForgeDirection; +import calclavia.lib.prefab.block.BlockTile; +import calclavia.lib.utility.LanguageUtility; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class BlockQuantumGate extends BlockTile +{ + public Icon iconTop, iconSide, iconBot; + + public BlockQuantumGate(int id) + { + super(id, Material.iron); + this.setHardness(32F); + this.setResistance(1000F); + } + + /** A randomly called display update to be able to add particles or other items for display */ + @Override + @SideOnly(Side.CLIENT) + public void randomDisplayTick(World world, int x, int y, int z, Random par5Random) + { + TileEntity tile = world.getBlockTileEntity(x, y, z); + + if (tile instanceof TileQuantumGate) + { + int frequency = ((TileQuantumGate) tile).getFrequency(); + + if (frequency != -1) + { + /** + * Spawn particles all around the pillar + */ + + for (int height = 0; height < 4; height++) + { + for (int i = 2; i < 6; i++) + { + ForgeDirection dir = ForgeDirection.getOrientation(i); + double spawnX = x + 0.5f + dir.offsetX; + double spawnY = y + 0.255f + par5Random.nextFloat() * 0.25f - height; + double spawnZ = z + 0.5f + dir.offsetZ; + double xRand = par5Random.nextFloat() * 0.6F - 0.3F; + double zRand = par5Random.nextFloat() * 0.6F - 0.3F; + + world.spawnParticle("enchantmenttable", spawnX + xRand, spawnY, spawnZ + zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + world.spawnParticle("enchantmenttable", spawnX - xRand, spawnY, spawnZ + zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + world.spawnParticle("enchantmenttable", spawnX + xRand, spawnY, spawnZ - zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + world.spawnParticle("enchantmenttable", spawnX - xRand, spawnY, spawnZ - zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + + if (((TileQuantumGate) tile).canFunction()) + { + world.spawnParticle("portal", spawnX + xRand, spawnY, spawnZ + zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + world.spawnParticle("portal", spawnX - xRand, spawnY, spawnZ + zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + world.spawnParticle("portal", spawnX + xRand, spawnY, spawnZ - zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + world.spawnParticle("portal", spawnX - xRand, spawnY, spawnZ - zRand, Math.random() * 0.5, 0.1, Math.random() * 0.5); + } + } + } + } + } + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int i, float f1, float f2, float f3) + { + if (player != null && player.getHeldItem() == null || player.getHeldItem().itemID != (Electrical.blockGlyph.blockID)) + { + TileEntity tile = world.getBlockTileEntity(x, y, z); + + if (tile instanceof TileQuantumGate) + { + int frequency = ((TileQuantumGate) tile).getFrequency(); + + if (frequency == -1) + { + if (!world.isRemote) + player.addChatMessage("Quantum Gate not set up."); + } + else + { + if (!world.isRemote) + { + player.addChatMessage("Quantum Gate frequency: " + " " + frequency); + } + } + } + return true; + } + + return false; + } + + @Override + public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity par5Entity) + { + + } + + @Override + public TileEntity createNewTileEntity(World world) + { + return new TileQuantumGate(); + } + + @Override + public boolean isOpaqueCube() + { + return false; + } + +} diff --git a/electrical/src/main/java/resonantinduction/quantum/gate/QuantumGateManager.java b/electrical/src/main/java/resonantinduction/quantum/gate/QuantumGateManager.java new file mode 100644 index 00000000..b643b54e --- /dev/null +++ b/electrical/src/main/java/resonantinduction/quantum/gate/QuantumGateManager.java @@ -0,0 +1,108 @@ +package resonantinduction.quantum.gate; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.world.World; +import universalelectricity.api.vector.Vector3; +import universalelectricity.api.vector.VectorWorld; + +public class QuantumGateManager +{ + private static HashMap managerList = new HashMap(); + private HashSet teleporters = new HashSet(); + private static HashMap coolDown = new HashMap(); + + public static QuantumGateManager getManagerForDim(int dim) + { + if (managerList.get(dim) == null) + { + managerList.put(dim, new QuantumGateManager()); + } + + return managerList.get(dim); + } + + /** Adds a teleport anchor to this list or anchors */ + public static void addAnchor(TileQuantumGate anch) + { + if (anch != null) + { + QuantumGateManager manager = getManagerForDim(anch.worldObj.provider.dimensionId); + + if (!manager.teleporters.contains(anch)) + { + manager.teleporters.add(anch); + } + } + } + + /** Removes a teleport anchor to this list or anchors */ + public static void remAnchor(TileQuantumGate anch) + { + if (anch != null) + { + QuantumGateManager manager = getManagerForDim(anch.worldObj.provider.dimensionId); + manager.teleporters.remove(anch); + } + } + + public static HashSet getConnectedAnchors(World world) + { + return getManagerForDim(world.provider.dimensionId).teleporters; + } + + public boolean contains(TileQuantumGate anch) + { + return teleporters.contains(anch); + } + + public static TileQuantumGate getClosestWithFrequency(VectorWorld vec, int frequency, TileQuantumGate... anchors) + { + TileQuantumGate tele = null; + List ignore = new ArrayList(); + if (anchors != null) + { + ignore.addAll(Arrays.asList(anchors)); + } + Iterator it = new ArrayList(QuantumGateManager.getConnectedAnchors(vec.world)).iterator(); + while (it.hasNext()) + { + TileQuantumGate teleporter = it.next(); + if (!ignore.contains(teleporter) && teleporter.getFrequency() == frequency) + { + if (tele == null || new Vector3(tele).distance(vec) > new Vector3(teleporter).distance(vec)) + { + tele = teleporter; + } + } + } + return tele; + } + + protected static void moveEntity(Entity entity, VectorWorld location) + { + if (entity != null && location != null) + { + location.world.markBlockForUpdate((int) location.x, (int) location.y, (int) location.z); + if (entity instanceof EntityPlayerMP) + { + if (coolDown.get(((EntityPlayerMP) entity).username) == null || (System.currentTimeMillis() - coolDown.get(((EntityPlayerMP) entity).username) > 30)) + { + ((EntityPlayerMP) entity).playerNetServerHandler.setPlayerLocation(location.x, location.y, location.z, 0, 0); + coolDown.put(((EntityPlayerMP) entity).username, System.currentTimeMillis()); + } + } + else + { + entity.setPosition(location.x, location.y, location.z); + } + } + } +} diff --git a/electrical/src/main/java/resonantinduction/quantum/gate/TileQuantumGate.java b/electrical/src/main/java/resonantinduction/quantum/gate/TileQuantumGate.java new file mode 100644 index 00000000..8e131004 --- /dev/null +++ b/electrical/src/main/java/resonantinduction/quantum/gate/TileQuantumGate.java @@ -0,0 +1,163 @@ +package resonantinduction.quantum.gate; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import resonantinduction.electrical.tesla.ITesla; +import resonantinduction.electrical.tesla.TeslaGrid; +import universalelectricity.api.energy.EnergyStorageHandler; +import universalelectricity.api.vector.Vector3; +import universalelectricity.api.vector.VectorWorld; +import calclavia.lib.prefab.tile.TileElectrical; + +/** + * @author Calclavia, Archadia + */ +public class TileQuantumGate extends TileElectrical implements ITesla +{ + private long lastFrequencyCheck = 0; + private int frequency = 0; + + public TileQuantumGate() + { + energy = new EnergyStorageHandler(100000); + ioMap = 0; + } + + @Override + public void initiate() + { + super.initiate(); + TeslaGrid.instance().register(this); + + if (!worldObj.isRemote) + { + QuantumGateManager.addAnchor(this); + } + } + + @Override + public void updateEntity() + { + super.updateEntity(); + + if (canFunction() && ticks % 60 == 0) + { + AxisAlignedBB bounds = AxisAlignedBB.getAABBPool().getAABB(xCoord - 1, yCoord - 4, zCoord - 1, xCoord + 2, yCoord + 2, zCoord + 2); + List entities = worldObj.getEntitiesWithinAABB(Entity.class, bounds); + + for (Entity entity : entities) + { + if (entity instanceof EntityPlayer) + if (entity.isSneaking()) + continue; + + doTeleport(entity); + } + } + } + + public boolean canFunction() + { + return energy.isFull(); + } + + @Override + public void validate() + { + + super.validate(); + } + + @Override + public void invalidate() + { + if (!worldObj.isRemote) + { + QuantumGateManager.remAnchor(this); + } + + TeslaGrid.instance().unregister(this); + super.invalidate(); + } + + public void doTeleport(Entity entity) + { + VectorWorld teleportSpot = null; + + if (getFrequency() != -1) + { + TileQuantumGate teleporter = QuantumGateManager.getClosestWithFrequency(new VectorWorld(this), getFrequency(), this); + + if (teleporter != null) + { + teleportSpot = new VectorWorld(teleporter).translate(0.5, 2, 0.5); + } + } + + if (teleportSpot != null) + { + QuantumGateManager.moveEntity(entity, teleportSpot); + } + } + + /** @return -1 if the teleporter is unable to teleport. */ + public int getFrequency() + { + if (System.currentTimeMillis() - this.lastFrequencyCheck > 10) + { + this.lastFrequencyCheck = System.currentTimeMillis(); + this.frequency = 0; + + for (int i = 4; i > 0; i--) + { + Vector3 position = new Vector3(xCoord, yCoord - i, this.zCoord); + + Block block = Block.blocksList[this.worldObj.getBlockId((int) position.x, (int) position.y, (int) position.z)]; + + if (block instanceof BlockGlyph) + { + int metadata = this.worldObj.getBlockMetadata((int) position.x, (int) position.y, (int) position.z); + this.frequency += Math.pow(BlockGlyph.MAX_GLYPH, i - 2) * metadata; + } + else + { + return -1; + } + } + } + + return frequency; + } + + @Override + public void readFromNBT(NBTTagCompound nbt) + { + super.readFromNBT(nbt); + + } + + @Override + public void writeToNBT(NBTTagCompound nbt) + { + super.writeToNBT(nbt); + + } + + @Override + public long teslaTransfer(long transferEnergy, boolean doTransfer) + { + return energy.receiveEnergy(transferEnergy, doTransfer); + } + + @Override + public boolean canTeslaTransfer(TileEntity transferTile) + { + return true; + } +} diff --git a/src/main/resources/assets/resonantinduction/languages/en_US.properties b/src/main/resources/assets/resonantinduction/languages/en_US.properties index 3c3f097f..a7ec152b 100644 --- a/src/main/resources/assets/resonantinduction/languages/en_US.properties +++ b/src/main/resources/assets/resonantinduction/languages/en_US.properties @@ -139,6 +139,13 @@ item.resonantinduction\:wire.superconductor.name=Superconductor Wire item.resonantinduction\:transformer.name=Transformer item.resonantinduction\:multimeter.name=Multimeter +### Quantum Tier +tile.resonantinduction\:quantumGate.name=Quantum Gate +tile.resonantinduction\:glyph.0.name=Monogon Glyph +tile.resonantinduction\:glyph.1.name=Digon Glyph +tile.resonantinduction\:glyph.2.name=Trigon Glyph +tile.resonantinduction\:glyph.3.name=Tetragon Glyph + ## Tool-tips tooltip.transformer.stepUp=Step Up tooltip.transformer.stepDown=Step Down diff --git a/src/main/resources/assets/resonantinduction/textures/blocks/glyph_0.png b/src/main/resources/assets/resonantinduction/textures/blocks/glyph_0.png new file mode 100644 index 0000000000000000000000000000000000000000..6f69cd5e1111410f283d91d69e69188329cb3d01 GIT binary patch literal 971 zcmV;+12p`JP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D02*{fSaefwW^{L9 za%BKeVQFr3E>1;MAa*k@H7+qRNAp5A0009zNklUnZ2>7DYLDio@_-6!fKtU> z0oO1ESfEC8ZI<07$^|I;GD1;9&<3!fyQ>PYt-j>^#erL?$j~^aJEZ^%!HJx(>Mjp4 zhuP8M)1ow-rj!NKo>|g`#}sD<>6OMQ78d~k`~*&t4IN!{fgO=vU!BQ7 zb$lBW0NN!OrT_~7;T8aqPOb)M##;C4_08(tM`8dgI?zXVt-xG>zXnbi5ch@n)uc2s ziOug$omC%!n@MeewbuuT+zun2qB^L*jt*44y7FTufH$nBmk=}bso&wwowW_H4j6zJ zKO!%PQMvO$ukyt?y8sb%_CG}c;C?u`rT~}$o&bn=F#!lKTmW;xQ8)mahLFlgN5)~TfCeY~ri^so3-Y;j3t{|+TqyQK$K-Ck%EycLF#NB*#7an2?&|RQ< t$dz+;YAW}kfXC?a7^R3Z1w0_S-G5porA1O~dYJ$K002ovPDHLkV1g6&sV4vc literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/resonantinduction/textures/blocks/glyph_1.png b/src/main/resources/assets/resonantinduction/textures/blocks/glyph_1.png new file mode 100644 index 0000000000000000000000000000000000000000..b7387d6f7a387e7224dcc767165a42b9f9d90ec0 GIT binary patch literal 853 zcmV-b1FHOqP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D02*{fSaefwW^{L9 za%BKeVQFr3E>1;MAa*k@H7+qRNAp5A0008SNklG}Ej<>keSKRi6#-`^wu9dN)F^7i(Y4}2a_J$uC0*Vpd{xP1Nb6XAu# znIcl5QcLa48dkun4opB^$2Bfv;&YG6A}O7mfZ(U)Jyw7^_n;)|oRKrl4qPtMZd^;> zHbl;V{Zi1zx3$8bV9G znLyV%Z_wH$h}r4q(t{{_6Lwa-2};tUac;oPSGxk3<_;5}(}!0vvu4^lL-=Uvr zGhn2)f#|o$-St_7ef)Gc17ULm&>ms90xAG81rY13xnUzdMDB<)2p#gtJu7$@Fn^8; z*d52HNSClnY?p2~pTMo8GoZThfmriA5ze}dg6EG_C-b?y!*6%%8BjeS8qlQv5oO0H z;v=u|3!uaJn2$s23cw2J1Q59h0A4UgZh%vci(S5XK=S!uwE{}(cC+yZ(0F;@!)<)l z4My6xcg)L%{aD1BXuZC^ZtD!FhT(IYK>vWrs2oy2$|pAfe0LvCuQO{Hy_FtG(fIBL z8U26o`QKvik6Wi}h;@_|fN_D;PK34+XYfe7``Ru(;tI$;P&?G>T%DQ5dno9bu8t|g flq=vb;_B)b>L0G?2Aj7t00000NkvXXu0mjf?e2^2 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/resonantinduction/textures/blocks/glyph_2.png b/src/main/resources/assets/resonantinduction/textures/blocks/glyph_2.png new file mode 100644 index 0000000000000000000000000000000000000000..5b34119f5e86ecc621b4fc8b7d1f897173f8a22a GIT binary patch literal 957 zcmV;u148_XP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D02*{fSaefwW^{L9 za%BKeVQFr3E>1;MAa*k@H7+qRNAp5A0009lNklbZ!|Xpx^J`+XPCl*BcB55Nb`(3RdH3oHH-io)Eq8m)mgILf}$@Y6g32G01LWXRe)pVkedewE=5zJagH-Z zfQ?{BO{ludQ>*!)d1uws@NPTrtE(c*7Ct$>brn^4v4O|e2yftIEo5UHPe7wXFLIA|e(Q*hc zt*H(WUMT`p*_26$_!0mfek;ev>-p!Up9cZ>LJVdnZ@>t%m=^nMM1YMkR>b}DHGjAp zgWa>UB^6`R8!|w5t-wZrzXo;~;B#}{+QKMF2=Ijkp0ErQECfS5KcUs|Ya7+vUOyz+idb#w~r~ z1}W9cHS%Rey-h+@q;|Vqm)Zb(kUVcA(6^8own+?7*>M8^uicZQJE=8D-HI+zVQ}LH z8vTFp{NJLUms4{p2{n}nfZ+mE-6333%!5l@t*fi>6eB=)f$AnJ`<&EN?n42$G37Q| fk!=LrB08Nbc@em3p|3PO00000NkvXXu0mjf&vuvN literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/resonantinduction/textures/blocks/quantumGate.png b/src/main/resources/assets/resonantinduction/textures/blocks/quantumGate.png new file mode 100644 index 0000000000000000000000000000000000000000..83b52a4044dffc21e41f972979c416b95f9e1922 GIT binary patch literal 1317 zcmV+=1={+FP)N2bPDNB8 zb~7$DE-^7j^FlWO00f~)L_t(YOSM*MQ=4TJ^)KY5VTxHvAb~=HEa{^Dxu!auj#Dh1 ziX}!$jH9vzNRvPsD9|#~mQJN0N&%_UQCgOQ5L%X~GoJT7Pi_|d+VkPgz2}~L&-1)l z->Z7Z&<*T%yR#HvY&M(2;Xr~|oPcM}ggK(s0CUb_&;J-uAtI5I1Vm7*l!PQl0A(OG zrETNKbwfLz*mmu}7H0(9qA$w><>~IVz{E*lBIi$LNkYkm%76t}sN2R5eaSuN4=<}C zYp&jxr+a>73*c}uKx$n})^C6F-Oje&Is9PsO;hp!Bo_h&1E{gRHFM-o9e87}$#4aL z7C=V8mMRQ*2DjaP8)xD>7-v@*ut2*pvF91wVu=ApZf7oJG3ZUcW?<8o$a-UHi85f@ z9A3tw*C+C)1CaCWfh`};{PWShTwpBQl29^%aR%K6XFoe}+>$=zY~coIydQafCcbN| z)q9ehy?cBPGh+w-ku7(0$@SHIZFISDcr$P(dv5Xsdm*C%NAQ9-|JML;^{&^C>@XL2 z`(9W(A8Q@6crh`6s~`fEoe#ay)u!Ri3zIpN*v=M4n$vG^P(zhBU;%grH@O!;X^pI! zf^qF)93@sz14w@A(^PA6@5AZ8`3%88$>WnL+<*gwDsMeAwa;k55rb1piz5JKb$Fp= zbU%>RKLNsvOc}_Vl0XCg6~R$ca2P945^PBX*mZTy`G;PyL=+8BasxI5=F4NIizCtk zkOO5hlv*(5`g(!6bdlhc%785A*|XeuWV`W*IikFPWp||>QM>k_vV9skl>%kJg1Z>q z;RVOd$5H~ixdD~}2;i!}&8|*~7zqGz$qg8}!W~_)hUSC>!0SW#5@4x&;sza0w9g-a zlpCN0V`ac$HjpD$g?_R|)+`o_tN_55$)wc2oYy{^!gequAt)FK#WrE?d}<3XBGGpn zkkheb4rtdOYL_#rC_RKSV8Iz|;Uew&Y(>YcE;PCl+2s~8+9wI^$~Y3Bm_zr;r zD-d0g)ykU-TGzax)CFb302u93!h9v8wa+NZfQSnQtXnci#s%_^;?}Y=JZEmd&l137 zv4QE*Xid*zb@yUn#NlX49dH|B!2mcvmAi27FR*|N;1lEw&AFm0<}aSeY9y82tJ>9R zN7vKFzTc@wWY?F>HpF+yCfKilq})C_E}RWM+UpKRO% ze^`+7`3RsXgLtq+aw@bO$mGsX=J*K(Q*r}+jon^9yo-C(_HTG%Th8y-@k1s~&~TEg z0gw<>gr4EC1jdgW6Z?qL!eGe_xCjw{3w)`p?>7D&{ehNzgJLhDF|K=%fgT>-p{B<0{t*e#CiA{SB_a618(B1Y&q$)(Kspa9A+MHxy$N@eg4 bQC0OXPJCTu9-aho00000NkvXXu0mjfj~rAw literal 0 HcmV?d00001