Create a new Watson Conversation service in Bluemix.

You will need to sign up for a Bluemix account if you don’t have one already.

Navigate to “Catalog” and search for “Conversation”, select it from the results and create a free plan.

Get the credentials from your service.

After your conversation service has been created, you will be able to get the username and password for the service from the “Service credentials” tab → “View credentials” dropdown. Record these now, you will need it later when we start coding your application.

Create a new Workspace for your application.

A workspace is the way you can express a dialog. Your Watson Conversation service may contain many workspaces for all of your user flows.

Under the manage tab, select “Launch tool”. Create a workspace and name it “Sandwich shop.”

Create intents.

Intents are the ways Watson understands the user’s intent. In other words, you can train the Watson Natural Language classifier with a bunch of examples of ways of expressing an intent like “ordering a sandwich”, and in the future, even though your users won’t necessarily write their requests exactly how you specified it, through training the language model Watson will select the intent if that request matched it within a certain threshold level.

So for our example, you can add a new intent called “#order” and the values can be:

Create entities.

Entities are the specifics of information that can come in through the intents. Entities are most likely nouns that help you better service the request. For our example, we will be creating some entity types like, @toppings and @meats.

Try adding some @toppings now:

Design the dialog.

You can now design your dialog with the intents and entities you created earlier. Your must create triggers that based on whether it is matched or not, will yield a response from Watson.

Test your conversation.

It’s probably a good idea at this point to test your conversation and make sure it’s working properly. You can press the dialog bubble icon on the top right to start a simulation of your conversation.

Get the workspace ID.

Before we start making modifications to your GameOn room, copy your workspace ID. Follow the menu option to workspace, select the “drawer” icon next to the workspace card and choose “view details” in order to see your workspace ID. You will need this ID later when you connect your code to this workspace.

Fork and clone the sample-swift-room

$ git clone https://github.com/<your-forked-repo>/sample-room-swift.git

Add the Watson SDK as a dependency in your project.

In your Package.swift file, add to the bottom of the list of dependencies the following library:

.Package(url: "https://github.com/watson-developer-cloud/swift-sdk", majorVersion: 0)

In Source/SwiftRoom/RoomImplementation.swift, import the Conversation service module.

import ConversationV1

Set some of the settings for your service. If you recall from the prerequisites section above when setting up the Conversation service, you saved your credentials and workspace ID. You will need these values at this point.

let username = "username-goes-here"
let password = "password-goes-here"
let version = "2017-04-19"  // use today's date for the most recent version
let workspaceID = "workspace-id-goes-here"

Add a Conversation service wrapper to your RoomImplementation class to connect to your Conversation workspace. The wrapper is an object you will use to send input to, and receive output from, the service.

let conversation = Conversation(username: username,
                                password: password,
                                version: version)

Add a Context for the conversation.

A context allows the conversation to hold state. For instance, when you are finished selecting the meat on your sandwich, Watson continues the conversation with asking about toppings. Since REST calls are stateless by nature, we can hold state by keeping a state ID that is updated whenever you get a new response back.

var context: Context?

Set the context of the conversation on application start.

public init() {

       conversation.message(withWorkspace: workspaceID,
                            failure: failure) {
              response in

              self.context = response.context
       }

}

RoomImplementation.swift will now look like this:

import LoggerAPI
import Foundation
import KituraWebSocket
import SwiftyJSON

import ConversationV1

let username = "username-goes-here"
let password = "password-goes-here"
let version = "2017-03-22"
let workspaceID = "workspace-id-goes-here"
let conversation = Conversation(username: username, password: password, version: version)

let failure = { (error: Error) in print(error) }

public class RoomImplementation {

    var context: Context? // save context to continue conversation
    let roomDescription = RoomDescription()

    public init() {

         conversation.message(withWorkspace: workspaceID, failure: failure) { response in
                print(response.output.text)
                self.context = response.context
            }

    }
    …

In the handleMessage method in RoomImplementation.swift, there is a switch block on the message target. In the case of target == “room”, the message is either a command or a chat. We want to send the chat messages to the Conversation service and then send Watson’s response back to the client.

Add the Watson code in the “else” block.

         if messageIsCommand(content: content) {
                try processCommand(message: message, content: content, endpoint: endpoint, connection: connection)
         }
         else {

		try endpoint.sendMessage(connection: connection,
                                         message: Message.createChatMessage(username: username, message: content))

                let request = MessageRequest(text: content, context: context)
                conversation.message(withWorkspace: workspaceID, request: request, failure: failure) {
                    response in
                    print(response.output.text)

                    if response.output.text.count > 0 {

                        let text = response.output.text[0]
                        try! endpoint.sendMessage(connection: connection,
                                         message: Message.createChatMessage(username: "Watson", message: text ))

                    }

                    self.context = response.context
                }

            }

That should be it! You can see a working sample [jkingoliver-github}[here].

cd into your working directory and compile your project.

$ cd sample-room-swift
$ npm install
$ gulp

Run and test your server locally.

$ .build/debug/GameOn

Make your room public.

For Game On! to include your room, you need to tell it where the publicly reachable WebSocket endpoint is. This requires two steps:

• {deployroom}[deploy your room to Bluemix as a Cloud Foundry application], and then
• register your room with the game.