We just published a course on the freeCodeCamp.org YouTube channel that will teach you how to create a fully-functional Minecraft clone using React, JavaScript, and Three.js.

Daniel Bark created this course. Daniel is a senior software engineer from Sweden and is an expert with Three.js.

Three.js is a JavaScript 3D library that allows developers to create and display animated 3D computer graphics in web browsers.

In this course, you will create a game that supports five Minecraft block types. It will include moving, jumping, switching and placing blocks, saving, and more.

You will learn about many React concepts such as useState, useEffect, useRef and custom Hooks for State management. And you will be able to apply the principles to create other 3D games in JavaScript.

This is not in the game.

Here are the sections covered in this course:

• Boilerplate
• Sky
• Textures
• Ground
• Player
• Keyboard input
• Movement
• First person camera
• State management
• Cube component
• Add/Remove Cubes
• Texture Selector
• Save world
• Hover cubes
• Outro

Watch the full course on the freeCodeCamp.org YouTube channel (2-hour watch).

Forge is a modding API. Minecraft Forge (or Forge for short) is a layer between our code and Minecraft itself.

We cannot directly ask Minecraft to add items and do special cool things. That’s why we need an API (application programming interface) to handle our logic and make Minecraft recognise it.

Sounds cool! How do I get started?

• You’ll need the JDK (Java development kit) which is a set of libraries, tools and the runtime environment to make Java programs and run them.
• A Minecraft account which can be bought from their official website. (https://minecraft.net/en-us/store/)
• An IDE (Eclipse or IntelliJ are recommended for Minecraft development)

After installing/acquiring these pieces of software, download your desired Forge version at https://files.minecraftforge.net/.

Tip: Hover over the information button and press direct download to avoid an Adfly virus!

Once you have downloaded this ZIP you’ll be able to unzip it. Do so and cd (cmd/command) into the directory with all of the Forge files. Run gradlew setupDecompWorkspace.

Next up is picking your IDE (integrated development environment).

• Eclipse? gradlew eclipse.
• IntelliJ? Import the build.gradle file in your IntelliJ setup.

Okay now what? How do I add fancy new items? (Basic mod setup)

Hold your horses. There’s much more to it. You’ll have to texture an item of course, add code and so much more! In this article we’ll only look at some simple sample code which I also use for my own mods. Here it is!

`@Mod.EventBusSubscriber @Mod(modid = Version.MOD_ID, name = Version.MOD_NAME, version = Version.VERSION) public class TheMod {

public static ModMetadata metadata;

public static File baseDir;
public static Configuration config;

@SidedProxy(clientSide="com.ciphry.client.ClientProxy", serverSide="com.ciphry.common.CommonProxy")
public static CommonProxy proxy;

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event) {
    proxy.preInit(event);

    baseDir = new File(event.getModConfigurationDirectory(), MOD_ID);
    config = new Configuration(event.getSuggestedConfigurationFile());

    if (!baseDir.exists())
        baseDir.mkdir();
}

@Mod.EventHandler
public void init(FMLInitializationEvent event) {
    proxy.init(event);

}

@Mod.EventHandler
public void postInit(FMLPostInitializationEvent event) {
    proxy.postInit(event);
}

Use this code as you please. Just make sure you edit, for instance, the proxy strings and more. This should give you a basic overview of what a basic mod class looks like.

In this article, I'll discuss how we reached young audiences by combining robotics with e-sports.

What on Earth?

Ever heard of anything like it before? Me neither. The robot was created as part of Futurice’s project with Yle, the national broadcast company of Finland.

Yle produces content for TV, radio, and the web. It has a broad reach of older audiences, but has had trouble reaching younger ones. The goal of this project was to use new technology to reach young audiences — specifically teenagers.

Yle’s content has traditionally been non-participatory: the performers perform, and the audience watches. However, younger audiences generally view content that is more participatory, such as YouTube videos or streams.

We wanted to create participatory content — the performer should interact with their audience. Yle’s journalists specialized in teenage audiences pointed out that gaming and e-sports are popular content. We realized that gaming was the perfect context for this: the audience could play together with the performer. We wanted to explore what an entertainer, or even influencer of the future could look like. So why not create a streaming robot gamer?

Yle’s journalists and Futurice’s roboticists coming up with the idea of a robot gamer

First drafts

What Was This Robot Like?

We chose two games for the robot to play: Flappy Bird and Minecraft.

Flappy Bird was a cult game that had a brief period of extreme popularity in 2014. We chose Flappy Bird because the mechanisms of the game are simple, and allowed for the game to be played with machine learning. We wanted to try a neuroevolution algorithm, which evolved new birds into the game based on which birds did best in the previous generation. This way we could see how the audience reacted when a computer was playing the game.

We chose Minecraft for its communal features, which allow interaction between players. Players can co-operate or fight each other, trade with each other, and chat with each other. They can “grief” each other — i.e. be a nuisance. Players can also mine materials, and turn them into items, or even build cities. They can store precious things, farm the land, herd animals, and fight monsters.

Minecraft also has a material called redstone, which players can use to build logic. Effectively, players can build an entire computer inside of Minecraft. Poetic, eh?

For playing Minecraft, we decided that a human should control the robot. The game is complicated, and having authentic interactions with other players would require a human on the other end.

Flappy Bird and the robot

Our team of Yle’s journalists and Futurice roboticists defined some clear advantages for using a robot in this context:

• A robot is tireless — it can play forever, and provide content 24/7. It’s an ideal streamer.
• A robot can be gender neutral. Gamers and gaming audiences are typically male, but a gender neutral robot could potentially attract more diverse audiences.
• A robot can reflect gamers’ behaviour, stirring emotions. Gaming culture is often aggressive. The robot could be aggressive in turn, making gamers reflect on their own behaviour.
• A robot can interact within the game and chat simultaneously. Humans are limited to one output, a robot can have several.

Testing our streaming equipment and having problems with interference from the robot’s face screen.

We decided on a six hour gaming session, alternating between Minecraft and Flappy Bird. To nail down the user experience for the session, we defined guidelines for our design of the robot:

• Experimental user experience — the user should be able to explore within the interaction with the robot.
• Streamers are usually strong characters. The robot is a character with a strong personality.
• The robot can cause “WTF?” reactions in players. We wanted the experience to be memorable, rather than bland.
• The culture and space of online gaming is unique, and should be designed for.

Based on these guidelines, we created the character IQ_201. IQ_201 is based on aggressive online gamers that are convinced of their own superior intelligence (see this meme about having an IQ over 200). The robot would be rude and reactive, meant to get a reaction out of adolescents interacting with it.

Before implementation, the team also wanted to take into account some ethical considerations:

• Transparency about how the robot is operated is needed. If this robot was going to be put into production, users should be able to find information on how it works.
• The robot should treat all the players the same. This was also part of the decision to make the robot appear gender neutral. And due to the sometimes angry, hateful, even racist or sexist culture of gaming, we needed to design the robot’s personality carefully. It could be out-there, even rude, but never hateful. We didn’t want any heated gaming moments.
• The robot should be rude, but not too over-the-top.
• The chat needed to be moderated. As stated, gaming culture can be toxic. We wanted to keep a careful eye on both the Minecraft and Twitch chats, to ensure no shenanigans would go on.

To fulfill all these requirements, we selected the Furhat robot. The Furhat robot had a relatively easy-to-use teleoperation interface, which allowed for the user to input text to be turned into the robot’s speech, as well as perform gestures at the click of a button.

Flowers and Violence

We had a 6 hour stream, starting at 2pm and ending at 8pm. We alternated between games: 2-3pm was Flappy Bird, 3-5pm Minecraft, 5-6pm Flappy Bird, then 6-8pm Minecraft again. This schedule allowed the robot operators playing Minecraft to have a much-needed break in the middle.

Our robot

In the beginning, a few people joined. Gradually, we gained more and more people. We reached our peak at 4:20 — 49 simultaneous viewers on Twitch. Overall, we had 431 unique viewers. In Minecraft, there were around 30 active players. Considering how minimal our advertising was (one forum post and a few tweets), we were pleasantly surprised by the turnout.

The Minecraft sessions were directed by two robot operators (myself and another Minja). The other Minja played Minecraft, and I operated the robot’s voice and gestures. A third person was answering messages on chat.

Minecraft was overwhelming. The robot’s provocative character provoked teenagers into repeatedly killing it. After fleeing to the mountains to be with the llamas a couple of times and being killed yet again, we modified the robot’s behaviour to be more friendly. We wanted to create more constructive interactions.

Two Minjas as robot operators

Toward the end of the second Minecraft stream, teenagers were cooperating with the robot. They protected it from the few aggressive players that were left, and gave it gifts such as flowers. Some even complimented the robot directly, to make it happy. The players started following the robot, agreeing to cooperate when it initiated building a lighthouse. They also built a house, and captured and named a llama: IQ_201 Junior.

There were two clear factions in the game: some were intent to kill the robot throughout the entire game, and some protected it throughout. Some became more comfortable with the robot as the stream went on, switching sides. Either way, the robot aroused strong emotions. Teenagers sought out genuine interaction with it. No-one ignored the robot, or was bored.

Discussions about how the robot worked were had throughout the stream. No-one asked the robot itself though, maybe out of respect or fear of annoying it. Discussions focused on whether the robot was “real”, i.e. whether it was truly automatic, or a human was operating it. Was it typing with actual physical hands? Or had it “hacked into” the game and was playing via code?

“I Will Miss You Robot!”

16 people responded to our survey afterward. 80% of players were under 18, most were 13 to 15-year-olds. 80% of players interacted with the robot. This was extremely positive, we succeeded in making a robot that was compelling to users. 75% of players rated the robot as 3 or above, out of 5.

Viewers over time

We collected comments from the players from the survey, as well as the Minecraft game chat. They are translated from Finnish, and reflect some of the thoughts our players had on the robot.

The critical first:

“It was pretty fun and cool. But it somehow felt like a set-up.” [Referring to the robot possibly having a human operator]

A lot of players were wondering how the robot actually worked. This comment brings us back to the ethical consideration we talked about earlier: transparency about how the robot was operated.

Though we intended to be transparent at first, we decided to not inform users of the robot’s teleoperated nature for this first pilot. We made this choice because we wanted to keep the “suspension of disbelief” of the user active, meaning that we wanted the participants to play along with the fact they were talking to a “real robot” (an autonomous robot) (Duffy & Zawieska, 2012).

The negative response we received regarding the unclarity on the robot’s functioning made it clear to us that if this pilot were extended, it is highly important to be more transparent. It is possible to hold suspension of disbelief and be honest of the robot’s operation simultaneously (we do all know that television shows are not reality, after all).

“The robot was a bit simple in certain things, and sometimes talked meanly to people, and was condescending. This was a bit anxiety inducing… Was this intentional?”

Some players felt that the robot’s rude behaviour crossed the boundary into condescending. They wished that the robot would be more considerate in the future. This indicates that even a robot can hurt feelings. In future versions, making IQ_201 more empathic, and less focused on the superiority of robots over humans, could have positive results.

“The robot looked a bit blue in the face, and its voice was a bit weird.”

Two teenagers did not enjoy the robot’s appearance and voice. One remarked especially about its blue face, asking why we did not make it “normal colored”.

This may have been due to the robot falling into the “uncanny valley” for these players. Uncanny valley is a theory developed by robotics researcher Masahiro Mori (Mori et al., 2012). His theory posits that as the appearance of a robot approaches human-likeness, there is a dip when the appearance gets very close. Zombies and corpses fall into this valley.

To get rid of this effect with our robot, it could be wise to alter the robot’s appearance and voice in future solutions.

The Uncanny Valley by Masahiro Mori. Wikimedia commons.

And then the positive:

“It was really interesting gaming with the robot. :) Hopefully in the future we can have this type of event again. :)”

The majority of the teenagers enjoyed playing with the robot, and watching the stream. Their feedback complimented the robot’s sense of humour, and its playing skills. A continuation of the pilot would surely find an interested audience.

[to the robot] “Some people have trouble with new things. In this case, these players are having trouble with a robot, since you’re new.”

This player consoled the robot in-game, as other players were giving it a hard time by continuously killing it. This comment was moving: the player felt bad for the robot, and thought the robot might feel bad as well, attempting to change that. This is a clear empathic response toward the robot.

[to the robot] “I will miss you robot!”

A few players gave the robot heartfelt goodbyes when it left Minecraft. These players found the robot approachable, and even formed an emotional bond with it. This means we succeeded in creating a compelling character, even during what was only a 6 hour stream.

For future builds of the robot, the players should be informed how the robot operates. This could help them calibrate an appropriate level of emotional bond to the robot.

Are Robotic Influencers Our Future?

Players took an active interest in the robot. They approached it, interacted with it, and formed opinions on it. The robot also provoked emotional reactions — both positive and negative. Some participants really loved the robot and wished for more interaction in the future, and some were heavily critical.

This indicates that robot influencers have the capacity to affect our emotions — whether this capacity will ever reach the level of human entertainers, I do not know. Whether that is desirable, I also do not know.

What positively surprised me was that the young user base of the robot were media literate: they critically examined the robot’s mode of operation. The players had a good idea of what is possible with AI today, and what is not. They were not easily duped.

This makes me hopeful for our future, whether it contains robotic entertainers or not. When viewers remain critical, they can understand that robots are machines with no actual emotional capacity, even if viewers do choose to suspend disbelief.

Interacting with the robot can be though of as a form of parasocial interaction for the viewer — where the viewer may feel that their relationship with the robot is close — even though it is not truly reciprocal. This in itself is not necessarily harmful, as long as we are honest about what the relationship truly is. We should understand that robots are putting on a performance to elicit emotions in us — like human entertainers do

A video about the project.

First published on Towards Data Science.

Duffy, B. R., & Zawieska, K. (2012, September). Suspension of disbelief in social robotics. In 2012 IEEE RO-MAN: The 21st IEEE International Symposium on Robot and Human Interactive Communication (pp. 484–489). IEEE.

Mori, M., MacDorman, K. F., & Kageki, N. (2012). The uncanny valley: The original essay by Masahiro Mori. IEEE Spectrum, 98–100.

Usually, modifying Minecraft requires coding in Java, and a lot of scaffolding. Now you can write and share Minecraft mods using TypeScript/Javascript.

ScriptCraft is an open source JavaScript Minecraft modding library, and we’ve written support for TypeScript, and a bunch of tooling to create a familiar developer experience for those coming from JavaScript land (including Yeoman and NPM).

In this article I’ll walk you through getting set up and building your first TypeScript Minecraft mod in under an hour — as little as 20 minutes, depending on your internet connection.

In this video (click here if the embed doesn’t work above) I show you how to write a basic Minecraft mod using TypeScript, and run it on your local computer with both a desktop and a mobile Minecraft server.

Below, I’ll walk you through the steps, with links to resources.

Prerequisites

You’ll need some software installed on your computer, to run the Minecraft server and the tools for writing your plugin. Install all of the four following:

• Docker — a containerisation solution.
• Node.js — a JavaScript execution engine and library.
• Portainer — a web-based GUI for managing Docker containers.
• Visual Studio Code — a code editor.

Minecraft Client

You need a Minecraft client to test your plugin.

Install at least one of the following:

• Minecraft Java Edition — a desktop client, if you want to test against a Bukkit server.
• Minecraft Pocket Edition — a mobile client, if you want to test against a Nukkit server (phone/tablet/Xbox). If you use this, you can use Minecraft Pocket Edition Bedrock Launcher to run the mobile client on your computer.

Installation

Now that you have the prerequisites installed, it is time to install the tools for the server and for plugin development.

1. Run the following command:

npm i -g smac yo generator-sma-plugin typescript

This will install four things on your computer:

• smac— Scriptcraft Modular Architecture Controller, a program that runs Minecraft Servers for your plugins.
• yo — Yeoman, a scaffolding tool.
• generator-sma-plugin — a Yeoman plugin for generating a new Minecraft plugin using the Scriptcraft Modular Architecture.
• typescript — the TypeScript transpiler, for converting TypeScript code into ES5 JavaScript that can run in Minecraft.

Create a new plugin

Now that you have the toolset installed, create a new plugin by running this command:

yo sma-plugin

This starts the plugin wizard:

➜ yo sma-plugin

     _-----_     ╭──────────────────────────╮    |       |    │      Welcome to the      │    |--(o)--|    │  Scriptcraft SMA Plugin  │   `---------´   │       generator by       │    ( _´U`_ )    │      Magikcraft.io!      │    /___A___\   /╰──────────────────────────╯     |  ~  |   __'.___.'__ ´   `  |° ´ Y `

? Your package name (workspace)

There is only one question you need to answer here — the name of your plugin. The wizard will create a new folder with the name of the plugin, and place the files for the new plugin in it.

This screencast shows you the process:

Scaffold a Minecraft plugin using Magikcraft
_Magikcraft.io allows you to write Minecraft plugins in TypeScript/JavaScript that will run on Desktop / Mobile._asciinema.org

Once the wizard completes, it emits a message similar to this (I chose the name my-sma-plugin in this example):

Edit your new plugin

Start Visual Studio Code and open the directory containing your new plugin.

Here is a description of the files in your new plugin:

• __tests__ — a directory containing unit tests for your plugin. These are run with Jasmine. Add more tests in here as you develop your plugin.
• .vscode — settings for Visual Studio code.
• autoload — any files in here are automatically executed when your plugin is enabled in the Minecraft server. Use this for initialisation tasks, registering event handlers, and so forth.
• lib — A place for you to put files that should not be automatically loaded (or that are required from your autoloaded files). If your plugin provides functionality to other plugins, then you export that via lib/index.ts.
• node_modules — modules from npm are installed here. You cannot use modules from npm that use V8 APIs (like fs or http). Many of the features that you need are provided by the Scriptcraft API and by the [@magikcraft/core](https://github.com/Magikcraft/magikcraft-core) package.
• .editorconfig — settings for the editor.
• .gitattributes — settings for git.
• .gitignore — files to ignore for git.
• .prettierrc — settings for code formatting.
• package-lock.json —versions of installed dependencies.
• package.json —configuration for this plugin, including dependencies and scripts.
• README.md — instructions for developing and testing your plugin.
• smac-nukkit.json — a configuration for running a Nukkit server with your plugin loaded.
• smac.json — a configuration for running a Bukkit server with your plugin loaded.
• tsconfig.json — the TypeScript configuration for transpiling your plugin to JavaScript.

Open autoload/index.ts:

This file is automatically executed when the plugin is loaded. Changes that you make here will be visible when you (re)load the plugin.

Start a development server

You can load your plugin in a development server. There are two servers that you can use — one for the desktop Java client, and the other for the mobile Pocket Edition client.

Start the desktop server

Run this to start a desktop server:

npm run start:bukkit

This will:

1. Pull the Bukkit server image from Docker Hub.
2. Start the Bukkit server with your plugin loaded.
3. Start the TypeScript transpiler to transpile your code to ES5.

You can now connect to the server with your desktop client. Click on Multiplayer then Direct Connect, then use the server address 127.0.0.1:

Start the mobile server

Run this command to start a mobile server:

npm run start:nukkit

This will:

1. Pull the Nukkit server image from Docker Hub.
2. Start the Nukkit server with your plugin loaded.
3. Start the TypeScript transpiler to transpile your code to ES5.

You can now connect to the server with your pocket edition client. Click on Play then Servers, then add a server with the address 127.0.0.1:

Reload changes to your plugin

As you change your plugin and save the changed TypeScript, it will automatically be transpiled to JavaScript.

To reload the changes in the development server, type the following in the server console:

ts onrefresh()

See the screencast below to see what this looks like.

Stop the server

To stop the server, type this command at the server console:

smac stop

See the screencast below to see what it looks like when you run this command.

Screencast: Start, Reload, and Stop

This screencast shows you starting the desktop server, reloading the plugin code, and also stopping the development server.

Start a Magikcraft Development Server
_Start a Magikcraft Development Server._asciinema.org

Further Resources

• Magikcraft on GitHub
• Magikcraft on YouTube
• MCT1 Source Code (Example Plugin)
• ScriptCraft on GitHub
• Bukkit API Docs