ASE.cpp

Go to the documentation of this file.

#include "../../rapidxml-1.13/rapidxml.hpp"

#include "Module.h"

#include <stdio.h>
#include <curl/curl.h>

#include "../Library/MD5.h"

#include <io.h>
#include <fcntl.h>
#include <share.h>
#include <sys/stat.h>

Ase::Ase(Bus* prmBus, Logger* prmLogger, int prmSoundDevice, SVocalware prmVocalware) : Module(prmBus)
{
        bus = prmBus;
        logger = prmLogger;
        soundDevice = prmSoundDevice;
        vocalware = prmVocalware;
}

void Ase::Initialize(Devices::Bass* prmBass)
{
        bass = prmBass;
}

inline bool FileExists(const std::string name)
{
        struct stat buffer;
        return (stat(name.c_str(), &buffer) == 0);
}

void Ase::FrameMove(float fElapsedTime)
{
        if (!bass) return;

        for (UINT i = 0; i < bus->commandStream.size(); i++)
        {
                Command command = bus->commandStream.at(i);
                if (command.delay != 0.0f) continue;

                if (command.name.substr(0, 10) == "Scenarios/")
                {
                        LoadScenario(command.name);
                        currentStep = command.ivalue;

                        char msg[99];
                        sprintf_s(msg, 99, "ASE:FrameMove Scenario %s loaded, step %i command 0", command.name.substr(10).c_str(), command.ivalue);
                        logger->Log(msg);

                        bus->commandStream.erase(bus->commandStream.begin() + i);

                        char randId[7];
                        static const char alphanum[] =
                                "346789"
                                "ABCDEFGHIJKLMNPQRTUVWXY";
                        for (i = 0; i < 6; i++)
                                randId[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
                        randId[6] = 0;
                        bus->receiptNumber = randId;
                }
                else if (command.name == "EndScenario")
                {
                        bus->ClearHelp();
                        currentStep = subStep = 0;
                        bus->waypoints.clear();
                        scenarioLoaded = false;
                        bus->commandStream.erase(bus->commandStream.begin() + i);
                        Command newcommand;
                        newcommand.name = "Viewport-MFD";
                        strcpy_s(newcommand.svalue, 64, "Nav");
                        bus->commandStream.push_back(newcommand);

                        Command command3;
                        command3.name = "Display-Reset"; // reset
                        bus->commandStream.push_back(command3);

                        Command command2;
                        command2.name = "Display-Event";
                        command2.ivalue = 2; // start music
                        bus->commandStream.push_back(command2);
                }
                else if (command.name == "ContinueScenario")
                {
                        if (scenarioLoaded)
                                AdvanceToNextStep();
                        bus->commandStream.erase(bus->commandStream.begin() + i);
                }
        }

        if (!scenarioLoaded)
                return;

        bus->ScenarioTimer += fElapsedTime;

        static float verticalStabilized = 0.0f;
        float pitchdiff = fabsf(bus->AFCS.DesiredPitch - bus->PitchAttitude);
        if (pitchdiff < D3DXToRadian(2.5f))
                verticalStabilized += fElapsedTime;
        else
                verticalStabilized = 0.0f;

        // 2.5 - 0 is 2.5... 2.5-2.5 is 0... 2.5-5 is -2.5 clamped to 0
        if (bus->AFCS.AutopilotEngaged)
                bus->ScenarioScore += max(2.5f - D3DXToDegree(pitchdiff), 0.0f) * 2.0f * fElapsedTime * bus->occupantPitchControlAuthority; // 5 per second max

        static float lateralStabilized = 0.0f;
        float rolldiff = fabsf(bus->AFCS.DesiredRoll - bus->RollAttitude);
        if (rolldiff < D3DXToRadian(5.0f))
                lateralStabilized += fElapsedTime;
        else
                lateralStabilized = 0.0f;

        // 2.5 - 0 is 2.5... 2.5-2.5 is 0... 2.5-5 is -2.5 clamped to 0
        if (bus->AFCS.AutopilotEngaged)
                bus->ScenarioScore += max(5.0f - D3DXToDegree(rolldiff), 0.0f) * fElapsedTime * bus->occupantRollControlAuthority; // 5 per second max

        // decrease what they can do the further it gets from where they should be... so 0/15 is 0
        if (bus->AFCS.AutopilotEngaged)
        {
                bus->occupantRollControlAuthority = max(0, 1.0f - rolldiff / D3DXToRadian(5.0f)) * occupantControlAuthority;
                bus->occupantPitchControlAuthority = max(0, 1.0f - pitchdiff / D3DXToRadian(2.5f)) * occupantControlAuthority;
        }
        else
        {
                bus->occupantRollControlAuthority = bus->occupantPitchControlAuthority = 1.0f;
        }


        SCommand command = steps.at(currentStep).commands.at(subStep);

        if (!command.vmu.empty())
        {
                if (stream)
                {
                        // forces it to wait until previous speech is finished (supports back to back VMU's)
                        if (bass->StreamIsPlaying(stream))
                                return;
                        BASS_StreamFree(stream);
                        stream = 0;
                }
                std::string path;
                if (command.voice == 0)
                        path = "Scenarios/Audio/" + md5(command.vmu) + ".mp3";
                else
                {
                        SVoice voice = vocalware.voices.at(command.voice);
                        std::string cs = voice.eid + voice.lid + voice.vid + command.vmu + voice.fxtype + voice.fxlevel;
                        path = "Scenarios/Audio/" + std::to_string(command.voice) + "/" + md5(cs) + ".mp3";
                }
                if (!FileExists(path))
                {
                        GenerateTextToSpeech(command.vmu, command.voice, path);
                }
                stream = bass->PlayStream(path);
        }
        // something to do
        else if (!command.name.empty())
        {
                if (command.name == "ModulateOccupantControlAuthority")
                {
                        occupantControlAuthority *= command.fvalue;
                        char msg[99];
                        sprintf_s(msg, 99, "ASE:FrameMove Handling command: %s", command.name.c_str());
                        logger->Log(msg);
                }
                else if (command.name == "SetOccupantControlAuthority")
                {
                        occupantControlAuthority = command.fvalue;
                        char msg[99];
                        sprintf_s(msg, 99, "ASE:FrameMove Handling command: %s", command.name.c_str());
                        logger->Log(msg);
                }
                else
                {
                        // something to add to the command stream on the bus
                        Command busCommand;
                        busCommand.name = command.name;
                        memcpy(busCommand.svalue, command.svalue, 64); // covers whole union
                        bus->commandStream.push_back(busCommand);
                        char msg[99];
                        sprintf_s(msg, 99, "ASE:FrameMove Dispatching command: %s", command.name.c_str());
                        logger->Log(msg);
                }
        }
        // help subsystem
        else if (!command.help.empty())
        {
                // manipulating the help system
                if (command.help == "Clear")
                {
                        bus->ClearHelp();
                }
                else if (command.help == "Highlight")
                {
                        bus->AddHighlight(command.element);
                }
                else if (command.help == "Dim")
                {
                        bus->RemoveHighlight(command.element);
                }
        }
        // wait for conditions
        else if (!command.wait.empty())
        {
                // see if condition met, then continue
                bool conditionMet = false;

                // we want both users to click the button at some point within the timeout period
                for (UINT i = 0; i < bus->commandStream.size(); i++)
                {
                        Command busCommand = bus->commandStream.at(i);
                        if (busCommand.delay != 0.0f) continue;

                        if (command.wait == "BothPilotsPressedTrigger" && busCommand.name == "JoystickTrigger")
                        {
                                steps.at(currentStep).commands.at(subStep).conditionsMet |= (busCommand.ivalue + 1); // 1 and 2
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                                if (steps.at(currentStep).commands.at(subStep).conditionsMet == 3)
                                        conditionMet = true;
                        }
                        else if (command.wait == "EitherPilotPressedTrigger" && busCommand.name == "JoystickTrigger")
                        {
                                bus->commandStream.erase(bus->commandStream.begin() + i);
                                conditionMet = true;
                        }
                }

                if (command.wait == "StabilizedFlight" && lateralStabilized >= 10.0f && verticalStabilized >= 10.0f)
                        conditionMet = true;
                else if (command.wait == "WaypointsLeft" && bus->waypoints.size() == static_cast<UINT>(command.ivalue))
                        conditionMet = true;
                else if (command.wait == "WaypointDistance" && bus->waypoints.size() > 0)
                {
                        D3DXVECTOR3 diff3 = bus->Location - bus->waypoints.at(0).absoluteLocation();
                        D3DXVECTOR2 diff2 = D3DXVECTOR2(diff3.x, diff3.y);
                        float dist = D3DXVec2Length(&diff2);
                        if (dist <= command.fvalue)
                                conditionMet = true;
                }
                else if (command.wait == "ThrustSetting")
                {
                        if (bus->AFCS.AutothrottleEngaged)
                        {
                                conditionMet = true;
                        }
                        else if (fabsf(bus->EngineThrustCommand[0] - command.fvalue) <= 0.03f && fabsf(bus->EngineThrustCommand[1] - command.fvalue) <= 0.03f) // 67 to 73
                        {
                                conditionMet = true;
                        }
                }

                if (!conditionMet)
                {
                        // see if timeout elapsed, then continue
                        steps.at(currentStep).commands.at(subStep).timeoutLeft -= fElapsedTime;
                        if (steps.at(currentStep).commands.at(subStep).timeoutLeft > 0)
                        {
                                return; // don't proceed to next step
                        }
                        else if (!steps.at(currentStep).commands.at(subStep).timeoutStep.empty())
                        {
                                currentStep = FindStep(steps.at(currentStep).commands.at(subStep).timeoutStep);
                                subStep = -1; // because we are about to increment it
                        }
                }
        }
        // jump to another step
        else if (!command.jump.empty())
        {
                currentStep = FindStep(command.jump);
                subStep = -1; // because we are about to increment it
        }

        AdvanceToNextStep();
}

void Ase::AdvanceToNextStep()
{
        // advance to next step
        subStep++;
        if (static_cast<UINT>(subStep) >= steps.at(currentStep).commands.size())
        {
                subStep = 0;
                currentStep++;
                if (currentStep >= steps.size())
                {
                        // we are done!
                        currentStep = 0;
                        scenarioLoaded = false;
                        logger->Log("ASE::AdvanceToNextStep Scenario completed!");
                        return;
                }
        }

        // restore the step's timeout, conditionMet
        steps.at(currentStep).commands.at(subStep).timeoutLeft = steps.at(currentStep).commands.at(subStep).timeout;
        steps.at(currentStep).commands.at(subStep).conditionsMet = 0;

        char msg[99];
        sprintf_s(msg, 99, "ASE:AdvanceToNextStep Scenario step %i command %i", currentStep, subStep);
        logger->Log(msg);
}

size_t write_data(void* ptr, size_t size, size_t nmemb, FILE* stream)
{
        size_t written = fwrite(ptr, size, nmemb, stream);
        return written;
}

bool Ase::GenerateTextToSpeech(std::string read, UINT voiceId, std::string outputPath)
{
        CURL* curl = curl_easy_init();
        if (curl)
        {
                FILE* fp;
                if (fopen_s(&fp, outputPath.c_str(), "wb") != 0)
                {
                        logger->Log("Ase::GenerateTextToSpeech fopen failed!", Logger::Fatal, errno);
                        return false;
                }

                SVoice voice = vocalware.voices.at(voiceId);

                std::string cs = voice.eid + voice.lid + voice.vid + read + voice.fxtype + voice.fxlevel + vocalware.acc + vocalware.api + vocalware.secret;
                std::string encodedRead = curl_easy_escape(curl, read.c_str(), read.length());
                std::string url = "http://www.vocalware.com/tts/gen.php?EID=" + voice.eid + "&LID=" + voice.lid + "&VID=" + voice.vid + "&TXT=" + encodedRead + "&FX_TYPE=" + voice.fxtype + "&FX_LEVEL=" + voice.fxlevel;
                url += "&ACC=" + vocalware.acc + "&API=" + vocalware.api + "&CS=" + md5(cs);

                curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
                curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
                curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
                curl_easy_perform(curl);
                curl_easy_cleanup(curl);
                fclose(fp);
                return true;
        }
        logger->Log("Ase::GenerateTextToSpeech curl_easy_init failed!", Logger::Fatal);
        return false;
}

void Ase::LoadScenario(std::string path)
{
        scenarioLoaded = false;
        currentStep = 0;
        subStep = 0;
        steps.clear();

        if (path.length() == 0)
        {
                logger->Log("Ase::LoadScenario scenario file path was empty!", Logger::Fatal);
                exit(0);
        }

        int configFile;
        _sopen_s(&configFile, path.c_str(), _O_RDONLY | _O_BINARY | _O_SEQUENTIAL, SH_DENYWR, S_IREAD);
        if (configFile == -1)
        {
                char msg[99];
                sprintf_s(msg, 99, "Ase::LoadScenario could not open file: %S", path.c_str());
                logger->Log(msg, Logger::Error, errno);
                exit(0);
        }

        int fileLength = _filelength(configFile);
        char* buffer = new char[fileLength + 1]; // null terminator
        _read(configFile, buffer, fileLength);
        _close(configFile);
        buffer[fileLength] = 0; // null terminate

        using namespace rapidxml;
        xml_document<> doc; // character type defaults to char
        doc.parse<0>(buffer); // 0 means default parse flags

        xml_node<>* scenario = doc.first_node("Scenario");

        for (xml_node<>* stepNode = scenario->first_node(); stepNode; stepNode = stepNode->next_sibling())
        {
                if (_strcmpi(stepNode->name(), "Step") != 0) continue;

                SStep step;

                xml_attribute<>* name = stepNode->first_attribute("name");
                if (name->value()) step.name = name->value();

                for (xml_node<>* node = stepNode->first_node(); node; node = node->next_sibling())
                {
                        SCommand command;

                        xml_attribute<>* commandName = node->first_attribute("name");
                        if (commandName) command.name = commandName->value();
                        xml_attribute<>* svalue = node->first_attribute("svalue");
                        if (svalue)
                                strcpy_s(command.svalue, 64, svalue->value());
                        xml_attribute<>* ivalue = node->first_attribute("ivalue");
                        if (ivalue)
                                command.ivalue = atoi(ivalue->value());
                        xml_attribute<>* fvalue = node->first_attribute("fvalue");
                        if (fvalue)
                                command.fvalue = static_cast<float>(atof(fvalue->value()));
                        xml_attribute<>* bvalue = node->first_attribute("bvalue");
                        if (bvalue)
                                command.bvalue = atoi(bvalue->value()) == 1;
                        xml_attribute<>* vmu = node->first_attribute("vmu");
                        if (vmu) command.vmu = vmu->value();
                        xml_attribute<>* voice = node->first_attribute("voice");
                        if (voice) command.voice = atoi(voice->value());
                        xml_attribute<>* wait = node->first_attribute("wait");
                        if (wait) command.wait = wait->value();
                        xml_attribute<>* timeout = node->first_attribute("timeout");
                        if (timeout) command.timeout = static_cast<float>(atof(timeout->value()));
                        xml_attribute<>* timeoutStep = node->first_attribute("timeoutStep");
                        if (timeoutStep) command.timeoutStep = timeoutStep->value();
                        xml_attribute<>* jump = node->first_attribute("jump");
                        if (jump) command.jump = jump->value();
                        xml_attribute<>* help = node->first_attribute("help");
                        if (help) command.help = help->value();
                        xml_attribute<>* element = node->first_attribute("element");
                        if (element) command.element = element->value();

                        step.commands.push_back(command);
                }

                if (step.commands.size() > 0)
                        steps.push_back(step);
        }

        SAFE_DELETE(buffer);

        scenarioLoaded = true;
        bus->ScenarioTimer = 0.0f; // reset
        bus->ScenarioScore = 0.0f; // reset


        occupantControlAuthority = 1.0f; // initially 100%, if they fail the first test it goes to 50, then to 25?


        bus->waypoints.clear();

        Waypoint butch = Waypoint(&bus->vehicles.at(1));
        butch.FixId = "BUTCH";
        butch.type = Waypoint::WaypointType::FlyoverFix;
        butch.relativeLocation = D3DXVECTOR3(-0.015f, -0.097f + 0.015f, 0.042f); // left runway, 50 feet (15 m) down the runway, coming in from aft of station
        butch.relativeLocation.y -= 20.0f; // 20km out
        bus->waypoints.push_back(butch);

        Waypoint cssdy = Waypoint(&bus->vehicles.at(1));
        cssdy.FixId = "CASDY";
        cssdy.type = Waypoint::WaypointType::FinalApproachFix;
        cssdy.relativeLocation = D3DXVECTOR3(-0.015f, -0.097f + 0.015f, 0.042f); // left runway, 50 feet (15 m) down the runway, coming in from aft of station
        cssdy.relativeLocation.y -= 8.828f; // 8.828 km out ... 
        cssdy.relativeLocation.z += 0.458f; // .042 + .458 is .5 ... FL355 is the FAF with sin(3 deg) means 8.282km out
        bus->waypoints.push_back(cssdy);

        Waypoint e419 = Waypoint(&bus->vehicles.at(1));
        e419.FixId = "E419";
        e419.type = Waypoint::WaypointType::TouchdownZone;
        e419.relativeLocation = D3DXVECTOR3(-0.015f, -0.097f + 0.015f, 0.042f); // left runway, 50 feet (15 m) down the runway, coming in from aft of station
        //e419.relativeLocation.y -= 0.2f; // move it back a bit
        bus->waypoints.push_back(e419);
}

UINT Ase::FindStep(std::string stepName)
{
        for (UINT i = 0; i < steps.size(); i++)
        {
                if (steps.at(i).name == stepName)
                        return i;
        }
        return 0;
}