Robot Action Game

const Alexa = require('ask-sdk-core');
const Util = require('./util');

const NAMESPACE = 'Custom.Mindstorms.Gadget';
const NAME = 'dance';

const numberOfQuestions = 5;

const LaunchRequestHandler = {
    canHandle(handlerInput) {
        return handlerInput.requestEnvelope.request.type === `LaunchRequest`;
    },
    handle: async function (handlerInput) {
        let request = handlerInput.requestEnvelope;
        let { apiEndpoint, apiAccessToken } = request.context.System;
        let apiResponse = await Util.getConnectedEndpoints(apiEndpoint, apiAccessToken);
        if ((apiResponse.endpoints || []).length === 0) {
            return handlerInput.responseBuilder
                .speak(`I couldn't find an EV3 Brick connected to this Echo device. Please check to make sure your EV3 Brick is connected, and try again.`)
                .getResponse();
        }
        // Store the gadget endpointId to be used in this skill session
        let endpointId = apiResponse.endpoints[0].endpointId || [];
        Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);
        return handlerInput.responseBuilder
            .speak(`Welcome to my game with my friend EV3. Would you like to start or ask for help?`)
            .reprompt(helpMessage)
            .getResponse();
    }
};

const QuizHandler = {
    canHandle(handlerInput) {
        console.log("Inside QuizHandler - canHandle");
        const request = handlerInput.requestEnvelope.request;
        return request.type === "IntentRequest" &&
            (request.intent.name === "QuizIntent" || request.intent.name === "AMAZON.StartOverIntent");
    },
    handle(handlerInput) {
        return startQuiz(handlerInput);
    }
};

const EventsReceivedRequestHandler = {
    // Checks for a valid token and endpoint.
    canHandle(handlerInput) {
        console.log("in EventsReceivedRequestHandler");
        let { request } = handlerInput.requestEnvelope;
        console.log('Request type: ' + Alexa.getRequestType(handlerInput.requestEnvelope));
        if (request.type !== 'CustomInterfaceController.EventsReceived') {
            return false;
        }
        const attributesManager = handlerInput.attributesManager;
        let sessionAttributes = attributesManager.getSessionAttributes();
        let customEvent = request.events[0];

        // Validate event token
        if (sessionAttributes.token !== request.token) {
            console.log("Event token doesn't match. Ignoring this event");
            return false;
        }

        // Validate endpoint
        let requestEndpoint = customEvent.endpoint.endpointId;
        if (requestEndpoint !== sessionAttributes.endpointId) {
            console.log("Event endpoint id doesn't match. Ignoring this event");
            return false;
        }
        return true;
    },
    handle(handlerInput) {
        let customEvent = handlerInput.requestEnvelope.request.events[0];
        let payload = customEvent.payload;
        let name = customEvent.header.name;

        if(name == 'help-done') {
            return startQuiz(handlerInput);
        }
        
        const attributes = handlerInput.attributesManager.getSessionAttributes();
        const quizItem = attributes.quizItem;

        if (supportsDisplay(handlerInput)) {
            display(`Question #${attributes.counter}`, quizItem.Question, handlerInput.responseBuilder);
        }
        console.log((quizItem.Question));
        return handlerInput.responseBuilder
            .speak(quizItem.Question)
            .withShouldEndSession(false)
            .getResponse();
    }
};

const ExpiredRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'CustomInterfaceController.Expired'
    },
    handle(handlerInput) {
        console.log("== Custom Event Expiration Input ==");

        // Set the token to track the event handler
        const token = handlerInput.requestEnvelope.request.requestId;
        Util.putSessionAttribute(handlerInput, 'token', token);

        const attributesManager = handlerInput.attributesManager;
        let duration = attributesManager.getSessionAttributes().duration || 0;
        if (duration > 0) {
            Util.putSessionAttribute(handlerInput, 'duration', --duration);

            // Extends skill session
            const speechOutput = `${duration} minutes remaining.`;
            return handlerInput.responseBuilder
                .addDirective(Util.buildStartEventHandler(token, 60000, {}))
                .speak(speechOutput)
                .getResponse();
        }
        else {
            // End skill session
            return handlerInput.responseBuilder
                .speak("")
                .withShouldEndSession(true)
                .getResponse();
        }
    }
};

const QuizAnswerHandler = {
    canHandle(handlerInput) {
         const attributes = handlerInput.attributesManager.getSessionAttributes();
        const request = handlerInput.requestEnvelope.request;

        return attributes.state === states.QUIZ &&
            request.type === 'IntentRequest' &&
            request.intent.name === 'AnswerIntent';
    },
    handle(handlerInput) {
        console.log("Inside QuizAnswerHandler - handle");
        const attributes = handlerInput.attributesManager.getSessionAttributes();
        const response = handlerInput.responseBuilder.withShouldEndSession(false);

        if (attributes.currentInputHandlerId) {
            responseBuilder.addDirective({
                'type': 'CustomInterfaceController.StopEventHandler',
                'token': attributes.currentEventHandlerToken
            });
        }

        var speakOutput = ``;
        const quizItem = attributes.quizItem;
        const isCorrect = compareSlots(handlerInput.requestEnvelope.request.intent.slots, quizItem.Answer);

        if (isCorrect) {
            speakOutput = getPositiveReaction();
            attributes.quizScore += 1;
            handlerInput.attributesManager.setSessionAttributes(attributes);
        } else {
            speakOutput = getNegativeReaction();
        }

        speakOutput += `The correct answer is ${quizItem.Answer}. `;

        if (attributes.counter < numberOfQuestions) {
            speakOutput += getCurrentScore(attributes.quizScore, attributes.counter);
            const quizItem = prepareQuizItem(handlerInput);
            speakOutput += quizItem.Question;
            const endpointId = handlerInput.attributesManager.getSessionAttributes().endpointId
            let directive = Util.build(endpointId, NAMESPACE, NAME,
                {
                    counter: attributes.counter,
                    actions: quizItem.Actions
                });
            const token = handlerInput.requestEnvelope.request.requestId;
            
            if (supportsDisplay(handlerInput)) {
                display(`Question #${attributes.counter}`, quizItem.Question, handlerInput.responseBuilder);
            }
     
            return response.speak(speakOutput)
                .addDirective(Util.buildStartEventHandler(token, 60000, {}))
                .addDirective(directive)
                .reprompt(quizItem.Question)
                .getResponse();
        } else {
            const finalScoreOutput = getFinalScore(attributes.quizScore, attributes.counter);
            if (supportsDisplay(handlerInput)) {
                display('Final Score', finalScoreOutput, response);
            }
            speakOutput += finalScoreOutput + exitSkillMessage;
            return response.speak(speakOutput).withSimpleCard("Robot Game finished", finalScoreOutput)

            .withShouldEndSession(true)
            .getResponse();
        }
    }
};

const RepeatHandler = {
    canHandle(handlerInput) {
        const attributes = handlerInput.attributesManager.getSessionAttributes();
        const request = handlerInput.requestEnvelope.request;

        return attributes.state === states.QUIZ &&
            request.type === 'IntentRequest' &&
            request.intent.name === 'AMAZON.RepeatHandler';
    },
    handle(handlerInput) {
        console.log("Inside RepeatHandler - handle");
        const attributes = handlerInput.attributesManager.getSessionAttributes();
        const response = handlerInput.responseBuilder;

        const quizItem = attributes.quizItem;
        const question = quizItem.Question;

        return handlerInput.responseBuilder
            .speak(question)
            .reprompt(question)
            .getResponse();
    }
};

const HelpIntentHandler = {
    canHandle(handlerInput) {
        const request = handlerInput.requestEnvelope.request;
        return request.type === 'IntentRequest' &&
            request.intent.name === 'AMAZON.HelpIntent';
    },
    handle(handlerInput) {
    
        const token = handlerInput.requestEnvelope.request.requestId;
        const endpointId = handlerInput.attributesManager.getSessionAttributes().endpointId || [];
        let directive = Util.build(endpointId, NAMESPACE, 'demo', {});
        return handlerInput.responseBuilder
            .speak(``)
            .withShouldEndSession(false)
            .addDirective(Util.buildStartEventHandler(token, 60000, {}))
            .addDirective(directive)
            .getResponse();
    }
};

const ExitHandler = {
    canHandle(handlerInput) {
        const attributes = handlerInput.attributesManager.getSessionAttributes();
        const request = handlerInput.requestEnvelope.request;

        return request.type === `IntentRequest` && (
            request.intent.name === 'AMAZON.StopIntent' ||
            request.intent.name === 'AMAZON.PauseIntent' ||
            request.intent.name === 'AMAZON.CancelIntent'
        );
    },
    handle(handlerInput) {
        return handlerInput.responseBuilder
            .speak(exitSkillMessage)
            .getResponse();
    }
};

const SessionEndedRequestHandler = {
    canHandle(handlerInput) {
        return handlerInput.requestEnvelope.request.type === 'SessionEndedRequest';
    },
    handle(handlerInput) {
        return handlerInput.responseBuilder.getResponse();
    }
};

const IntentReflectorHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest';
    },
    handle(handlerInput) {
        const intentName = Alexa.getIntentName(handlerInput.requestEnvelope);
        const speakOutput = `You just triggered ${intentName}`;
        console.log(JSON.stringify(handlerInput.requestEnvelope));

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt("I don't understand this command, try again")
            .getResponse();
    }
};

const ErrorHandler = {
    canHandle() {
        return true;
    },
    handle(handlerInput, error) {
        console.log("Inside ErrorHandler - handle");
        console.log(`Error handled: ${JSON.stringify(error)}`);
        console.log(`Handler Input: ${JSON.stringify(handlerInput)}`);

        return handlerInput.responseBuilder
            .speak('error')
            .getResponse();
    }
};

const skillBuilder = Alexa.SkillBuilders.custom();

const states = {
    START: `_START`,
    QUIZ: `_QUIZ`,
};

const helpMessage = `My friend EV3 will perform some actions. He may move, turn, or change his colors.  Then I will ask a question about what it did.  Sounds easy enough?  The game will consist of ${numberOfQuestions} questions.`;
const exitSkillMessage = `Thank you for playing my game with EV3!  Let's play again soon!`;

function supportsDisplay(handlerInput) {
    var hasDisplay =
        handlerInput.requestEnvelope.context &&
        handlerInput.requestEnvelope.context.System &&
        handlerInput.requestEnvelope.context.System.device &&
        handlerInput.requestEnvelope.context.System.device.supportedInterfaces &&
        handlerInput.requestEnvelope.context.System.device.supportedInterfaces.Display
    return hasDisplay;
}


function startQuiz(handlerInput) {
    console.log("Inside QuizHandler - handle");

    const attributes = handlerInput.attributesManager.getSessionAttributes();
    const response = handlerInput.responseBuilder;

    attributes.state = states.QUIZ;
    attributes.counter = 0;
    attributes.quizScore = 0;

    handlerInput.attributesManager.setSessionAttributes(attributes);

    const quizItem = prepareQuizItem(handlerInput);

    var speakOutput = `OK.  EV3 will perform some actions and then I will ask you about what you saw. `;
    const endpointId = handlerInput.attributesManager.getSessionAttributes().endpointId || [];
    Util.putSessionAttribute(handlerInput, 'endpointId', endpointId);

    const token = handlerInput.requestEnvelope.request.requestId;
    Util.putSessionAttribute(handlerInput, 'token', token);

    let directive = Util.build(endpointId, NAMESPACE, NAME,
        {
            counter: 1,
            actions: quizItem.Actions
        });
        console.log(JSON.stringify(directive));
    
    return response.speak(speakOutput )
      .withShouldEndSession(false)
        .addDirective(Util.buildStartEventHandler(token, 60000, {}))
        .addDirective(directive)
        .getResponse();
}

function getCurrentScore(score, counter) {
    return `Your current score is ${score} out of ${counter}. `;
}

function getFinalScore(score, counter) {
    return `Your final score is ${score} out of ${counter}. `;
}

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

function prepareQuizItem(handlerInput) {

    const attributes = handlerInput.attributesManager.getSessionAttributes();
    var counter = attributes.counter;
    counter += 1;
    const quizItem = buildQuizItem(counter);
    attributes.quizItem = quizItem;
    attributes.counter = counter;
    handlerInput.attributesManager.setSessionAttributes(attributes);

    return quizItem;
}

function buildQuizItem(counter) {

    var question = null;
    var answer = null;
    var actions = [];
    let action, action2 = null;
    const random = getRandom(0, counter - 1);
    for (let i = 0; i < counter; i++) {
        const randomType = getRandom(0, 6);
        switch (randomType) {
            default:
            case 0:
                action = { Type: 'LED', LedGroup: ['LEFT', 'RIGHT'][getRandom(0, 1)], Color: ['BLACK', 'RED', 'GREEN', 'AMBER', 'ORANGE', 'YELLOW'][getRandom(1, 5)] };
                if (i == random) {
                    question = `What is the color for the ${i + 1}th action.`;
                    answer = action.Color;
                }
                actions.push(action);
                break;
            case 1:
                action = { Type: 'LED', LedGroup: ['LEFT', 'RIGHT'][getRandom(0, 1)], Color: ['BLACK', 'RED', 'GREEN', 'AMBER', 'ORANGE', 'YELLOW'][getRandom(1, 5)] };
                if (i == random) {
                    question = `Did the ${i + 1}th action light up the left or right? `;
                    answer = action.LedGroup;
                }
                actions.push(action);
                break;
            case 2:
                action = { Type: 'MOVE', Direction: ['FORWARD', 'BACKWARD', 'LEFT', 'RIGHT'][getRandom(0, 3)], Duration: getRandom(1, 2), Speed: 50 };
                if (i == random) {
                    question = `For the ${i + 1}th action, did EV3 move Forward, Backward, Left, or right?`;
                    answer = action.Direction;
                }
                actions.push(action);
                i++;
                action2 = reverseAction(action);
                if (i == random) {
                    question = `For the ${i + 1}th action, did EV3 move Forward, Backward, Left, or right?`;
                    answer = action2.Direction;
                }
                actions.push(action2);
                break;
            case 3:
                action = { Type: 'MOVE', Direction: ['FORWARD', 'BACKWARD', 'LEFT', 'RIGHT'][getRandom(0, 3)], Duration: getRandom(1, 2), Speed: 50 };
                if (i == random) {
                    question = `For the ${i + 1}th action, how many seconds did EV3 move?`;
                    answer = action.Duration;
                }
                actions.push(action);
                i++;
                action2 = reverseAction(action);
                if (i == random) {
                    question = `For the ${i + 1}th action, how many seconds did EV3 move?`;
                    answer = action2.Duration;
                }
                actions.push(action2);
                break;
            case 4:
                action = { Type: 'WEAPON', Rotations: getRandom(1, 3), Speed: getRandom(0, 1) ? 50 : -50 };
                if (i == random) {
                    question = `For the ${i + 1}th action, how many rotations did EV3's weapon move?`;
                    answer = action.Rotations;
                }
                actions.push(action);
                break;
            case 5:
                action = { Type: 'WEAPON', Rotations: getRandom(1, 3), Speed: getRandom(0, 1) ? 100 : -100 };
                if (i == random) {
                    question = `For the ${i + 1}th action, did EV3's weapon rotate clockwise or counter-clockwise?`;
                    answer = action.Speed == 100 ? 'Clockwise' : 'Counter-clockwise';
                }
                actions.push(action);
                break;
            case 6:
                    action = { Type: 'SOUND', Note: ['C', 'D', 'E', 'F', 'G', 'A', 'B'][getRandom(0, 6)] };
                    if (i == random) {
                        question = `For the ${i + 1}th action, what was the musical note?`;
                        answer = action.Note;
                    }
                    actions.push(action);
                    break;
        }
        console.log(i);
        console.log(JSON.stringify(actions));
        

    }
    console.log(actions);
    return { 'Question': question, 'Answer': answer, 'Actions': actions };
}

function reverseAction(action) {
     let action2 = JSON.parse(JSON.stringify(action));
     switch(action.Direction) {
        case 'FORWARD':
             action2.Direction = 'BACKWARD';
             break;
        case 'BACKWARD':
             action2.Direction = 'FORWARD';
             break;
        case 'LEFT':
             action2.Direction = 'RIGHT';
             break;
        case 'RIGHT':
             action2.Direction = 'LEFT';
             break;
     }
     return action2;
}

function compareSlots(slots, value) {
    for (const slot in slots) {
        if (Object.prototype.hasOwnProperty.call(slots, slot) && slots[slot].value !== undefined) {
            if (slots[slot].value.toString().toLowerCase() === value.toString().toLowerCase()) {
                return true;
            }
        }
    }

    return false;
}

function getPositiveReaction() {
    const speechConsCorrect = ['Booya', 'All righty', 'Bam', 'Bazinga', 'Bingo', 'Boom', 'Bravo', 'Cha Ching', 'Cheers', 'Dynomite', 'Hip hip hooray', 'Hurrah', 'Hurray', 'Huzzah', 'Oh dear.  Just kidding.  Hurray', 'Kaboom', 'Kaching', 'Oh snap', 'Phew', 'Righto', 'Way to go', 'Well done', 'Whee', 'Woo hoo', 'Yay', 'Wowza', 'Yowsa'];
    return `<say-as interpret-as='interjection'>${speechConsCorrect[getRandom(0, speechConsCorrect.length - 1)]}! </say-as><break strength='strong'/>`;
}

function getNegativeReaction() {
    const speechConsWrong = ['Argh', 'Aw man', 'Blarg', 'Blast', 'Boo', 'Bummer', 'Darn', "D'oh", 'Dun dun dun', 'Eek', 'Honk', 'Le sigh', 'Mamma mia', 'Oh boy', 'Oh dear', 'Oof', 'Ouch', 'Ruh roh', 'Shucks', 'Uh oh', 'Wah wah', 'Whoops a daisy', 'Yikes'];
    return `<say-as interpret-as='interjection'>${speechConsWrong[getRandom(0, speechConsWrong.length - 1)]} </say-as><break strength='strong'/>`;
}

function display(title, text, response) {
     console.log("display " +  title + text + response);
    const textContent = new Alexa.RichTextContentHelper().withPrimaryText(text).getTextContent();
    response.addRenderTemplateDirective({
        type: 'BodyTemplate1',
        token: 'Question',
        backButton: 'hidden',
        title,
        textContent
    });
}

exports.handler = skillBuilder
    .addRequestHandlers(
        LaunchRequestHandler,
        QuizHandler,
        QuizAnswerHandler,
        EventsReceivedRequestHandler,
        // ExpiredRequestHandler,
        RepeatHandler,
        HelpIntentHandler,
        ExitHandler,
        SessionEndedRequestHandler,
        IntentReflectorHandler
    )
    // .addErrorHandlers(ErrorHandler)
    .lambda();