The Tickle Monster! - An Alexa Game

//The Tickle Monster speechlet. 
//This is a single file to make cutting/pasting/fiddling easier.
exports.handler = function (event, context) {
    //Security check. There's only one true Tickle Monster!
    var appId = "your app id";
    if (event.session.application.applicationId !== "amzn1.echo-sdk-ams.app." + appId) 
         context.fail("Invalid Application ID");
         
    parseEvent(event).then(
            function(parsedEvent){
                context.succeed(
                    //determine intent/see how to respond
                    getEventReponse(parsedEvent)
                );
            }, 
            //participants not found or invalid
            function(error) {
                context.succeed(
                    //send back a message saying the user needs to configure participants
                    buildSpeechletResponse(
                        {
                            message: "Please view the message from Tickle Monster in your Alexa app and choose <break time='1ms'/> 'Link Account' <break time='1ms'/> to set up participant names.",
                            shouldResetNames: true,
                            shouldEndSession: true
                        }
                    )
                );
            }
        ).catch(
            function(err){
                context.fail("Exception: " + err);
            }
        );
};

function getEventReponse(parsedEvent){
    //variables set according to conditions below and passed to a buildSpeechletResponse() function at the end.
    var responseInfo = {
        message: "",
        repromptText: "",
        intentName: parsedEvent.intentName,
        shouldResetNames: false,
        shouldEndSession: true
    };
    
    //if user only says "launch Tickle Monster", then give instructions on use.
    if (parsedEvent.isLaunchRequest) 
      launchMessage(responseInfo);
    else if(parsedEvent.intentName === "AMAZON.HelpIntent") 
      helpMessage(responseInfo);
    else if(parsedEvent.intentName === "AMAZON.StopIntent") 
      stopMessage(responseInfo);
    else if(parsedEvent.intentName === "WhosNextIntent")
      whosNext(parsedEvent, responseInfo);
    else if(parsedEvent.intentName === "ResetNamesIntent")
      confirmNameReset(responseInfo);
    //if user is responding to the question of whether or not to reset the names
    else if(parsedEvent.previousIntentName === "ResetNamesIntent"){
        if(parsedEvent.intentName === "AMAZON.YesIntent")
          yesResetNames(responseInfo);
        else if(parsedEvent.intentName === "AMAZON.NoIntent")
          noResetNames(responseInfo);
    }
    
    return buildSpeechletResponse(responseInfo);
}

function parseEvent(event){
    var promise = new Promise(function(resolve, reject) {
        //Technically, I hacked the OAuth protocol to store the possible names in the access token
        //to avoid having to worry about management of credentials or even a database.
        //Typically the access token is only a key used to then lookup user information (not a storage mechanism FOR user info),
        //I'm just being tricky.
        var unparsedParticipants = event.session.user.accessToken;
        
        if(unparsedParticipants && unparsedParticipants !== "")
        {
            var parsedParticipants = getParticipants(unparsedParticipants);
            
            var intent = event.request.intent ? event.request.intent.name : "";
            //track the previous intent so we can, for example, respond to a yes/no question
            var previousIntent = (event.session.attributes && event.session.attributes.previousIntentName);
            
            var isLaunchRequest = event.request.type === "LaunchRequest";
            
            //pass back the info we most care about
            resolve(
                {
                    event: event, 
                    participants: parsedParticipants,
                    intentName: intent,
                    previousIntentName: previousIntent,
                    isLaunchRequest: isLaunchRequest
                });
        }
        else {
            reject(Error("No participants found!"));
        }
    });
    
    return promise;
}

//See the response section of this document for more detail on what's going on here: 
//https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/alexa-skills-kit-interface-reference
function buildSpeechletResponse(responseInfo) {
    var speechletResponse = { 
        version: "1.0",
        sessionAttributes: { previousIntentName: responseInfo.intentName },
        response: {
            //note the use of SSML (speech markup). this can alternately be plain text if you say so in the response.
            outputSpeech: {
                type: "SSML",
                ssml: "<speak>" + responseInfo.message + "</speak>"
            },
            shouldEndSession: responseInfo.shouldEndSession
        }
    };
    
    //if we want to include repromt text (necessary for certification in case of LaunchRequest)
    if(responseInfo.repromptText) 
        speechletResponse.response.reprompt =
            {
                outputSpeech:{
                    type: "SSML",
                    ssml: "<speak>" + responseInfo.repromptText + "</speak>"
                }
            }
    
    //if we want to reset the names, then send a "LinkAccount" card to the Alexa app so the user can do so.
    if(responseInfo.shouldResetNames) speechletResponse.response.card = { type: "LinkAccount" };
    
    return speechletResponse;
}

//keep the responses varied so they seem less robotic (and more fun!)
//uses rudamentary SSML for pauses. see here for details:
//https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/speech-synthesis-markup-language-ssml-reference
var variedTickleResponses = [
    'Hmmm. <break time="1s"/> Maybe {TickleVictim}!',
    'I think you should tickle <break time="1s"/> {TickleVictim}!',
    '{TickleVictim}! Definitely {TickleVictim}!',
    'This time? <break time="1s"/> I think {TickleVictim}',
    'Maybe <break time="1s"/> {TickleVictim}!',
    'How about <break time="1s"/> {TickleVictim}!',
    'Let me think. <break time="1s"/> Hmmm. <break time="1s"/> {TickleVictim}!',
    'You want to know who\'s next? <break time="1s"/> {TickleVictim}!',
    'Better watch out {TickleVictim}, you\'re next!',
    '{TickleVictim}! Get {TickleVictim}!',
    'I think {TickleVictim} could use some tickles!'
    ];
    
    
//Message Configuration
//********"Alexa, Launch Tickle Monster"**************************
function launchMessage(responseInfo){
  responseInfo.message = "All right! Let's get tickling! Just ask <break time='1ms'/> \"who's' next\", or say \"reset the participant names\".";
  responseInfo.repromptText = "I didn't hear a response. You can ask <break time='1ms'/> \"who's next\", or say \"reset the participant names\".";
  responseInfo.shouldEndSession = false;
}

//********"Alexa, Ask Tickle Monster For Help"*********************
function helpMessage(responseInfo){
  responseInfo.message = "To choose the next person to be tickled, just ask <break time='1ms'/> \"who's next\". Otherwise say \"reset the participant names\" to enter who's playing.";
  responseInfo.repromptText = "I didn't hear a response. " + responseInfo.message;
  responseInfo.shouldEndSession = false;
}

//********"Stop"****************************************************
function stopMessage(responseInfo){
  responseInfo.message = "Okay. Tickle Monster signing off!";
}

//********"Alexa, Ask Tickle Monster Who's Next"********************
function whosNext(parsedEvent, responseInfo){
  responseInfo.message = getVariedTickleResponse(parsedEvent.participants);
}

//*********"Alexa, Ask Tickle Monster To Reset Participant Names"***
function confirmNameReset(responseInfo){
  responseInfo.message = "Are you sure you want Tickle Monster to reset the names?";
  responseInfo.repromptText = "Do you want to reset the participant names? Please answer \"yes\" or \"no\".";
  responseInfo.shouldEndSession = false;
}

//*********"Are You Sure You Want to Reset Participant Names?********
//*********"Yes"*****************************************************
function yesResetNames(responseInfo){
  //there will be a link in the Alexa app 
  //that lets the user revisit the name setup page.
  responseInfo.message = "Please view the message from Tickle Monster in your Alexa app and choose <break time='1ms'/> 'Link Account' <break time='1ms'/> to finish resetting the names.";
  responseInfo.shouldResetNames = true;
}

//*********"Are You Sure You Want to Reset Participant Names?********
//*********"No"******************************************************
function noResetNames(responseInfo){
  responseInfo.message = "Okay. Cancelled.";
}

//***
//*Helpers
//***
function getNextTickleVictim(participants){
    //add the possibility of "Everyone", just to spice things up a bit
    var chanceIn = 20;
    if(getRandomInt(0, chanceIn) == chanceIn) 
        return "Everyone";
    
    var participantsCount = participants.length;
    
    //get a random tickle victim to return.
    var randomIndex = getRandomInt(0, participantsCount - 1);
    return participants[randomIndex];
}

function getVariedTickleResponse(participants){
    var nextVictim = getNextTickleVictim(participants);
    
    var randomResponseIndex = getRandomInt(0, variedTickleResponses.length - 1)
    return variedTickleResponses[randomResponseIndex].replace(/{TickleVictim}/g, nextVictim);
}

function getParticipants(unparsedParticipants){
    //crude, reasonable validation for character limit.
    var charLimit = 1000;
    if(unparsedParticipants.length>charLimit)
        unparsedParticipants=unparsedParticipants.substring(0,charLimit);

    //crude validation using Regex. remove anything that's not a letter, comma, space or single quote
    unparsedParticipants = unparsedParticipants.replace(/[^a-z\s',]/gi, "");

    return unparsedParticipants.split(",");
}

function getRandomInt(min, max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}