Initial commit

src/main/java/de/srendi/cctutorial/cctutorial/CCBlock.java

@@ -0,0 +1,29 @@
+package de.srendi.cctutorial.cctutorial;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.material.Material;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.IBlockReader;
+
+import javax.annotation.Nullable;
+
+public class CCBlock extends Block {
+
+    public CCBlock() {
+        super(Properties.create(Material.IRON).hardnessAndResistance(5, 10));
+    }
+
+    //Create a new tile entity with our registry object
+    @Nullable
+    @Override
+    public TileEntity createTileEntity(BlockState state, IBlockReader world) {
+        return Registration.CC_TILEENTITY.get().create();
+    }
+
+    //Say minecraft, our CCBlock has a tile entity.
+    @Override
+    public boolean hasTileEntity(BlockState state) {
+        return true;
+    }
+}

src/main/java/de/srendi/cctutorial/cctutorial/CCPeripheral.java

@@ -0,0 +1,97 @@
+package de.srendi.cctutorial.cctutorial;
+
+import dan200.computercraft.api.lua.LuaFunction;
+import dan200.computercraft.api.peripheral.IComputerAccess;
+import dan200.computercraft.api.peripheral.IPeripheral;
+import net.minecraft.util.text.StringTextComponent;
+import net.minecraftforge.fml.server.ServerLifecycleHooks;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Our peripheral class, this is the class where we will register functions for our block.
+ */
+public class CCPeripheral implements IPeripheral {
+
+    /**
+     * A list of all our connected computers. We need this for event usages.
+     */
+    List<IComputerAccess> connectedComputers = new ArrayList<>();
+
+    /**
+     * This is our tile entity, we set the tile entity when we create a new peripheral. We use this tile entity to access the block or the world
+     */
+    private final CCTileEntity tileEntity;
+
+    /**
+     *
+     * @param tileEntity the tile entity of this peripheral
+     */
+    public CCPeripheral(CCTileEntity tileEntity) {
+        this.tileEntity = tileEntity;
+    }
+
+    /**
+     * We use getType to set the name for our peripheral. A modem would wrap our block as "test_n"
+     *
+     * @return the name of our peripheral
+     */
+    @Nonnull
+    @Override
+    public String getType() {
+        return "test";
+    }
+
+    /**
+     * CC use this method to check, if the peripheral in front of the modem is our peripheral
+     */
+    @Override
+    public boolean equals(@Nullable IPeripheral iPeripheral) {
+        return this == iPeripheral;
+    }
+
+    /**
+     * Will be called when a computer disconnects from our block
+     */
+    @Override
+    public void detach(@Nonnull IComputerAccess computer) {
+        connectedComputers.remove(computer);
+    }
+
+    /**
+     * Will be called when a computer connects to our block
+     */
+    @Override
+    public void attach(@Nonnull IComputerAccess computer) {
+        connectedComputers.add(computer);
+    }
+
+    public CCTileEntity getTileEntity() {
+        return tileEntity;
+    }
+
+    /**
+     * To register functions for our block, wee need to create final methods with the {@link LuaFunction} annotation
+     * This function will send a message to every player on the Server
+     */
+    @LuaFunction
+    public final void sendMessage(String message) {
+        //Used to get the current server and all online players.
+        ServerLifecycleHooks.getCurrentServer().getPlayerList().getPlayers().forEach(player -> {
+            //Now, send the message
+            player.sendStatusMessage(new StringTextComponent(message), false);
+        });
+    }
+
+    /**
+     * Because we want to access the world, we need to run this function on the main thread.
+     */
+    @LuaFunction(mainThread = true)
+    public final boolean isRaining() {
+        return getTileEntity().getWorld().getRainStrength(0) > 0;
+    }
+
+}

src/main/java/de/srendi/cctutorial/cctutorial/CCTileEntity.java

@@ -0,0 +1,36 @@
+package de.srendi.cctutorial.cctutorial;
+
+import dan200.computercraft.api.peripheral.IPeripheral;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.Direction;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.util.LazyOptional;
+
+import static dan200.computercraft.shared.Capabilities.CAPABILITY_PERIPHERAL;
+
+public class CCTileEntity extends TileEntity {
+
+    public CCTileEntity() {
+        super(Registration.CC_TILEENTITY.get());
+    }
+
+    /**
+     * Our peripheral, we create a new peripheral for each new tile entity
+     */
+    protected CCPeripheral peripheral = new CCPeripheral(this);
+    private LazyOptional<IPeripheral> peripheralCap;
+
+    /**
+     * When a computer modem tries to wrap our block, the modem will call getCapability to receive our peripheral.
+     */
+    @Override
+    public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction direction) {
+        if (cap == CAPABILITY_PERIPHERAL) {
+            if (peripheralCap == null) {
+                peripheralCap = LazyOptional.of(() -> peripheral);
+            }
+            return peripheralCap.cast();
+        }
+        return super.getCapability(cap, direction);
+    }
+}

src/main/java/de/srendi/cctutorial/cctutorial/CCtutorial.java

@@ -0,0 +1,22 @@
+package de.srendi.cctutorial.cctutorial;
+
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.Mod;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+// The value here should match an entry in the META-INF/mods.toml file
+@Mod("cctutorial")
+public class CCtutorial {
+
+    //Our mod id
+    public static final String MODID = "cctutorial";
+    // Directly reference a log4j logger.
+    private static final Logger LOGGER = LogManager.getLogger();
+
+    public CCtutorial() {
+        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);
+    }
+}

src/main/java/de/srendi/cctutorial/cctutorial/Registration.java

@@ -0,0 +1,42 @@
+package de.srendi.cctutorial.cctutorial;
+
+import com.google.common.collect.Sets;
+import net.minecraft.block.Block;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.tileentity.TileEntityType;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+
+import java.util.function.Supplier;
+
+public class Registration {
+
+    public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, CCtutorial.MODID);
+    public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, CCtutorial.MODID);
+    public static final DeferredRegister<TileEntityType<?>> TILE_ENTITIES = DeferredRegister.create(ForgeRegistries.TILE_ENTITIES, CCtutorial.MODID);
+
+    //Blocks
+    public static final RegistryObject<Block> CC_BLOCK = register("tutorial_block", CCBlock::new);
+
+    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().group(ItemGroup.REDSTONE)));
+        return registryObject;
+    }
+
+    //Tile Entities
+    public static final RegistryObject<TileEntityType<CCTileEntity>> CC_TILEENTITY = Registration.TILE_ENTITIES.register("tutorial_block", () -> new TileEntityType<>(CCTileEntity::new, Sets.newHashSet(CC_BLOCK.get()), null));
+
+    //Register our stuff
+    public static void register() {
+        IEventBus modEventBus = FMLJavaModLoadingContext.get().getModEventBus();
+        BLOCKS.register(modEventBus);
+        ITEMS.register(modEventBus);
+        TILE_ENTITIES.register(modEventBus);
+    }
+}

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

@@ -0,0 +1,40 @@
+
+modLoader = "javafml" #mandatory
+loaderVersion = "[36,)" #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 = "cctutorial" #mandatory
+version = "1.0" #mandatory
+# A display name for the mod
+displayName = "CCtutorial" #mandatory
+# The description text for the mod (multi line!) (#mandatory)
+description = '''
+    A mod to show you, how the magic of cc works.
+'''
+# A dependency - use the . to indicate dependency for a specific modid. Dependencies are optional.
+[[dependencies.cctutorial]] #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 = "[36,)" #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.advancedperipherals]]
+modId = "computercraft"
+mandatory = true
+versionRange = "1.95.3"
+ordering = "NONE"
+side = "BOTH"
+[[dependencies.cctutorial]]
+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.16.5"
+ordering = "NONE"
+side = "BOTH"

src/main/resources/pack.mcmeta

@@ -0,0 +1,7 @@
+{
+  "pack": {
+    "description": "cctutorial resources",
+    "pack_format": 6,
+    "_comment": "A pack_format of 6 requires json lang files and some texture changes from 1.16.2. Note: we require v6 pack meta for all mods."
+  }
+}