Twice Upon a Loader

Forge/build.gradle

@@ -0,0 +1,108 @@
+buildscript {
+    repositories {
+        maven { url = 'https://maven.minecraftforge.net' }
+        mavenCentral()
+    }
+    dependencies {
+        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true
+    }
+}
+apply plugin: 'java'
+apply plugin: 'net.minecraftforge.gradle'
+apply plugin: 'eclipse'
+apply plugin: 'maven-publish'
+
+archivesBaseName = "${mod_name}-forge-${minecraft_version}"
+
+minecraft {
+    mappings channel: 'official', version: minecraft_version
+    
+    if (project.hasProperty('forge_ats_enabled') && project.findProperty('forge_ats_enabled').toBoolean()) {
+        // This location is hardcoded in Forge and can not be changed.
+        // https://github.com/MinecraftForge/MinecraftForge/blob/be1698bb1554f9c8fa2f58e32b9ab70bc4385e60/fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModFile.java#L123
+        accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
+        project.logger.debug('Forge Access Transformers are enabled for this project.')
+    }
+
+    runs {
+        client {
+            workingDirectory project.file('run')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            taskName 'Client'
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            mods {
+                modClientRun {
+                    source sourceSets.main
+                    source project(":Common").sourceSets.main
+                }
+            }
+        }
+
+        server {
+            workingDirectory project.file('run')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            taskName 'Server'
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            mods {
+                modServerRun {
+                    source sourceSets.main
+                    source project(":Common").sourceSets.main
+                }
+            }
+        }
+
+        data {
+            workingDirectory project.file('run')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            args '--mod', mod_id, '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
+            taskName 'Data'
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            mods {
+                modDataRun {
+                    source sourceSets.main
+                    source project(":Common").sourceSets.main
+                }
+            }
+        }
+    }
+}
+
+sourceSets.main.resources.srcDir 'src/generated/resources'
+
+dependencies {
+    minecraft "net.minecraftforge:forge:${minecraft_version}-${forge_version}"
+    compileOnly project(":Common")
+
+    implementation fg.deobf("curse.maven:tardim-531315:3983700")
+    implementation fg.deobf("org.squiddev:cc-tweaked-1.19.1:${cc_version}")
+}
+
+tasks.withType(JavaCompile) {
+    source(project(":Common").sourceSets.main.allSource)
+}
+
+processResources {
+    from project(":Common").sourceSets.main.resources
+}
+
+
+jar.finalizedBy('reobfJar')
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            groupId project.group
+            artifactId project.archivesBaseName
+            version project.version
+            artifact jar
+        }
+    }
+    repositories {
+        maven {
+            url "file://" + System.getenv("local_maven")
+        }
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/Registration.java

@@ -0,0 +1,56 @@
+package su.a71.tardim_ic.tardim_ic;
+
+import com.google.common.collect.Sets;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.CreativeModeTab;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+import net.minecraftforge.registries.RegistryObject;
+
+import su.a71.tardim_ic.tardim_ic.digital_interface.DigitalInterfaceBlock;
+import su.a71.tardim_ic.tardim_ic.digital_interface.DigitalInterfaceTileEntity;
+import su.a71.tardim_ic.tardim_ic.redsone_input.RedstoneInputBlock;
+import su.a71.tardim_ic.tardim_ic.redsone_input.RedstoneInputTileEntity;
+
+import java.util.function.Supplier;
+
+public class Registration {
+
+    public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, TardimInControl.MODID);
+    public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, TardimInControl.MODID);
+    public static final DeferredRegister<BlockEntityType<?>> BLOCK_ENTITIES = DeferredRegister.create(ForgeRegistries.BLOCK_ENTITY_TYPES, TardimInControl.MODID);
+
+    public static final CreativeModeTab TARDIM_IC_TAB = new CreativeModeTab("tardim_ic") {
+        @Override
+        public ItemStack makeIcon() {
+            return new ItemStack(Registration.DIGITAL_TARDIM_INTERFACE.get());
+        }
+    };
+
+    // Blocks
+    private static <T extends Block> RegistryObject<T> register(String name, Supplier<T> block) {
+        RegistryObject<T> registryObject = BLOCKS.register(name, block);
+        ITEMS.register(name, () -> new BlockItem(registryObject.get(), new Item.Properties().tab(TARDIM_IC_TAB)));
+        return registryObject;
+    }
+    public static final RegistryObject<Block> DIGITAL_TARDIM_INTERFACE = register("digital_tardim_interface", DigitalInterfaceBlock::new);
+    public static final RegistryObject<Block> REDSTONE_TARDIM_INPUT = register("redstone_tardim_input", RedstoneInputBlock::new);
+
+    // Tile Entities
+    public static final RegistryObject<BlockEntityType<DigitalInterfaceTileEntity>> DIGITAL_TARDIM_INTERFACE_TILEENTITY = Registration.BLOCK_ENTITIES.register("digital_tardim_interface", () -> new BlockEntityType<>(DigitalInterfaceTileEntity::new, Sets.newHashSet(DIGITAL_TARDIM_INTERFACE.get()), null));
+    public static final RegistryObject<BlockEntityType<RedstoneInputTileEntity>> REDSTONE_TARDIM_INPUT_TILEENTITY = Registration.BLOCK_ENTITIES.register("redstone_tardim_input", () -> new BlockEntityType<>(RedstoneInputTileEntity::new, Sets.newHashSet(REDSTONE_TARDIM_INPUT.get()), null));
+
+    // Register our stuff
+    public static void register() {
+        IEventBus modEventBus = FMLJavaModLoadingContext.get().getModEventBus();
+        BLOCKS.register(modEventBus);
+        ITEMS.register(modEventBus);
+        BLOCK_ENTITIES.register(modEventBus);
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/TardimInControl.java

@@ -0,0 +1,20 @@
+package su.a71.tardim_ic.tardim_ic;
+
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.Mod;
+
+import su.a71.tardim_ic.tardim_ic.Constants;
+
+// The value here should match an entry in the META-INF/mods.toml file
+@Mod(Constants.MOD_ID)
+public class TardimInControl {
+
+    // Our mod id
+    public static final String MODID = "tardim_ic";
+
+    public TardimInControl() {
+        Registration.register();
+        // Register ourselves for server and other game events we are interested in. Currently, we do not use any events
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/command/CommandModemTransmit.java

@@ -0,0 +1,70 @@
+package su.a71.tardim_ic.tardim_ic.command;
+
+// This will be added whenever I manage to convince TARDIM devs to make CommandManager.register public
+
+import com.mojang.brigadier.Command;
+import com.swdteam.common.command.tardim.CommandTardimBase;
+import com.swdteam.common.command.tardim.ICommand;
+import com.swdteam.tardim.TardimData;
+import com.swdteam.tardim.TardimManager;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.player.Player;
+
+import dan200.computercraft.api.network.Packet;
+import dan200.computercraft.api.ComputerCraftAPI;
+
+import static com.swdteam.common.command.tardim.CommandTardimBase.sendResponse;
+
+public class CommandModemTransmit implements ICommand {
+    @Override
+    public void execute(String[] args, Player player, BlockPos pos, CommandTardimBase.CommandSource source) {
+        if (args.length == 3) {
+            TardimData data = TardimManager.getFromPos(pos);
+            if (data != null) {
+                if (data.hasPermission(player)) {
+                    try {
+                        int sendChannel = Integer.parseInt(args[0]);
+                        int replyChannel = Integer.parseInt(args[1]);
+                        String message = args[2];
+                        boolean allDimensions = Boolean.parseBoolean(args[3]) || args[3].equals("true");
+
+                        if (data.getTravelLocation() == null) {
+                            data.setTravelLocation(new TardimData.Location(data.getCurrentLocation()));
+                        }
+
+                        if (allDimensions)
+                        {
+                            ComputerCraftAPI.getWirelessNetwork().transmitInterdimensional(new Packet(sendChannel, replyChannel, message, new CommandSender(player, data.getTravelLocation().getPos())));
+                        }
+                        else {
+                            ComputerCraftAPI.getWirelessNetwork().transmitSameDimension(new Packet(sendChannel, replyChannel, message,
+                                    new CommandSender(player, data.getTravelLocation().getPos())), 300);
+                        }
+                        sendResponse(player, "Sent modem message", CommandTardimBase.ResponseType.COMPLETE, source);
+                    } catch (Exception var9) {
+                        sendResponse(player, "Invalid coordinates", CommandTardimBase.ResponseType.FAIL, source);
+                    }
+                } else {
+                    sendResponse(player, "You do not have permission", CommandTardimBase.ResponseType.FAIL, source);
+                }
+            }
+        } else {
+            sendResponse(player, this.getUsage(), CommandTardimBase.ResponseType.FAIL, source);
+        }
+    }
+
+    @Override
+    public String getCommandName() {
+        return "ccModemTransmit";
+    }
+
+    @Override
+    public String getUsage() {
+        return "ccModemTransmit <channel: int> <replyChannel: int> <message: string> <all_dimension: true/false>";
+    }
+
+    @Override
+    public CommandTardimBase.CommandSource allowedSource() {
+        return CommandTardimBase.CommandSource.BOTH;
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/command/CommandSender.java

@@ -0,0 +1,40 @@
+package su.a71.tardim_ic.tardim_ic.command;
+
+import dan200.computercraft.api.network.IPacketSender;
+import net.minecraft.core.BlockPos;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+
+public class CommandSender implements IPacketSender {
+
+    private final Player player;
+    private final Level level;
+    private final BlockPos pos;
+
+    CommandSender(Player player, BlockPos pos) {
+        this.player = player;
+        this.level = player.level;
+        this.pos = pos;
+    }
+
+    @NotNull
+    @Override
+    public Level getLevel() {
+        return this.level;
+    }
+
+    @NotNull
+    @Override
+    public Vec3 getPosition() {
+        return new Vec3(this.pos.getX(), this.pos.getY(), this.pos.getZ());
+    }
+
+    @NotNull
+    @Override
+    public String getSenderID() {
+        return this.player.getName().getString();
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/digital_interface/DigitalInterfaceBlock.java

@@ -0,0 +1,26 @@
+package su.a71.tardim_ic.tardim_ic.digital_interface;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.EntityBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.Material;
+import org.jetbrains.annotations.NotNull;
+import su.a71.tardim_ic.tardim_ic.Registration;
+
+import javax.annotation.Nullable;
+
+
+public class DigitalInterfaceBlock extends Block implements EntityBlock {
+
+    public DigitalInterfaceBlock() {
+        super(Properties.of(Material.METAL).strength(2, 4).noOcclusion());
+    }
+
+    @Nullable
+    @Override
+    public BlockEntity newBlockEntity(@NotNull BlockPos pos, @NotNull BlockState state) {
+        return Registration.DIGITAL_TARDIM_INTERFACE_TILEENTITY.get().create(pos, state);
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/digital_interface/DigitalInterfacePeripheral.java

@@ -0,0 +1,727 @@
+package su.a71.tardim_ic.tardim_ic.digital_interface;
+
+import com.mojang.datafixers.util.Pair;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Holder;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.level.Level;
+import net.minecraft.server.players.PlayerList;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.server.ServerLifecycleHooks;
+
+import dan200.computercraft.api.lua.LuaFunction;
+import dan200.computercraft.api.peripheral.IComputerAccess;
+import dan200.computercraft.api.peripheral.IPeripheral;
+import dan200.computercraft.api.lua.ObjectLuaTable;
+import dan200.computercraft.api.lua.LuaException;
+
+// TODO: Fabric and Forge diffirence? (Bottom: Fabric)
+import com.swdteam.tardim.TardimData;
+import com.swdteam.tardim.TardimManager;
+import com.swdteam.tardim.TardimData.Location;
+//import com.swdteam.tardim.tardim.TardimManager;
+//import com.swdteam.tardim.tardim.TardimData;
+
+import com.swdteam.common.command.tardim.CommandTravel;
+import com.swdteam.common.data.DimensionMapReloadListener;
+import com.swdteam.common.init.TRDSounds;
+import com.swdteam.common.item.ItemTardim;
+import com.swdteam.main.Tardim;
+
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.*;
+
+
+public class DigitalInterfacePeripheral implements IPeripheral {
+
+    private final List<IComputerAccess> connectedComputers = new ArrayList<>();  // List of computers connected to the peripheral
+    private final DigitalInterfaceTileEntity tileEntity;  // Peripheral's BlockEntity, used for accessing coordinates
+
+    /**
+     * @param tileEntity the tile entity of this peripheral
+     * @hidden
+     */
+    public DigitalInterfacePeripheral(DigitalInterfaceTileEntity tileEntity) {
+        this.tileEntity = tileEntity;
+    }
+
+    /** Setting name for the peripheral. A computer will see it as "digital_tardim_interface_n"
+     * @hidden
+     */
+    @Nonnull
+    @Override
+    public String getType() { return "digital_tardim_interface"; }
+
+    /** Apparently CC uses this to check if the peripheral in front of a modem is this one
+     * @hidden
+     * @param iPeripheral The peripheral to compare against. This may be {@code null}.
+     * @return {@code true} if the peripheral is the same as this one.
+     */
+    @Override
+    public boolean equals(@Nullable IPeripheral iPeripheral) { return this == iPeripheral; }
+
+    /** Called when a computer disconnects from the peripheral
+     * @hidden
+     * @param computer The interface to the computer that is being detached. Remember that multiple computers can be
+     *                 attached to a peripheral at once.
+     */
+    @Override
+    public void detach(@Nonnull IComputerAccess computer) { connectedComputers.remove(computer); }
+
+    /** Called when a computer connects to the peripheral
+     * @hidden
+     * @param computer The interface to the computer that is being attached. Remember that multiple computers can be
+     *                 attached to a peripheral at once.
+     */
+    @Override
+    public void attach(@Nonnull IComputerAccess computer) { connectedComputers.add(computer); }
+
+    /**
+     * I *think* I use this to get peripheral's world position
+     * @hidden
+     * @return
+     */
+    public DigitalInterfaceTileEntity getTileEntity() {
+        return tileEntity;
+    }
+
+
+    /**
+     *  Get TARDIM's data, which we need for *every* function
+     * <p>
+     * We can't do a simple
+     * <code>TardimManager.getFromPos(getTileEntity().getPos())</code>
+     * <p>
+     * because if someone attempts to call a method outside a TARDIM, this would create a new TARDIM/Point to the one with ID of 0 (Due to the way TardimSaveHandler.loadTardisData works).
+     * Which is obviously not what we want.
+     * <p>
+     * So instead we use this, and get the ability to give user a LuaException if they think that fiddling with time is funny
+     * This is mostly a copy of getIDForXZ function with some added checks
+     *
+     * @return TardimData of the TARDIM that the peripheral is in
+     * @throws LuaException if the peripheral is not in a TARDIM
+     * @hidden
+     */
+    public TardimData getTardimData() throws LuaException {
+        int X = getTileEntity().getPos().getX(), Z = getTileEntity().getPos().getZ();
+
+        int index = 0;
+        int x = 0;
+        int y = 0;
+        int dx = 0;
+        int dy = 1;
+        int segment_length = 1;
+        int segment_passed = 0;
+        boolean found = false;
+        long timecheck = System.currentTimeMillis();
+
+        while(true) {
+            if (System.currentTimeMillis() - timecheck > 10000L) {
+                System.out.println("Finding ID from XZ Coordinates is taking too long!");
+                break;
+            }
+
+            if (X >= x * TardimManager.INTERIOR_BOUNDS
+                    && X <= TardimManager.INTERIOR_BOUNDS + x * TardimManager.INTERIOR_BOUNDS
+                    && Z >= y * TardimManager.INTERIOR_BOUNDS
+                    && Z <= TardimManager.INTERIOR_BOUNDS + y * TardimManager.INTERIOR_BOUNDS) {
+                found = true;
+                break;
+            }
+
+            x += dx;
+            y += dy;
+            if (++segment_passed == segment_length) {
+                segment_passed = 0;
+                int buffer = dy;
+                dy = -dx;
+                dx = buffer;
+                if (buffer == 0) {
+                    ++segment_length;
+                }
+            }
+
+            ++index;
+        }
+
+        // We really don't want to access a ghost TARDIM, do we?
+        if (!found) {
+            throw new LuaException("Peripheral is not inside a TARDIM");
+        }
+        TardimData T = TardimManager.getTardim(index);
+        if (T.getCurrentLocation() == null || T.getOwnerName() == null) {
+            throw new LuaException("Peripheral is not inside a TARDIM");
+        }
+
+    	return T;
+    }
+
+    // Peripheral methods ===============================================================
+
+    /**
+     * Return how much fuel is left in the TARDIM
+     *
+     * @return Fuel left (Out of 100)
+    */
+    @LuaFunction(mainThread = true)
+    public final double getFuel() throws LuaException {
+        return getTardimData().getFuel();
+    }
+
+    /**
+     * Get how much fuel it would take to travel to the destination
+     * @return Amount of fuel needed (Out of 100)
+    */
+    @LuaFunction(mainThread = true)
+    public final double calculateFuelForJourney() throws LuaException {
+        TardimData data = getTardimData();
+
+        if (data.getTravelLocation() == null) return 0;
+
+        Location curr = data.getCurrentLocation();
+        Location dest = data.getTravelLocation();
+
+        double fuel = 0.0;
+
+        if (curr.getLevel() != dest.getLevel())
+        {
+            fuel = 10.0;
+        }
+
+        Vec3 posA = new Vec3(curr.getPos().getX(), curr.getPos().getY(), curr.getPos().getZ());
+        Vec3 posB = new Vec3(dest.getPos().getX(), dest.getPos().getY(), dest.getPos().getZ());
+        fuel += posA.distanceTo(posB) / 100.0;
+        if (fuel > 100.0) fuel = 100.0;
+
+        return fuel;
+    }
+
+    /**
+     * Check whether the TARDIM is locked
+     * @return true if locked, false if not
+     */
+    @LuaFunction(mainThread = true)
+    public final boolean isLocked() throws LuaException {
+        return getTardimData().isLocked();
+    }
+
+    /**
+     * Check whether the TARDIM is in flight
+     * @return true if in flight, false if not
+     */
+    @LuaFunction(mainThread = true)
+    public final boolean isInFlight() throws LuaException { return getTardimData().isInFlight(); }
+
+    /**
+     * Supposedly gets UNIX timestamp of when we entered flight
+     * @return UNIX timestamp if in flight, -1 if not
+     */
+    @LuaFunction(mainThread = true)
+    public final long getTimeEnteredFlight() throws LuaException {
+        TardimData data = getTardimData();
+        if (!data.isInFlight()) {
+            return -1;
+        }
+        return data.getTimeEnteredFlight();
+    }
+
+    /**
+     * Get username of the TARDIM's owner
+     * @return String of the owner's username
+     */
+    @LuaFunction(mainThread = true)
+    public final String getOwnerName() throws LuaException {
+        TardimData data = getTardimData();
+        return data.getOwnerName();
+    }
+
+    /**
+     * Lock/unlock the TARDIM
+     * @param locked    true to lock, false to unlock
+     */
+    @LuaFunction(mainThread = true)
+    public final void setLocked(boolean locked) throws LuaException {
+        getTardimData().setLocked(locked);
+    }
+
+    /**
+     * Get the current location of the TARDIM
+     * @return ObjectLuaTable of the current location with the following keys:
+     * <ul>
+     *     <li>dimension - String of the dimension</li>
+     *     <li>pos - table with the keys x, y, z that hold numbers</li>
+     *     <li>facing - String of the facing</li>
+     * </ul>
+     */
+    @LuaFunction(mainThread = true)
+    public final ObjectLuaTable getCurrentLocation() throws LuaException {
+    	Location loc = getTardimData().getCurrentLocation();
+        return new ObjectLuaTable(Map.of(
+            "dimension", loc.getLevel().location().toString(),
+            "pos", new ObjectLuaTable(Map.of(
+                "x", loc.getPos().getX(),
+                "y", loc.getPos().getY(),
+                "z", loc.getPos().getZ()
+            )),
+        "facing", loc.getFacing().toString()
+        ));
+    }
+
+    /**
+     * Get the current location of the TARDIM
+     * @return if there is no destination returns null.
+     * <p>
+     * Otherwise, ObjectLuaTable of the current location with the following keys:
+     *  <ul>
+     *      <li>dimension - String of the dimension</li>
+     *      <li>pos - table with the keys x, y, z that hold numbers</li>
+     *      <li>facing - String of the facing</li>
+     *  </ul>
+     */
+    @LuaFunction(mainThread = true)
+    public final ObjectLuaTable getTravelLocation() throws LuaException {
+    	TardimData data = getTardimData();
+        if (data.getTravelLocation() == null) {
+            data.setTravelLocation(data.getCurrentLocation());
+        }
+        Location loc = data.getTravelLocation();
+        return new ObjectLuaTable(Map.of(
+                "dimension", loc.getLevel().location().toString(),
+                "pos", new ObjectLuaTable(Map.of(
+                    "x", loc.getPos().getX(),
+                    "y", loc.getPos().getY(),
+                    "z", loc.getPos().getZ()
+                )),
+                "facing", loc.getFacing().toString()
+        ));
+    }
+
+    /**
+     * Get list of the TARDIM owner's companions
+     * @return ObjectLuaTable containing the usernames of the companions
+     */
+    @LuaFunction(mainThread = true)
+    public final ObjectLuaTable getCompanions() throws LuaException {
+    	TardimData data = getTardimData();
+        Map<Integer, String> companions = new HashMap<>();
+    	for (int i = 0; i < data.getCompanions().size(); i++) {
+    		companions.put(i + 1, data.getCompanions().get(i).getUsername());
+    	}
+    	return new ObjectLuaTable(companions);
+    }
+
+    /**
+     * Set dimension for the TARDIM to travel to
+     * <p>
+     * This is a serious hazard right now due to the fact that I am unable to check if the dimension is valid.
+     * <p>
+     * TODO: If invalid dimension is given, the TARDIM is unable to land until the dimension is changed. Add proper checks.
+     * @param dimension String of the dimension e.g. "minecraft:overworld"
+     */
+    @LuaFunction(mainThread = true)
+    public final void setDimension(String dimension) throws LuaException {
+    	TardimData data = getTardimData();
+
+        String key = dimension;
+        dimension = DimensionMapReloadListener.toTitleCase(dimension);
+        if (TardimManager.DIMENSION_MAP.containsKey(dimension)) {
+            key = (String)TardimManager.DIMENSION_MAP.get(dimension);
+        } else {
+            dimension = dimension.toLowerCase();
+        }
+
+        if (!CommandTravel.isValidPath(key)) {
+            throw new LuaException("Invalid dimension");
+        } else {
+            ResourceKey<Level> dim = ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(dimension));
+            if (data.getTravelLocation() == null) {
+                data.setTravelLocation(new Location(data.getCurrentLocation()));
+            }
+
+            data.getTravelLocation().setLocation(dim);
+        }
+    }
+
+    /**
+     * Set the destination's coordinates
+     * @param x X coordinate
+     * @param y Y coordinate
+     * @param z Z coordinate
+     */
+    @LuaFunction(mainThread = true)
+    public final void setTravelLocation(int x, int y, int z) throws LuaException {
+        TardimData data = getTardimData();
+        if (data.getTravelLocation() == null) {
+            data.setTravelLocation(new Location(data.getCurrentLocation()));
+        }
+
+        data.getTravelLocation().setPosition(x, y, z);
+    }
+
+
+    /**
+     * Set destination to the TARDIM's owner's home (Must be online)
+     */
+    @LuaFunction(mainThread = true)
+    public final void home() throws LuaException {
+    	TardimData data = getTardimData();
+
+        UUID uuid = data.getOwner();
+        String username = data.getOwnerName();
+        if (uuid == null || username == null) {
+            throw new LuaException("TARDIM has no owner");
+        }
+
+        PlayerList playerList = ServerLifecycleHooks.getCurrentServer().getPlayerList();
+        ServerPlayer player = playerList.getPlayer(uuid);
+        if (player == null) {
+            throw new LuaException("TARDIM owner is not online");
+        }
+
+        ResourceKey<Level> dim = player.getRespawnDimension();
+        BlockPos pos = player.getRespawnPosition();
+        if (pos == null) {
+            throw new LuaException("TARDIM owner has no home");
+        }
+
+        setDimension(dim.location().toString());
+        setTravelLocation(pos.getX(), pos.getY(), pos.getZ());
+    }
+
+    /**
+     * Set destination for a player's location (Player must be online)
+     * @param username - String of the username of the player
+     */
+    @LuaFunction(mainThread = true)
+    public final void locatePlayer(String username) throws LuaException {
+    	PlayerList playerList = ServerLifecycleHooks.getCurrentServer().getPlayerList();
+    	ServerPlayer player = playerList.getPlayerByName(username);
+    	if (player == null) {
+    		throw new LuaException("Player not found");
+    	}
+
+    	ResourceKey<Level> dim = player.getCommandSenderWorld().dimension();
+    	BlockPos pos = player.blockPosition();
+
+    	setDimension(dim.location().toString());
+    	setTravelLocation(pos.getX(), pos.getY(), pos.getZ());
+    }
+
+    /**
+     * Get online players. Useful for making a GUI for the locate function or just a nice dashboard.
+     *
+     * @return ObjectLuaTable of the online players
+     */
+    @LuaFunction(mainThread = true)
+    public final ObjectLuaTable getOnlinePlayers() throws LuaException {
+    	PlayerList playerList = ServerLifecycleHooks.getCurrentServer().getPlayerList();
+        Map<Integer, String> players = new HashMap<>();
+        for (int i = 0; i < playerList.getPlayers().size(); i++) {
+            players.put(i + 1, playerList.getPlayers().get(i).getGameProfile().getName());
+        }
+
+    	return new ObjectLuaTable(players);
+    }
+
+    /**
+     * Get the rotation of the TARDIM's door
+     * @return String of the door rotation ("north", "south", "east", "west")
+     */
+    @LuaFunction(mainThread = true)
+    public final String getDoorRotation() throws LuaException {
+    	TardimData data = getTardimData();
+    	Direction rotation = data.getTravelLocation().getFacing();
+        switch (rotation) {
+            case NORTH -> {
+                return "north";
+            }
+            case EAST -> {
+                return "east";
+            }
+            case SOUTH -> {
+                return "south";
+            }
+            case WEST -> {
+                return "west";
+            }
+            default -> {
+                throw new LuaException("Invalid door rotation");
+            }
+        }
+    }
+
+    /**
+     * Set the rotation of the TARDIM's door
+     * @param rotation  String of the door rotation ("north", "south", "east", "west")
+     */
+    @LuaFunction(mainThread = true)
+    public final void setDoorRotation(String rotation) throws LuaException {
+    	TardimData data = getTardimData();
+        switch (rotation) {
+            case "north" -> data.getTravelLocation().setFacing(Direction.NORTH);
+            case "east" -> data.getTravelLocation().setFacing(Direction.EAST);
+            case "south" -> data.getTravelLocation().setFacing(Direction.SOUTH);
+            case "west" -> data.getTravelLocation().setFacing(Direction.WEST);
+            default -> throw new LuaException("Invalid door rotation");
+        }
+
+        data.save();
+    }
+
+    /**
+     * Toggle the rotation of the TARDIM's door (north -> east -> south -> west -> north)
+     */
+    @LuaFunction(mainThread = true)
+    public final void toggleDoorRotation() throws LuaException {
+    	TardimData data = getTardimData();
+        if (data.getTravelLocation() == null) {
+            data.setTravelLocation(new Location(data.getCurrentLocation()));
+        }
+
+        if (data.getTravelLocation().getFacing() == null) {
+            data.getTravelLocation().setFacing(Direction.NORTH);
+        }
+
+        switch (data.getTravelLocation().getFacing()) {
+            case NORTH -> data.getTravelLocation().setFacing(Direction.EAST);
+            case EAST -> data.getTravelLocation().setFacing(Direction.SOUTH);
+            case SOUTH -> data.getTravelLocation().setFacing(Direction.WEST);
+            case WEST -> data.getTravelLocation().setFacing(Direction.NORTH);
+            default -> data.getTravelLocation().setFacing(Direction.NORTH);
+        }
+
+        data.save();
+    }
+
+    /**
+     * Add a number to the destination's coordinates
+     * @param axis  String of the axis ("x", "y", "z")
+     * @param amount    Number to add to the axis
+     */
+    @LuaFunction(mainThread = true)
+    public final void coordAdd(String axis, int amount) throws LuaException {
+    	TardimData data = getTardimData();
+    	if (data.getTravelLocation() == null) {
+    		data.setTravelLocation(new Location(data.getCurrentLocation()));
+    	}
+
+    	Location location = data.getTravelLocation();
+    	switch (axis) {
+    		case "x" -> location.addPosition(amount, 0, 0);
+            case "y" -> location.addPosition(0, amount, 0);
+            case "z" -> location.addPosition(0, 0, amount);
+            default -> throw new LuaException("Invalid axis");
+    	}
+    }
+
+    /**
+     * Dematerialize the TARDIM
+     */
+    @LuaFunction(mainThread = true)
+    public final void demat() throws LuaException {
+    	TardimData data = getTardimData();
+
+        if (data.isInFlight()) {
+            throw new LuaException("TARDIM is already in flight");
+        }
+        Location loc = data.getCurrentLocation();
+        ServerLevel level = ServerLifecycleHooks.getCurrentServer().getLevel(loc.getLevel());
+        ItemTardim.destroyTardim(level, loc.getPos(), Direction.NORTH);
+        data.setInFlight(true);
+    	if (data.getTravelLocation() == null) {
+            data.setTravelLocation(new Location(data.getCurrentLocation()));
+        }
+
+        // TODO: This is a horrendous way of doing this. Please fix.
+        String level_str = "tardim:tardis_dimension";
+        ServerLifecycleHooks.getCurrentServer().getLevel(ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(level_str))).playSound(null, this.tileEntity.getPos(), (SoundEvent) TRDSounds.TARDIM_TAKEOFF.get(), SoundSource.AMBIENT, 1.0F, 1.0F);
+
+        data.save();
+    }
+
+    /**
+     * Materialize the TARDIM at the destination
+     * <p>
+     * Has a LOT of checks to make sure the TARDIM can materialize, so please implement error handling if you use this.
+     */
+    @LuaFunction(mainThread = true)
+    public final void remat() throws LuaException {
+        TardimData data = getTardimData();
+
+        if (data.isInFlight()) {
+            if (data.getTimeEnteredFlight() < System.currentTimeMillis() / 1000L - 10L) {
+                Location loc = data.getTravelLocation();
+                ServerLevel level = ServerLifecycleHooks.getCurrentServer().getLevel(loc.getLevel());
+                double fuel = data.calculateFuelForJourney(
+                        ServerLifecycleHooks.getCurrentServer().getLevel(data.getCurrentLocation().getLevel()), level, data.getCurrentLocation().getPos(), loc.getPos()
+                );
+                if (data.getFuel() >= fuel) {
+                    level.getChunk(loc.getPos());
+                    BlockPos landingPosButBetter = CommandTravel.getLandingPosition(level, loc.getPos());
+                    boolean recalc = false;
+
+                    for(int jj = 0; jj < 32; ++jj) {
+                        if (!Block.canSupportRigidBlock(level, landingPosButBetter.below())) {
+                            BlockPos pos2 = landingPosButBetter.offset(
+                                    level.random.nextInt(10) * (level.random.nextBoolean() ? 1 : -1),
+                                    0,
+                                    level.random.nextInt(10) * (level.random.nextBoolean() ? 1 : -1)
+                            );
+                            landingPosButBetter = CommandTravel.getLandingPosition(level, pos2);
+                            if (Block.canSupportRigidBlock(level, landingPosButBetter.below())) {
+                                recalc = true;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!recalc) {
+                        for(int jj = 0; jj < 32; ++jj) {
+                            if (!Block.canSupportRigidBlock(level, landingPosButBetter.below())) {
+                                BlockPos pos2 = landingPosButBetter.offset(
+                                        level.random.nextInt(30) * (level.random.nextBoolean() ? 1 : -1),
+                                        0,
+                                        level.random.nextInt(30) * (level.random.nextBoolean() ? 1 : -1)
+                                );
+                                landingPosButBetter = CommandTravel.getLandingPosition(level, pos2);
+                                if (Block.canSupportRigidBlock(level, landingPosButBetter.below())) {
+                                    recalc = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    if (!recalc) {
+                        for(int jj = 0; jj < 32; ++jj) {
+                            if (!Block.canSupportRigidBlock(level, landingPosButBetter.below())) {
+                                BlockPos pos2 = landingPosButBetter.offset(
+                                        level.random.nextInt(50) * (level.random.nextBoolean() ? 1 : -1),
+                                        0,
+                                        level.random.nextInt(50) * (level.random.nextBoolean() ? 1 : -1)
+                                );
+                                landingPosButBetter = CommandTravel.getLandingPosition(level, pos2);
+                                if (Block.canSupportRigidBlock(level, landingPosButBetter.below())) {
+                                    recalc = true;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    if (Block.canSupportRigidBlock(level, landingPosButBetter.below())) {
+                        loc.setPosition(landingPosButBetter.getX(), landingPosButBetter.getY(), landingPosButBetter.getZ());
+                        if (Tardim.isPosValid(level, loc.getPos())) {
+                            ItemTardim.buildTardim(level, loc.getPos(), data.getTravelLocation().getFacing(), data.getId());
+                            data.setCurrentLocation(data.getTravelLocation());
+                            data.setTravelLocation(null);
+                            data.setInFlight(false);
+                            data.addFuel(-fuel);
+                            data.save();
+
+//                            if (!recalc) {
+//                                sendResponse(player, "TARDIM is landing", CommandTardimBase.ResponseType.COMPLETE, source);
+//                            } else {
+//                                sendResponse(player, "Landing recalculated due to obstruction", CommandTardimBase.ResponseType.INFO, source);
+//                                sendResponse(player, "TARDIM is landing", CommandTardimBase.ResponseType.COMPLETE, source);
+//                            }
+
+                            String level_str = "tardim:tardis_dimension";
+                            ServerLifecycleHooks.getCurrentServer().getLevel(ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(level_str))).playSound(null, this.tileEntity.getPos(), (SoundEvent) TRDSounds.TARDIM_LANDING.get(), SoundSource.AMBIENT, 1.0F, 1.0F);
+
+                        } else {
+                            throw new LuaException("TARDIM landing obstructed. Aborting...");
+                        }
+                    } else {
+                        throw new LuaException("TARDIM landing obstructed. Aborting...");
+                    }
+                } else {
+                    throw new LuaException("Not enough fuel for journey");
+                }
+            } else {
+                throw new LuaException("TARDIM is still taking off");
+            }
+        } else {
+            throw new LuaException("TARDIM has already landed");
+        }
+    }
+
+    /**
+     * Locate a biome
+     * @param biome_str String of the biome e.g. "minecraft:plains"
+     */
+    @LuaFunction(mainThread = true)
+    public final void locateBiome(String biome_str) throws LuaException {
+        TardimData data = getTardimData();
+        if (data.getTravelLocation() == null) {
+            data.setTravelLocation(new Location(data.getCurrentLocation()));
+        }
+
+        Optional<Biome> biome = ServerLifecycleHooks.getCurrentServer()
+                .registryAccess()
+                .registryOrThrow(Registry.BIOME_REGISTRY)
+                .getOptional(new ResourceLocation(biome_str));
+        if (biome != null && biome.isPresent()) {
+            if (data.getTravelLocation() == null) {
+                data.setTravelLocation(new Location(data.getCurrentLocation()));
+            }
+
+            ServerLevel level = ServerLifecycleHooks.getCurrentServer().getLevel(data.getTravelLocation().getLevel());
+            BlockPos blockpos = new BlockPos(
+                    data.getTravelLocation().getPos().getX(),
+                    level.getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, data.getTravelLocation().getPos()).getY(),
+                    data.getTravelLocation().getPos().getZ()
+            );
+            BlockPos blockpos1 = this.findNearestBiome(level, (Biome)biome.get(), blockpos, 6400, 8);
+            if (blockpos1 != null) {
+                data.getTravelLocation().setPosition(blockpos1.getX(), blockpos1.getY(), blockpos1.getZ());
+                data.save();
+            } else {
+                throw new LuaException("Biome not found");
+            }
+        } else {
+            throw new LuaException("Unknown biome");
+        }
+    }
+
+    /**
+     * Helper method to find a biome
+     * @param level ServerLevel to search
+     * @param biome Biome to find
+     * @param pos   BlockPos to start from
+     * @param i Idk what this is, likely a radius
+     * @param j No idea about this either
+     * @return BlockPos of the biome
+     * @hidden
+     */
+    public BlockPos findNearestBiome(ServerLevel level, Biome biome, BlockPos pos, int i, int j) {
+        Pair<BlockPos, Holder<Biome>> bb = level.getChunkSource()
+                .getGenerator()
+                .getBiomeSource()
+                .findBiomeHorizontal(
+                        pos.getX(),
+                        pos.getY(),
+                        pos.getZ(),
+                        i,
+                        j,
+                        b_val -> b_val.value() == biome,
+                        level.random,
+                        true,
+                        level.getChunkSource().randomState().sampler()
+                );
+        return bb != null && bb.getFirst() != null ? (BlockPos)bb.getFirst() : null;
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/digital_interface/DigitalInterfaceTileEntity.java

@@ -0,0 +1,45 @@
+package su.a71.tardim_ic.tardim_ic.digital_interface;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+import org.jetbrains.annotations.NotNull;
+import su.a71.tardim_ic.tardim_ic.Registration;
+
+import dan200.computercraft.api.peripheral.IPeripheral;
+import static dan200.computercraft.shared.Capabilities.CAPABILITY_PERIPHERAL;
+
+public class DigitalInterfaceTileEntity extends BlockEntity {
+
+    public DigitalInterfaceTileEntity(BlockPos pos, BlockState state) {
+        super(Registration.DIGITAL_TARDIM_INTERFACE_TILEENTITY.get(), pos, state);
+    }
+
+    /**
+     * Our peripheral, we create a new peripheral for each new tile entity
+     */
+    protected DigitalInterfacePeripheral peripheral = new DigitalInterfacePeripheral(this);
+    private LazyOptional<IPeripheral> peripheralCap;
+    public BlockPos getPos() {
+        return this.worldPosition;
+    }
+
+    /**
+     * When a computer modem tries to wrap our block, the modem will call getCapability to receive our peripheral.
+     * Then we just simply return a {@link LazyOptional} with our Peripheral
+     */
+    @Override
+    @NotNull
+    public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, Direction direction) {
+        if (cap == CAPABILITY_PERIPHERAL) {
+            if (peripheralCap == null) {
+                peripheralCap = LazyOptional.of(() -> peripheral);
+            }
+            return peripheralCap.cast();
+        }
+        return super.getCapability(cap, direction);
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/redsone_input/RedstoneInputBlock.java

@@ -0,0 +1,100 @@
+package su.a71.tardim_ic.tardim_ic.redsone_input;
+
+import com.swdteam.common.block.BlockBaseTardimPanel;
+
+import com.swdteam.common.init.TRDDimensions;
+import com.swdteam.common.init.TRDSounds;
+import com.swdteam.network.NetworkHandler;
+import com.swdteam.network.packets.PacketOpenEditGui;
+import com.swdteam.tardim.TardimData;
+import com.swdteam.tardim.TardimManager;
+import com.swdteam.tileentity.TileEntityBaseTardimPanel;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.DebugPackets;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.EntityBlock;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.Material;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraftforge.common.util.FakePlayerFactory;
+import net.minecraftforge.server.ServerLifecycleHooks;
+import org.jetbrains.annotations.NotNull;
+
+import su.a71.tardim_ic.tardim_ic.Registration;
+
+import javax.annotation.Nullable;
+
+public class RedstoneInputBlock extends BlockBaseTardimPanel implements EntityBlock {
+    private boolean isPowered = false;
+    public RedstoneInputBlock() {
+        super(Properties.of(Material.METAL).strength(2, 4).noOcclusion());
+    }
+
+    @Nullable
+    @Override
+    public BlockEntity newBlockEntity(@NotNull BlockPos pos, @NotNull BlockState state) {
+        return Registration.REDSTONE_TARDIM_INPUT_TILEENTITY.get().create(pos, state);
+    }
+
+    @Override
+    public InteractionResult use(BlockState blockState, Level w, BlockPos blockPos, Player player, InteractionHand hand, BlockHitResult p_60508_) {
+        if (!w.isClientSide) {
+
+            w.playSound((Player)null, blockPos, (SoundEvent) TRDSounds.TARDIM_BEEP.get(), SoundSource.BLOCKS, 0.3F, 0.5F);
+
+            BlockEntity be = w.getBlockEntity(blockPos);
+            if (be instanceof TileEntityBaseTardimPanel && w.dimension() == TRDDimensions.TARDIS) {
+                TardimData data = TardimManager.getFromPos(blockPos);
+                if (data != null && data.hasPermission(player)) {
+                    NetworkHandler.sendTo((ServerPlayer)player, new PacketOpenEditGui(1, blockPos));
+                    return InteractionResult.CONSUME;
+                }
+
+                player.displayClientMessage(
+                        Component.literal("You do not have permission").withStyle(ChatFormatting.DARK_RED).withStyle(ChatFormatting.BOLD), true
+                );
+            }
+        }
+
+        return InteractionResult.CONSUME;
+    }
+
+    public boolean canSurvive(BlockState blockState, LevelReader levelReader, BlockPos blockPos) {
+        return true;
+    }
+
+    public void neighborChanged(BlockState blockState, Level level, BlockPos blockPos, Block block, BlockPos fromPos, boolean isMoving) {
+        DebugPackets.sendNeighborsUpdatePacket(level, blockPos);
+
+        // get redstone signal
+        Direction direction = blockState.getValue(FACING);
+        int redstoneSignal = level.getSignal(blockPos, direction);
+        if (redstoneSignal > 0 && !isPowered) {
+            isPowered = true;
+            BlockEntity be = level.getBlockEntity(blockPos);
+            if (be instanceof TileEntityBaseTardimPanel && level.dimension() == TRDDimensions.TARDIS) {
+                TardimData data = TardimManager.getFromPos(blockPos);
+                if (data != null) {
+                    if (((TileEntityBaseTardimPanel)be).hasCommand()) {
+                        ((TileEntityBaseTardimPanel)be).execute(FakePlayerFactory.getMinecraft(ServerLifecycleHooks.getCurrentServer().getLevel(level.dimension())));
+                    }
+                }
+            }
+
+        } else if (redstoneSignal == 0 && isPowered)
+            isPowered = false;
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/redsone_input/RedstoneInputTileEntity.java

@@ -0,0 +1,28 @@
+package su.a71.tardim_ic.tardim_ic.redsone_input;
+
+import com.swdteam.tileentity.TileEntityBaseTardimPanel;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+import org.jetbrains.annotations.NotNull;
+
+import com.swdteam.common.init.TRDTiles;
+
+import su.a71.tardim_ic.tardim_ic.Registration;
+import com.swdteam.tileentity.TileEntityTardimScanner;
+import com.swdteam.common.block.BlockTardimScanner;
+
+
+public class RedstoneInputTileEntity extends TileEntityBaseTardimPanel {
+    public RedstoneInputTileEntity(BlockPos pos, BlockState state) {
+        super(Registration.REDSTONE_TARDIM_INPUT_TILEENTITY.get(), pos, state);
+    }
+
+
+    public BlockPos getPos() {
+        return this.worldPosition;
+    }
+}

Forge/src/main/java/su/a71/tardim_ic/tardim_ic/sonic/SonicProbe.java

@@ -0,0 +1,22 @@
+package su.a71.tardim_ic.tardim_ic.sonic;
+
+import net.minecraft.world.item.Item;
+
+import com.swdteam.tardim.TardimData;
+import com.swdteam.tardim.TardimManager;
+
+import com.swdteam.client.gui.GuiCommandScreen;
+
+public class SonicProbe extends Item {
+    private TardimData tardim;
+    public SonicProbe(Properties properties) {
+        super(properties.stacksTo(1));
+    }
+
+    public void setTardim(TardimData tardim) {
+        this.tardim = tardim;
+    }
+
+    // Add tile entity
+
+}

Forge/src/main/resources/META-INF/mods.toml

@@ -0,0 +1,46 @@
+
+modLoader = "javafml" #mandatory
+loaderVersion="[43,)" #mandatory This is typically bumped every Minecraft version by Forge. See our download page for lists of versions.
+license = "All rights reserved"
+[[mods]] #mandatory
+# The modid of the mod
+modId = "tardim_ic" #mandatory
+version = "0.9" #mandatory
+# A display name for the mod
+displayName = "TARDIM: In Control" #mandatory
+# The description text for the mod (multi line!) (#mandatory)
+description = '''
+    All of time and space, now automated. Control your TARDIM using ComputerCraft: Tweaked.
+'''
+# A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
+[[dependencies.tardim_ic]] #optional
+# the modid of the dependency
+modId = "forge" #mandatory
+# Does this dependency have to exist - if not, ordering below must be specified
+mandatory = true #mandatory
+# The version range of the dependency
+versionRange="[43,)" #mandatory
+# An ordering relationship for the dependency - BEFORE or AFTER required if the relationship is not mandatory
+ordering = "NONE"
+# Side this dependency is applied on - BOTH, CLIENT or SERVER
+side = "BOTH"
+# Here's another dependency
+[[dependencies.tardim_ic]]
+modId = "computercraft"
+mandatory = true
+versionRange = "1.95.3"
+ordering = "NONE"
+side = "BOTH"
+[[dependencies.tardim_ic]]
+modId = "tardim"
+mandatory = true
+versionRange = "1.1.3"
+ordering = "NONE"
+side = "BOTH"
+[[dependencies.tardim_ic]]
+modId = "minecraft"
+mandatory = true
+# This version range declares a minimum of the current minecraft version up to but not including the next major version
+versionRange = "1.19.2"
+ordering = "NONE"
+side = "BOTH"