root/deus/director_main.cpp

/**
 * director_main.cpp
 */

// Director includes
#include "structures.h"
#include "AuthorInterface_impl.h"
#include "DirectorInterface_impl.h"
#include "forward_search.h"
#include "StoryTracer.h"

#include <time.h>

// Qt includes
#include <qapplication.h>
#include <qtimer.h>
#include <qlayout.h>


// Prototypes
void getAuthorInput(QApplication &app);
void direct(QApplication &app);
void MakeOps();

DirectorForm_impl *dfi = NULL;          // 6am day of EOH hack


/************************************************
 * main()
 ************************************************/
void main()
{
        // Init Qt
        int argc = 0;
        QApplication app(argc, NULL);

        // Open DB connection
        conn = mysql_init(conn);
        conn = mysql_real_connect(conn, "128.174.252.116", "deus", 
                                "DeusExMachina", "deus", 0, NULL, 0);

        // Populate the story graph beginning with story_root
        getAuthorInput(app);

        // Connect to Model
        real_world = new World();
        real_world->Locations = MapGenerator();
        real_world->map_height = GetMapSize().first;
        real_world->map_width = GetMapSize().second;
        //recievedata();
        MakeOps();

        // Direct!
        direct(app);

        // Close Model/DB connections
        mysql_close(conn);
}



/************************************************
 * Functions called from main()
 ************************************************/
void getAuthorInput(QApplication &app)
{
        AuthorForm_impl f(NULL, "author_form");
        QObject::connect(&app, SIGNAL(lastWindowClosed()), &f, SLOT(closing()));

        f.show();
        while (!f.is_closing) app.processEvents();
}

void direct(QApplication &app)
{
        DirectorForm_impl f(NULL, "director_form");
        dfi = &f;
        QObject::connect(&app, SIGNAL(lastWindowClosed()), &f, SLOT(shuttingDown()));
        QObject::connect(&app, SIGNAL(aboutToQuit()), &f, SLOT(shuttingDown()));

        
        //
        //
        // FOR SNAZZY SCREENSHOT, NOT REAL CODE

        // Install stylish forward graph view pane
        QBoxLayout *layout = new QVBoxLayout((QWidget *)f.ForwardFrame, 5);
        PlanGraphDisplay *f_gd = new PlanGraphDisplay(forward_root, (QWidget*)f.ForwardFrame);
        layout->addWidget(f_gd);

        // Reverse panes
        QBoxLayout *rlayout = new QVBoxLayout((QWidget *)f.RegressionFrame, 5);
        PlanGraphDisplay *r_gd = new PlanGraphDisplay(regression_root, (QWidget*)f.RegressionFrame);
        rlayout->addWidget(r_gd);

        f.show();

/*
        srand(783879292);

while (true)
{
        delete forward_root; delete regression_root;
        forward_root = NULL; regression_root = NULL;

        bool done = false;
        int i, j;
        Operator none;
        PlanNode *n1, *n = forward_root = new PlanNode(none, 0);
        PlanNode *n2 = regression_root = new PlanNode(none, 0);
        f_gd->root = n;
        r_gd->root = n2;

        list<PlanNode *> queue;
        for (int depth = 0; !done && depth < 15; depth++) {
                //printf("depth: %d\n", depth);
                while (!done && n->depth == depth)
                {
                        j = (int)(4*(rand()/(double)RAND_MAX));
                        for (i = 0; i < j; i++) 
                        {
                                n1 = new PlanNode(none, depth+1);
                                //n1->icon->ul_x = n->icon->ul_x - ICON_W - 100 - (700 * (rand()/(double)RAND_MAX));
                                //n1->icon->ul_y = n->icon->ul_y + (20 * ICON_H * (rand()/(double)RAND_MAX) - (10*ICON_H));
                                n1->icon->ul_x = n->icon->ul_x + ICON_W + 200;
                                n1->icon->ul_y = n->icon->ul_y + (3*ICON_H*(j-i-(j/1.5)));

                                n->branches.push_back(n1);
                                queue.push_back(n1);
                        }

                        f_gd->fit();
                        
                        if (queue.size() > 0) {n = queue.front(); queue.pop_front();}
                        else done = true;

                        app.processEvents();


if (depth < 10) {
        
                queue.clear();
                        j = (int)(4*(rand()/(double)RAND_MAX));
                        for (i = 0; i < j; i++) 
                        {
                                n1 = new PlanNode(none, depth+1);
                                n1->icon->ul_x = n2->icon->ul_x - ICON_W - 100 - (700 * (rand()/(double)RAND_MAX));
                                n1->icon->ul_y = n2->icon->ul_y + (20 * ICON_H * (rand()/(double)RAND_MAX) - (10*ICON_H));
                                //n1->icon->ul_x = n->icon->ul_x - ICON_W - 200;
                                //n1->icon->ul_y = n->icon->ul_y + (3*ICON_H*(j-i-(j/1.5)));

                                n2->branches.push_back(n1);
                                queue.push_back(n1);
                        }

                        r_gd->fit();
                        
                        if (queue.size() > 0) {n2 = queue.front(); queue.pop_front();}
                        else done = true;
}

                        app.processEvents();
                }
        }
}
        
*/
        // END SNAZZY SCREENSHOT CODE
        //
        //

/*
        // Install stylish forward graph view pane
        QBoxLayout *layout = new QVBoxLayout((QWidget *)f.ForwardFrame, 5);
        PlanGraphDisplay *f_gd = new PlanGraphDisplay(forward_root, (QWidget*)f.ForwardFrame);
        layout->addWidget(f_gd);


        // Reverse panes
        QBoxLayout *rlayout = new QVBoxLayout((QWidget *)f.RegressionFrame, 5);
        PlanGraphDisplay *r_gd = new PlanGraphDisplay(regression_root, (QWidget*)f.RegressionFrame);
        rlayout->addWidget(r_gd);
*/

//      f.show();
        //f_gd->fit();


        // Generate NPCs
        for (int i = 0; i < 50; i++)
        {
                NPC n;

                n.name = "npc";

                n.xcoord = 300 * (rand()/(double)RAND_MAX);
                n.ycoord = 300 * (rand()/(double)RAND_MAX);

                n.attributes.insert(std::pair<string,int>("Hunger", 100*(rand()/(double)RAND_MAX)));
                n.attributes.insert(std::pair<string,int>("Occupation", 20*(rand()/(double)RAND_MAX)));
                n.attributes.insert(std::pair<string,int>("Drunk", 100*(rand()/(double)RAND_MAX)));
                n.attributes.insert(std::pair<string,int>("Thirst", 10*(rand()/(double)RAND_MAX)));
                n.attributes.insert(std::pair<string,int>("Money", 10000*(rand()/(double)RAND_MAX)));
                n.attributes.insert(std::pair<string,int>("Morality", 10*(rand()/(double)RAND_MAX)));
                n.attributes.insert(std::pair<string,int>("Fatigue", 10*(rand()/(double)RAND_MAX)));

                real_world->NPCs.push_back(n);
        }


        // Direct awayn.attributes.insert(std::pair<string,int>("Hunger", 100));
        bool success = true, complete = false;
        StoryTracer tracer;
        while (story_root && !f.shutting_down && !complete)
        {
                forward_search(0 /* unused */);
                f_gd->root = forward_root; f_gd->fit();
                app.processEvents();
                complete = tracer.Trace(success);
                r_gd->root = regression_root; r_gd->fit();
                app.processEvents();
//              if (matches) execute_
//              success = networking stuff
                success = false;
                app.processEvents();
        }
}


void MakeOps()
{
        Operator OP;
        
        // Change Attribute Operator
        for(int i=0; i<NUM_COND; i++)
        {
                for(int j=0; j<NUM_COND; j++)
                {
                        ((OP.PreConds).conditions)[i][j]="";
                        ((OP.PostConds).conditions)[i][j]="";
                }
        }
        ((OP.PreConds).conditions)[0][0]="npc";
        ((OP.PostConds).conditions)[0][0]="npc";
        ((OP.PostConds).conditions)[1][0]="attrib value";
        OP.code=OP_CHANGEATTRIBUTE;
        Ops.push_back(OP);

        //MOVENPC Operator
        for(i=0; i<NUM_COND; i++)
        {
                for(int j=0; j<NUM_COND; j++)
                {
                        ((OP.PreConds).conditions)[i][j]="";
                        ((OP.PostConds).conditions)[i][j]="";
                }
        }
        ((OP.PreConds).conditions)[0][0]="npc";
        ((OP.PostConds).conditions)[0][0]="npc";
        ((OP.PostConds).conditions)[1][0]="xloc yloc";
        OP.code=OP_MOVENPC;
        Ops.push_back(OP);
}

void initRegressionPanes()
{
printf("Don't call initRegressionPanes()!\n");
/*
        // Reverse panes
        QGridLayout *r_layout = new QGridLayout((QWidget *)dfi->RegressionFrame, 1, 1, 5);
        for (int i = 0; i < regression_roots.size(); i++)
        {
                // Qt takes care of deallocation
                PlanGraphDisplay *r_gd1 = new PlanGraphDisplay(regression_roots[i]);
                QWidgetItem *wi = new QWidgetItem(r_gd1);
                r_layout->addItem(wi);  
        }
*/
}


/************************************************
 * Global Data definition - declaration in structures.h
 ************************************************/
StoryNode *story_root = NULL;           // root of story graph
World* real_world = NULL;                       // real world state
MYSQL* conn = NULL;                                     // database connection
list<Operator> Ops;                                     // operators

PlanNode* forward_root = NULL;          // forward search
PlanNode* regression_root;                      // regression plans
PlanNode* current_plan_root = NULL;     // complete plan being executed
list<vector<PlanNode*> > pending_execution;