#include <iostream>

int main()
{
    using namespace std;
    
    string answer;
    
    cout << "As you walk along the grassy field you're ambushed by a kobold! \n\n";
    cout << "What do you wish to do? \n\n";
    getline (cin,answer);
    cout << endl;
    {

    
    if (answer == "attack", "Attack");
    {
    cout << "You attack the kobold! \n\n";
    }
    
    if (answer == "defend", "Defend")
    {
    cout << "You brace yourself against the kobold's attack \n\n";
    }
    }
    system("pause");
    return 0;
}

String1.compare(String string2); //Where 'string1' is the name of the first string variable you want to compare

if (answer.compare("attack") == 0); //This is true if the value of the string variable 'answer' is exactly the same as the word 'attack'

if((a==b && c!=b)||(a==c && c>b))
    then

/**
 This class draws a table by scaling and moving blocks.
 The table feet are the plane y = 0
*/

class Table
{
    GLfloat tableX, tableY, tableZ;
    GLfloat legX, legY, legZ;
    
public:
    Table( GLfloat width, GLfloat length );
    void render();
};

#ifdef MacOSX
#include <OpenGL/gl.h>
#else
#include <GL/gl.h>
#endif
#include "Table.h"

// Cube vertex data
GLfloat Vertices[8][3] = {
    { -1.0, -1.0,  1.0 },
    {  1.0, -1.0,  1.0 },
    {  1.0,  1.0,  1.0 },
    { -1.0,  1.0,  1.0 },
    { -1.0, -1.0, -1.0 },
    {  1.0, -1.0, -1.0 },
    {  1.0,  1.0, -1.0 },
    { -1.0,  1.0, -1.0 } };

// Helper function to draw a quad given indices to vertex array
static void drawQuad(int a, int b, int c, int d)
{
    glVertex3fv(Vertices[a]);
    glVertex3fv(Vertices[b]);
    glVertex3fv(Vertices[c]);
    glVertex3fv(Vertices[d]);
}

/**
 drawBlock simply draws a cube from -1 to 1 in all directions.
 We change what it produces using transformations.
*/
static void drawBlock()
{
    glBegin(GL_QUADS);
    // "Near" face, z = 1
    glColor3f(0.6, 0.6, 0.6);
    drawQuad(0, 1, 2, 3);

    // "Right" face, x = 1
    glColor3f(0.4, 0.4, 0.4);
    drawQuad(1, 5, 6, 2);

    // "Far" face, z = -1
    glColor3f(0.2, 0.2, 0.2);
    drawQuad(5, 4, 7, 6);

    // "Left" face, x = -1
    glColor3f(0.4, 0.4, 0.4);
    drawQuad(4, 0, 3, 7);

    // "Top" face, y = 1
    glColor3f(0.8, 0.8, 0.8);
    drawQuad(3, 2, 6, 7);

    // "Bottom" face, y = -1
    glColor3f(0.1, 0.1, 0.1);
    drawQuad(4, 5, 1, 0);
    glEnd();    
}
  
/**
 Constructor - calculates the table's dimensions based on the
 desired height and width.
*/
Table::Table( GLfloat width, GLfloat length )
{
    tableX = width;
    tableY = 0.05;
    tableZ = length;
    
    legX = width / 64;
    legY = 0.5;
    legZ = width / 64;    
}  

/**
 Draw the table as a set of scaled blocks.
 Notice push and pop to make things easier.
*/  
void Table::render()
{
    // Now draw the scene...
    // First, move down twice the leg height
    // This makes the feet of the table the plane y = 0
    glTranslatef( 0.0, 2*legY, 0.0 );
           
    // Draw the table top
    glPushMatrix();
        glScalef( tableX, tableY, tableZ );
        drawBlock();
    glPopMatrix();

    // Now the 4 legs...
    glPushMatrix();
        glTranslatef( tableX-8*legX, -tableY-legY, tableZ-8*legZ );
        glScalef( legX, legY, legZ );
        drawBlock();
    glPopMatrix();

    glPushMatrix();
        glTranslatef( -tableX+8*legX, -tableY-legY, tableZ-8*legZ );
        glScalef( legX, legY, legZ );
        drawBlock();
    glPopMatrix();

    glPushMatrix();
        glTranslatef( -tableX+8*legX, -tableY-legY, -tableZ+8*legZ );
        glScalef( legX, legY, legZ );
        drawBlock();
    glPopMatrix();

    glPushMatrix();
        glTranslatef( tableX-8*legX, -tableY-legY, -tableZ+8*legZ );
        glScalef( legX, legY, legZ );
        drawBlock();
    glPopMatrix();    
    
    // Undo the translation at the start of the function
    glTranslatef( 0.0, -2*legY, 0.0 );    
}

#ifndef _SAMPLE_H
#define _SAMPLE_H

const int CONSTANT = 10;

enum SampleEnum
{
    ONE = 0,
    TWO,
    THREE
};

void sampleFunction();

class Sample
{
private:
    int one;

public:
    void foo();
};

#endif

#include "Sample.h"

#include <iostream>

using namespace std;

void sampleFunction()
{
    cout << "Hello\n";
}

void Sample::foo()
{
    one = CONSTANT;
}

#include <iostream>

using namespace std;

void doSomething()
{
   cout << "Doing something..." << endl;
}

class Object
{
private:
    int id;
public:
    Object() {}
    
    void setId(int i) 
    {
        id = i;
    }

    void printId 
    {
        cout << id << endl;
    }
};

#ifndef _OBJECT_H
#define _OBJECT_H

void doSomething();

class Object
{
private:
    int id;
public:
    Object();
    void setId(int i);
    void printId();
};

#endif

#include "object.h"

#include <iostream> 

using namespace std;

void doSomething()
{
   cout << "Doing something..." << endl;
}

Object::Object()
{
}

void Object::setId(int i)
{
    id = i;
}

void Object::printId()
{
    cout << id << endl;
}

#include "object.h"

int main()
{
    Object object;
    object.setId(10);
    object.printId();

    doSomething();

    return 0;
}

#ifndef _ANOTHER_OBJECT_H
#define _ANOTHER_OBJECT_H

#include "object.h"

class AnotherObject
{
    Object object;

public:
    void doSomeStuff();   
};

#endif