Implementing FormFlow for Microsoft Node.js BotBuilder SDK

The C# BotBuilder SDK supports a really cool thing call FormFlow. With this, you can write a C# class which is used as a base for a dynamically generated series of question/answer pairs, in order to fill the properties of this class. For instance, do you want to create a burger ordering bot? Just add a enum for BreadOptions, an enum for Toppings, a choice of SauceOptions etc. This is a really cool feature of the C# BotBuilder SDK which allows you to quickly develop a chatbot with predefined rules and flow. As the Node.js BotBuilder SDK lacks this functionality, I tried to replicate it since I needed it for a simple project I’m building. Meet formflowbotbuilder.

Read More »

Using AIML files with Microsoft Bot Framework

A few days ago, I was pitching Bot Framework to an interested party, when a question came up: “Does the Bot Framework support AIML files? We have a lot of them and we are wondering whether we could use them”. Honestly, I didn’t have a clue what AIML is, so I decided to run a quick search.

Turns out that AIML stands for Artificial Intelligence Markup Language and, as Wikipedia nicely mentions it, it is an XML dialect for creating natural language software agents. AIML was used to power Alice Bot back in 1995 (this was one of the first chat bots available to the public). Moreover, AIML powered a discussion with Captain Kirk of Enterprise (ho there, Star Trek fans!). Alice AIML files are open source, you can find them here.

Read More »

Accessing Azure Table Storage Service from a Unity game

Azure Table Storage Service is an inexpensive, highly available NoSQL key-value store. It can store petabytes of structured data, supports a flexible data schema and Azure team provides a REST API. So, I thought, why not extending my Azure Services for Unity library with support for access to Azure Table Storage Service from any Unity game? Well, here we are, our latest commit to the repository contains access methods for the service.

Read More »

Hosting a Bot Framework chat bot on a Docker container on Azure App Service on Linux

Yeah, title is long but nevertheless you get the point of what I’m going to describe. So, to cut a long story short, last weekend I attended a hackathon where my teammates and I built a PoC of a movie quiz chat bot. At the end of the hackathon, we attempted to “dockerize” it and host it on App Service on Linux (currently on preview). This blog post documents the process.

Some prerequisites

  1. Great video intro (+demo!) of chat bots and Microsoft’s Bot Framework, an easy and flexible way to create an awesome chat bot
  2. You can develop a chat bot in many ways, check here for the Bot Builder Node.js SDK
  3. Check out my blog post about building a chat bot for Greek startup ParkAround
  4. App Service is Azure’s PaaS (Platform as a Service) offering, it supports Windows and Linux (preview). Check here for App Service on Linux documentation
  5. You can deploy apps as files into App Service, if you want to deploy a Docker container check here for Docker containers on App Service on Linux

Read More »

Developing a Bot for ParkAround using Microsoft Bot Framework

In this blog post we’ll discuss how we built a Bot for ParkAround using Microsoft Bot Framework and hosted it in Azure platform.

ParkAround is a prominent startup in Greece which allows you to book your place in hundreds of car parks in the cities of Athens/Thessaloniki as well as the airports of Barcelona and Malaga. We worked with ParkAround to build a Bot that allows the user to book a parking spot at the airports of Athens and Thessaloniki. You can currently chat with the Bot on Facebook’s Messenger platform, whereas support for other channels (e.g. Skype) will be rolled out in the next few weeks.

Bot has the name of “Mitsaras, the parking assistant” (“Mitsaras” being the folk/friendly name for “Dimitris”) and you can chat with it here: https://www.messenger.com/t/parkaroundbotBeware, bot currently uses Greek language only since it targets Greek audience for now. So, don’t get confused if it’s all Greek to you!

To develop the bot, we used Microsoft’s Bot Framework which allows you to create a bot that will interact with various conversation channels, such as Messenger, Skype, Slack and other services. Bot Framework supports a REST API and has two SDKs, one for .NET and one for Node.js. As most Microsoft SDKs nowadays, both of them are open source. If you aren’t acquainted with Bot Framework SDK, please take a look at the extensive documentation in order to better understand the code segments listed below. Also, ParkAround is a BizSpark startup, so we naturally chose Azure App Service PaaS platform to host the bot, so we can easily scale up/out if needed.

Last but definitely not least, before we continue with bot’s internals, we should mention that this work is a collaboration between myself, my colleague Sophia Chanialaki and ParkAround’s CEO, John Katsiotis.

Read More »

An update to Azure Services for Unity library

During the past few months I’ve pushed some updates to my Azure Services for Unity library. The goal of this library remained the same: use Azure App Service Easy Tables and Easy APIs easily from a single codebase without any additional Unity addins, I really want this to be a plugin free experience. Here, I’ll summarise some of the main updates in the library. For an intro to the library and an intro on Easy Tables and Easy APIs, check out my original blog post here. Moreover, check here for how to access Azure Table Storage Service from within a Unity game.

Read More »

Use Azure Services from Unity

tl;dr – Azure and Unity, really?

Azure Services for Unity is a small library (currently in beta) that provides you an easy way you to access an Azure database and/or APIs (hosted on Azure App Service) via the Unity game engine. You can use it to save highscores, status messages, send messages between players and much more. As there are no plugins involved, library is cross-platform and can run everywhere that Unity runs (editor, standalone players, iOS, Android, Windows Phone and Windows Store Apps). Of course, it is completely open source and free to use. It was last tested on Unity 5.3.4f1. Current version 0.0.2.

Update: for some additions and fixes to the library check out my newer blog post here
Update2: check this blog post for an addition to the library that allows you to access Azure Table Storage Service.

Intro

Azure App Service is quite an interesting cloud platform to develop web and mobile apps. One can easily create web apps that scale, create mobile apps backend and integrate with existing services either on the cloud or on-premise. App Service also has a very simple mechanism to store data and use various APIs, called Easy Tables and Easy APIs, respectively. Those can be rather helpful to game developers that want to create a backend for their game. In this blog post, we’ll describe a small library that allows a game written in Unity to access them.

Creating an Azure App Service and database

We assume you have an active Azure subscription. If not, refer to the last paragraph on this blog post to find out easy ways to get one. First, you’ll need to visit the new Azure portal at http://portal.azure.com.

Read More »

Raspberry Pi, Sense Hat, Azure IoT Hub, oh my!

In this blog post, we’ll post a very simple tutorial about gathering some simple data from a Sense Hat on a Raspberry Pi, post this data to Azure IoT Hub, parse them though Azure Stream Analytics and insert them into a simple Azure SQL Database table. This blog post helps as a tutorial for Azure IoT Hackathon we organized in Athens, on 18/3/2016.

  • On the hardware side, we’ll use a Raspberry Pi 2 and a Sense Hat
  • Creating a new Universal Windows Platform application
  • Write some code to get the temperature reading from the Sense Hat
  • Post the temperature/pressure/humidity reading from Sense Hat to Azure IoT Hub
  • A Stream Analytics job will store the temperatures on an Azure SQL Database

We’ll start by creating a new Azure IoT Hub, so we can connect our Raspberry to it.

Read More »

Creating an infinite 3D runner game in Unity (like Temple Run, Subway Surfers), part 2

This is the second part of  an infinite 3D runner game tutorial. If you haven’t read the first part, you’re highly encouraged to do it by clicking here. As always, you can find the source code here on GitHub and play the game here on a WebGL enabled browser.

The levels

In the second and last part of the tutorial, we’ll see how the two game levels were built. We’ll begin with the “straight paths” level.

Straight Paths Level

Let’s take a look at the objects contained in our game hierarchy.

1
GameObject hierarchy in the straight paths level.

First, there is the straight path game object which, by nature, is wider than the one in the “rotated paths” level. The path is a prefab (as designated by its blue color) and all subsequent paths will be clones of this one. Scene also contains some cubical shaped 3D objects (named Cubes), which act as floor of our path. It also contains the NewPathSpawn game object (a simple location in the 3D space), and some other locations called SpawnPoints. The SpawnPoints are positions in which new stuff will be generated. This stuff can be either a candy, or obstacle, or nothing at all.

Recall that Max runs from path to path. As we are not generating all paths at the beginning of the game (because we want to save on memory and mainly because we do not know how far in the game the player will proceed, i.e. how many paths to generate), we need a mechanism to generate the N+1 path, where N is the path that Max currently steps on. We’ve used a simple trigger BoxCollider to implement this. When Max collides with it, a new path is generated via the PathSpawnCollider script (described in a while). In the straight paths level, the new path is instantiated in the “NewPathSpawn” position, which conveniently happens to be positioned at the far end of the current path.

2
When the player collides with the PathSpawnCollider, a new path is generated on the NewPathSpawn position.
3
The NewPathSpawnPosition, where a new straight path will be instantiated.

The Character game object holds our Camera and the Max model. It also has a Character Controller component (which allows us to easily move our object) and a CharacterSidewaysMovement script (described below). Making the Character game object move will move both Camera and Max (since they are child game objects). This is the classic way of making 3rd person games, since in this way, camera will always be at the same position during the game, behind and a bit higher than Max.

The Canvas game object holds our simple UI (two Text objects) whereas the Directional Light is a simple light and the ScriptHolder game object holds our GameManager singleton script, which was described in the first part of the tutorial.

PathSpawnColliderScript

This script is used on both levels in order to generate the next path, following the one Max is currently running on.


public class PathSpawnCollider : MonoBehaviour {

    public float positionY = 0.81f;
    public Transform[] PathSpawnPoints;
    public GameObject Path;
    public GameObject DangerousBorder;

Script begins by declaring some public variables, to be set outside the script in the Unity editor.
– PositionY is used to properly place the redBorder on the Y axis
– The PathSpawnPoints array is used to host the locations that the next path and borders will be instantiated. In the “straight paths” level the array will have only one member (since we’ll only instantiate the next path) whereas in the “rotated paths” level the array will hold three locations, in one of which there will be the new path and in the rest two there will be the red borders that will kill Max upon collision
– The Path object holds the path prefab
– The DangerousBorder array holds the RedBorder prefab in the “rotated paths” level whereas it is null in the “straight path” level (where we do not need it)


  void OnTriggerEnter(Collider hit)
    {
        //player has hit the collider
        if (hit.gameObject.tag == Constants.PlayerTag)
        {
            //find whether the next path will be straight, left or right
            int randomSpawnPoint = Random.Range(0, PathSpawnPoints.Length);
            for (int i = 0; i < PathSpawnPoints.Length; i++)
            {
                //instantiate the path, on the set rotation
                if (i == randomSpawnPoint)
                    Instantiate(Path, PathSpawnPoints[i].position, PathSpawnPoints[i].rotation);
                else
                {
                    //instantiate the border, but rotate it 90 degrees first
                    Vector3 rotation = PathSpawnPoints[i].rotation.eulerAngles;
                    rotation.y += 90;
                    Vector3 position = PathSpawnPoints[i].position;
                    position.y += positionY;
                    Instantiate(SpawnBorder, position, Quaternion.Euler(rotation));
                }
            }

        }
    }

When Max collides with the PathSpawnCollider game object, game engine randomly chooses whether the next path will be straight, left or right. In the case of the “straight paths” level, we have only one entry in the PathSpawnPoints array (which corresponds to the straight location), so randomSpawnPoint will be 0 and the next path will be instatiated at the straight location. In the “rotated paths” level, we instatiate the next path on the chosen location and we also instantiate the RedBorder prefabs on the other two locations, while we are rotating them by 90 degrees to make them fit properly.

Read More »

Creating an infinite 3D runner game in Unity (like Temple Run, Subway Surfers), part 1

tl;dr: check the code here on GitHub and play the game here on a WebGL enabled browser

This is another blog post/tutorial in my Unity game development tutorials series, the first one being about a 3D game. Here, we’ll explore how to make a very special kind of game, an infinite 3D runner game. Since this post became somewhat big, it is split in two parts (check the second part here).

Chances are high that you have played an infinite 3D runner game at least once in the past years, when this genre became known and successful. These games have a 3rd person camera pointing at the main character who is running towards one direction in a 3D environment, while he tries to avoid various hazardous objects popping around that can kill him upon collision. This environment can be either a big path in which the character can change lanes like in normal traffic (such as in the game Subway Surfers) or can swipe left or right in various points to correctly follow the designated path (like in Temple Run).

b1
Subway Surfers game
temple_run-0_cinema_640-0
Temple Run game

This tutorial we’ve made contains two levels that feature both game mechanics. As you’ll see, these levels share some similarities but also have some notable differences. As usual, you can find the code here on GitHub and play the game here on a WebGL enabled browser.

Assets credits

Since this tutorial is a 3D game, I wouldn’t have something great to show without any 3D assets. Since I have no experience in 3D assets creation, I needed to find some premade ones. What other place to look for that than Unity’s Asset Store? The Asset Store is a wonderful place, where you can easily find low cost (even free) assets for your game. This tutorial would not be made possible if not for these great assets we used:

Game overview

Upon game launch, player can see a screen with two simple buttons. He can choose one of the two game levels, either the “rotated paths” level or the “straight paths” level.

In the “rotated paths” level, Max follows a narrow platform (“path”) till he reaches its end. At some point before this happens, the game engine randomly chooses where to place the next platform, either left, right, or straight ahead. The point where this next path will be placed is at the end of the current path. When Max reaches the current path’s end, player has to swipe in order to go left or right, or just continue on the main path. If player does not swipe in time, then Max may collide with the wall and die (the red walls, depicted in the picture below). When walking on the path, Max can pick the candy that appears in front of him to get some points to increase his score,  he can (must!) jump to avoid obstacles and, of course, he can swipe left or right when the platform is about to rotate in order to follow the new path.

rotated
Rotated paths level

Important: You’ll see me refer to player’s input as ‘swipe’. As you’ll see below, this game has two input methods (either arrow keys or swipe in a touch screen). So, when we say ‘swipe’, this implies either arrow keys usage or regular swipe usage on a touch screen.

In the “straight paths” level, Max follows a wide platform and continuously moves at a straight direction. Player can swipe left or right to move sideways along imaginary lanes (like in normal traffic), while he can pick candy to increase his score. He also must avoid randomly popping obstacles either by moving on a different lane or by jumping over them. If Max falls into an obstacle, he dies and the game is over.

straight
Straight paths level

In both cases/levels, the game can theoretically continue indefinitely. Game is over when Max falls onto a red wall (rotated paths level) or collides with an obstacle (both levels). When this happens, player can tap the screen to restart the game. Finally, as you can easily see, score is increasing as Max continues to be alive and keep running.

Read More »