Trabalho LP1

/*
SamuelPordeus
26 de novembro de 2014
Primeiro trabalho de LP1
*/
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <math.h>

// 1ª PARTE - IMPLEMENTAÇÃO DAS CLASSES

using namespace std;

class canvas
{
    private:
        int pixelcanvas[1]; //Coordenadas x e y do canvas
        int TipoPoligono[150]; //0 = Retangulo 1 = Circulo 2 = Triangulo 3 = Hexagono

    public:
        canvas (int x, int y)
        {
                pixelcanvas[0] = x;
                pixelcanvas[1] = y;
        }

        int largura()
        {
           return pixelcanvas[0];
        }

        int altura()
       {
            return pixelcanvas[1];
        }

        int getTipoPoligono (int i)
        {
            return TipoPoligono[i];
        }
        void setTipoPoligono (int i, int z)
        {
            TipoPoligono[i] = z;
        }

        int ReturnPoligono (int xy)
        {
            return TipoPoligono[xy];
        }

        int VerPoligono (int count1) //Cada vez que um poligono novo for criado, seu tipo sera checado e ele sera acrescentado
        {
            int retangulo = 0, circulo = 0, triangulo = 0, hexagono = 0;
            for (int i = 0 ; i <count1 ; ++i)
            {
                switch (TipoPoligono[i])
                {
                case 0:
                    retangulo++;
                    break;
                case 1:
                    circulo++;
                    break;
                case 2:
                    triangulo++;
                    break;
                case 3:
                    hexagono++;
                    break;
                }
            }
        }
};

class poligono
{
    private:
        int CentroXY[1];
        int Zindex; //Um poligono em cima do outro
        string cor;

    public:
        void setCentro (int x, int y)
        {
            CentroXY[0]=x;
            CentroXY[1]=y;
        }

        int CentroX ()
        {
            return CentroXY[0];
        }
        int CentroY ()
        {
            return CentroXY[1];
        }

        void setCor (string color)
        {
            cor = color;
        }

        void setZ (int z)
        {
            Zindex=z;
        }

        void ReturnCentro (int *x, int *y)
        {
            *x = CentroXY[0];
            *y = CentroXY[1];
        }

        string ReturnCor ()
        {
            return cor;
        }
};

class retangulo:poligono
{
    private:
        int Base, Altura; //Variaveis necessarias para construirmos o retangulo

    public:
        retangulo ()
        {}

        int getAltura ()
        {
            return Altura;
        }

        int getBase ()
        {
            return Base;
        }
        void setBase  (int x)
        {
            Base = x;
        }
        void setAltura (int y)
        {
            Altura = y;
        }
        int ReturnArea ()
        {
            return Base * Altura;
        }

        int ReturnPerimeter ()
        {
            return (2*Base) + (2*Altura);
        }
};

class circulo:poligono
{
    private:
        int Raio;

    public:
        int getRaio ()
        {
            return Raio;
        }

        int setRaio (int r)
        {
            Raio = r;
        }
        int ReturnArea ()
        {
            return 3.14*Raio;
        }
        int ReturnPerimeter ()
        {
            return (2*Raio)*3,14;
        }
};

class triangulo:poligono
{
    private:
        int Lado; //Variaveis necessarias para construirmos o triangulo

    public:
        triangulo ()
        {}

        int getLado ()
        {
            return Lado;
        }
        void setLado (int x)
        {
            Lado = x;
        }
        int ReturnArea ()
        {
            return Lado * 6,92;
        }

        int ReturnPerimeter ()
        {
            return Lado * 3;
        }
};

class hexagono:poligono
{
    private:
        int Lado; //Variaveis necessarias para construirmos o hexagono

    public:
        hexagono ()
        {}

        int getLado ()
        {
            return Lado;
        }
        void setLado (int x)
        {
            Lado = x;
        }
        int ReturnArea ()
        {
            return 6* Lado * Lado *(sqrt(3))/4;
        }

        int ReturnPerimeter ()
        {
            return Lado * 3;
        }
};

// 2ª PARTE - IMPLEMENTAÇÃO DO PROGRAMA

void CanvasInfo (canvas cnv, int x)
{
    int Altura, Largura;
    Altura = cnv.altura();
    Largura = cnv.largura();
    cout << "Altura do canvas: "<<Altura << "\t Largura do canvas: " << Largura <<endl<<endl;
}

void InsertRetangulo (retangulo *p, canvas a)
{
        int x, y, opt, CentroX, CentroY, overaltura, overbase, count1;
    string Cor;
    cout << "INSIRA O RETANGULO: "<<endl;
    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM DE TAMANHO NA LARGURA
    {
        cout << "Insira o tamanho da base do retangulo: ";
        cin >> x; cout <<endl;
        if (x>=a.largura())
        {
            cout << "Grande demais, defina um tamanho menor para a base";
        }
        else
        {
            break;
        }
    }

    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM DE TAMANHO NA ALTURA
    {
        cout << "Insira o tamanho da altura do retangulo: ";
        cin >> y; cout <<endl;
        if (y>=a.altura())
        {
            cout << "Grande demais, defina um tamanho menor para a altura";
        }
        else
        {
            break;
        }
    }

    p->setBase (x);
    p->setAltura (y);

    cout <<"Quais as coordenadas do centro do retangulo? \n";
    cout<<"A coordenada x: ";
    cin>>CentroX; cout<<endl;
    cout<<"A coordenada y: ";
    cin >>CentroY; cout<<endl;

    overaltura = a.altura()-p->getAltura()/2;
    overbase = a.largura()-p->getBase()/2;

    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM SE O RETANGULO ESTA NO CANVAS
    {

        if ((p->getAltura()/2)>=CentroX || p->getBase()/2>=CentroY || overaltura<=CentroX || overbase<=CentroY)
        {
        cout<<"O retangulo nao esta ajustado ao canvas. Escolha novamente as coordenadas ";
        cout<<"Digite a coordenada x: ";
        cin>>CentroX;
        cout<<endl;
        cout<<"Digite a coordenada y: ";
        cin>>CentroY;
        cout<<endl;
        }
        else
        {
            break;
        }
    }

    cout << "O poligono criado esta sobreposto? 1 = Sim 2 = Nao ";
    cin >> opt; cout<<endl;

    do {
    if (opt==1)
        {
            int z;
            cout << "Esta sobreposto a quantos poligonos? ";
            cin >> z; cout<<endl;
            p->setZ(z);
            break;
        }
    else if (opt==2)
        {
        p->setZ(0);
        break;
        }
    else
    {
        cout <<"Opcao invalida, escolha uma opcao valida"<<endl; cin>>opt;
        continue;
    }
    }
    while(opt!=1&&opt!=2);
    cout << "Qual a cor do poligono?";
    string cor;
    cin >> cor; cout<<endl;
    p->setCor(cor);
    cout << "O retangulo foi adicionado com sucesso!"<<endl;

}

void InsertCirculo (circulo *p, canvas a)
{
    int r, opt, CentroX, CentroY, overraio1, overraio2, count1;
    string cor;
    cout << "INSIRA O CIRCULO: "<<endl;
    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM DE TAMANHO NA LARGURA
    {
        cout << "Insira o tamanho do raio do circulo: ";
        cin >> r; cout <<endl;
        if(2*r>a.altura() || 2*r>a.altura())
        {
            cout << "Grande demais, defina um tamanho menor para o raio";
        }
        else
        {
            break;
        }
    }

    p->setRaio(r);

    cout <<"Quais sao as coordenadas do centro do circulo? \n";
    cout<<"A coordenada X: ";
    cin>>CentroX; cout<<endl;
    cout<<"A coordenada Y: ";
    cin >>CentroY; cout<<endl;

    overraio1 = a.altura()-p->getRaio();
    overraio2 = a.largura()-p->getRaio();

    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM SE O CIRCULO ESTA NO CANVAS
    {

        if (p->getRaio()>=CentroX || p->getRaio()>=CentroY || overraio1<=CentroX || overraio2<=CentroY)
        {
        cout<<"O circulo nao esta ajustado ao canvas. Escolha novamente as coordenadas ";
        cout<<"Digite a coordenada x: ";
        cin>>CentroX;
        cout<<endl;
        cout<<"Digite a coordenada y: ";
        cin>>CentroY;
        cout<<endl;
        }
        else
        {
            break;
        }
    }

    cout << "O poligono criado esta sobreposto? 1 = Sim 2 = Nao ";
    cin >> opt; cout<<endl;

    do {
    if (opt==1)
        {
            int z;
            cout << "Esta sobreposto a quantos poligonos? ";
            cin >> z; cout<<endl;
            p->setZ(z);
            break;
        }
    else if (opt==2)
        {
        p->setZ(0);
        break;
        }
    else
    {
        cout <<"Opcao invalida, escolha uma opcao valida"<<endl; cin>>opt;
        continue;
    }
    }
    while(opt!=1&&opt!=2);
    cout << "Qual a cor do poligono?";
    string Cor;
    cin >> Cor; cout<<endl;
    p->setCor(Cor);
    cout << "O circulo foi adicionado com sucesso!"<<endl;

}

void InsertTriangulo (triangulo *p, canvas a)
{
    int lado, opt, CentroX, CentroY, overbase, overaltura, count1;
    string cor;
    cout << "INSIRA O CIRCULO: "<<endl;
    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM DE TAMANHO NA LARGURA
    {
        cout << "Insira o tamanho do lado do triangulo: ";
        cin >> r; cout <<endl;
        if (lado>a.largura())
        {
            cout << "Grande demais, defina um tamanho menor para o lado";
        }
        else
        {
            break;
        }
    }

    p->setLado(lado);

    cout <<"Quais sao as coordenadas do centro do circulo? \n";
    cout<<"A coordenada X: ";
    cin>>CentroX; cout<<endl;
    cout<<"A coordenada Y: ";
    cin >>CentroY; cout<<endl;

    restobase=t.largura()-p->getbase()/2;

    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM SE O CIRCULO ESTA NO CANVAS
    {

        if ((p->getLado()/2)>=CentroX || p->getLado()/2>=CentroY || overbase<=CentroX || overaltura<=CentroY)
        {
            cout<<"O triangulo nao esta ajustado ao canvas. Escolha novamente as coordenadas ";
            cout<<"Digite a coordenada x: ";
            cin>>CentroX;
            cout<<endl;
            cout<<"Digite a coordenada y: ";
            cin>>CentroY;
            cout<<endl;
        }
        else
        {
            break;
        }
    }

    cout << "O poligono criado esta sobreposto? 1 = Sim 2 = Nao ";
    cin >> opt; cout<<endl;

    do {
    if (opt==1)
        {
            int z;
            cout << "Esta sobreposto a quantos poligonos? ";
            cin >> z; cout<<endl;
            p->setZ(z);
            break;
        }
    else if (opt==2)
        {
        p->setZ(0);
        break;
        }
    else
    {
        cout <<"Opcao invalida, escolha uma opcao valida"<<endl; cin>>opt;
        continue;
    }
    }
    while(opt!=1&&opt!=2);
    cout << "Qual a cor do poligono?";
    string Cor;
    cin >> Cor; cout<<endl;
    p->setCor(Cor);
    cout << "O triangulo foi adicionado com sucesso!"<<endl;

}

void InsertHexagono (retangulo *p, canvas a)
{
        int lado, opt, CentroX, CentroY, overlado1, overlado2, count1;
    string Cor;
    cout << "INSIRA O HEXAGONO: "<<endl;
    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM DE TAMANHO NA LARGURA
    {
        cout << "Insira o tamanho do lado do hexaogono: ";
        cin >> lado; cout <<endl;
        if ((lado*2)>=a.largura())
        {
            cout << "Grande demais, defina um tamanho menor para o lado";
        }
        else
        {
            break;
        }
    }

    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM DE TAMANHO NA ALTURA
    {
        cout << "Insira o tamanho da altura do retangulo: ";
        cin >> lado; cout <<endl;
        if ((lado*2)>=a.altura())
        {
            cout << "Grande demais, defina um tamanho menor para a altura";
        }
        else
        {
            break;
        }
    }

    p->setLado (lado);

    cout <<"Quais as coordenadas do centro do hexagono? \n";
    cout<<"A coordenada x: ";
    cin>>CentroX; cout<<endl;
    cout<<"A coordenada y: ";
    cin >>CentroY; cout<<endl;

    overlado1 = a.altura()-p->getLado();
    overlado2 = a.largura()-p->getLado();

    for (count1 = 0 ; count1 < 10000 ; count1++) //CHECAGEM SE O RETANGULO ESTA NO CANVAS
    {

        if (p->getLado()>=CentroX || p->getLado()>=CentroY || overlado1<=centrox || overlado2<=centroy)
        {
        cout<<"O hexagono nao esta ajustado ao canvas. Escolha novamente as coordenadas ";
        cout<<"Digite a coordenada x: ";
        cin>>CentroX;
        cout<<endl;
        cout<<"Digite a coordenada y: ";
        cin>>CentroY;
        cout<<endl;
        }
        else
        {
            break;
        }
    }

    cout << "O poligono criado esta sobreposto? 1 = Sim 2 = Nao ";
    cin >> opt; cout<<endl;

    do {
    if (opt==1)
        {
            int z;
            cout << "Esta sobreposto a quantos poligonos? ";
            cin >> z; cout<<endl;
            p->setZ(z);
            break;
        }
    else if (opt==2)
        {
        p->setZ(0);
        break;
        }
    else
    {
        cout <<"Opcao invalida, escolha uma opcao valida"<<endl; cin>>opt;
        continue;
    }
    }
    while(opt!=1&&opt!=2);
    cout << "Qual a cor do poligono?";
    string cor;
    cin >> cor; cout<<endl;
    p->setCor(cor);
    cout << "O hexagono foi adicionado com sucesso!"<<endl;

}

void PoligonoInfo (retangulo *a,circulo *b, triangulo *c, hexagono *d,canvas *p,int i)
{

    switch (p->getTipoPoligono(i))
    {
    case 4:
        break;
    case 0:
        cout<<"Retangulo\t"<<"Centro: "<<a->CentroX()<<", "<<a->CentroY()<<"\t"<<"Cor: "<<a->ReturnCor()<<"\t"<<"Area: "<<a->ReturnArea()<<"\t"<<"Perimetro: "<<a->ReturnPerimeter()<<endl;
        break;
    case 1:
        cout<<"Circulo\t"<<"Centro: "<<b->CentroX()<<", "<<b->CentroY()<<"\t"<<"Cor: "<<b->ReturnCor()<<"\t"<<"Area: "<<b->ReturnArea()<<"\t"<<"Perimetro: "<<b->ReturnPerimeter()<<endl;
        break;
    case 2:
        cout<<"Triangulo\t"<<"Centro: "<<c->CentroX()<<", "<<c->CentroY()<<"\t"<<"Cor: "<<c->ReturnCor()<<"\t"<<"Area: "<<c->ReturnArea()<<"\t"<<"Perimetro: "<<c->ReturnPerimeter()<<endl;
        break;
    case 3:
        cout<<"Hexagono\t"<<"Centro: "<<a->CentroX()<<", "<<d->CentroY()<<"\t"<<"Cor: "<<d->ReturnCor()<<"\t"<<"Area: "<<d->ReturnArea()<<"\t"<<"Perimetro: "<<d->ReturnPerimeter()<<endl;
        break;
    default: cout << "\n\nPoligono nao identificado!\n"<<endl;
    }
}

void PoligonoExcluir (retangulo *a,circulo *b, triangulo *c, hexagono *d,canvas *p,int i)
{

    int opt;
    if (p->getTipoPoligono(i)==0)
    {
        cout<<"Retangulo\t"<<"Centro: "<<a->CentroX()<<", "<<a->CentroY()<<"\t"<<"Cor: "<<a->ReturnCor()<<"\t"<<"Area: "<<a->ReturnArea()<<"\t"<<"Perimetro: "<<a->ReturnPerimeter()<<endl;
        cout<<"\nDeseja excluir esse poligono? 1=sim  2=nao   ";
        cin>>opt;
        if (opt==1) {p->setTipoPoligono(i,0);}
    }
    else if (p->gettipo(i)==1)
    {
        cout<<"Circulo\t"<<"Centro: "<<b->CentroX()<<", "<<b->CentroY()<<"\t"<<"Cor: "<<b->ReturnCor()<<"\t"<<"Area: "<<b->ReturnArea()<<"\t"<<"Perimetro: "<<b->ReturnPerimeter()<<endl;
        cout<<"\nDeseja excluir esse poligono? 1=sim  2=nao   ";
        cin>>opt;
        if (opt==1) {p->setTipoPoligono(i,0);}
    }
    else if (p->gettipo(i)==2)
    {
        cout<<"Triangulo\t"<<"Centro: "<<c->CentroX()<<", "<<c->CentroY()<<"\t"<<"Cor: "<<c->ReturnCor()<<"\t"<<"Area: "<<c->ReturnArea()<<"\t"<<"Perimetro: "<<c->ReturnPerimeter()<<endl;
        cout<<"\nDeseja excluir esse poligono? 1=sim  2=nao   ";
        cin>>opt;
        if (opt==1) {p->setTipoPoligono(i,0);}
    }
    else if (p->gettipo(i)==3)
    {
        cout<<"Hexagono\t"<<"Centro: "<<a->CentroX()<<", "<<d->CentroY()<<"\t"<<"Cor: "<<d->ReturnCor()<<"\t"<<"Area: "<<d->ReturnArea()<<"\t"<<"Perimetro: "<<d->ReturnPerimeter()<<endl;
        cout<<"\nDeseja excluir esse poligono? 1=sim  2=nao   ";
        cin>>opt;
        if (opt==1) {p->setTipoPoligono(i,0);}

    }


}

int SomaArea (retangulo *a,circulo *b, triangulo *c, hexagono *d,canvas *p,int i)
{
    switch (p->getTipoPoligono(i))
    {
    case 0:
        break;
    case 1:
        return a->ReturnArea();
        break;
    case 2:
        return b->ReturnArea();
        break;
    case 3:
        return c->ReturnArea();
        break;
    case 4:
        return d->ReturnArea();
        break;
}
}

int SomaPerimeter(retangulo *a,circulo *b, triangulo *c, hexagono *d,canvas *p,int i)
{
    switch (p->getTipoPoligono(i))
    {
    case 0:
        break;
    case 1:
        return a->ReturnPerimeter();
        break;
    case 2:
        return b->ReturnPerimeter();
        break;
    case 3:
        return c->ReturnPerimeter();
        break;
    case 4:
        return d->ReturnPerimeter();
        break;
}
}

int main ()
{
    int opcao1, opcao, breaker;
    retangulo r[900];
    circulo c[900];
    triangulo t[900];
    hexagono h[900];
    do{
    system("cls");
    int PoligonoCount=0, opcao;;
    cout << "Bem-vindo ao Canvas. Aqui voce ira criar e manipular poligonos.";<< endl;
    int x,y;
    cout<<"\n1. Configurar o canvas\t\t\t2.Sair do canvas\n";
    do{
    cin>>opcao1;
    if (opcao1==1){
    cout << "================================================================================"<<endl;
    cout << "A partir de agora, criaremos o canvas utilizado, escolhendo as dimensoes dele\n"<<endl;
    cout << "Largura do canvas: ";
    cin >> x;
    cout <<endl;
    cout << "Altura do canvas: ";
    cin >> y;
    cout<<endl;
    }
    else if(opcao1==2){break;}
    else {cout <<"Opcao invalida! Digite uma opcao valida!\n"; continue; }
    }while(opcao1!=1 && opcao1!=2);
    canvas b (x, y);
    do{
    if (opcao1==2){break;}
    system("cls");
    cout << "================================================================================";
    cout << "Bem-vindo ao canvas, o menu abaixo mostra as opcoes disponiveis no programa!\n" << endl;
    cout << "=================================MENU PRINCIPAL================================="<<endl;
    cout << "1. Exibir informacoes do Canvas\n"<<endl;
    cout << "2. Inserir Retangulo\t\t\t";
    cout << "3. Inserir Circulo\n"<<endl;
    cout << "4. Inserir Triangulo\t\t\t";
    cout << "5. Inserir Hexagono\n"<<endl;
    cout << "6. Listar Poligonos\n"<<endl;
    cout << "7. Excluir Poligonos\n"<<endl;
    cout << "8. Soma das areas dos poligonos do Canvas\n"<<endl;
    cout << "9. Soma dos perimetros dos poligonos do Canvas\n"<<endl;
    cout << "10. Sair do Menu\n"<<endl;
    cout << "================================================================================"<<endl;
    do{
    if (opcao1==2){break;}
    cin >> opcao;
    if (opcao==1)
    {
        InfoCanvas(b,PoligonoCount);
        system("pause");
        break;
    }
    if (opcao==2)
    {
        InsertRetangulo(&r[PoligonoCount],b);
        b.setTipoPoligono()ipo(PoligonoCount,opcao);
        PoligonoCount++;
        system("pause");
        break;
    }
    else if (opcao==3)
    {
        InsertCirculo(&c[PoligonoCount],b);
        b.setTipoPoligono()ipo(PoligonoCount,opcao);
        PoligonoCount++;
        system("pause");
        break;
    }
    else if (opcao==4)
    {
        InsertTriangulo(&t[cPoligonoCount],b);
        b.setTipoPoligono()ipo(PoligonoCount,opcao);
        PoligonoCount++;
        system("pause");
        break;
    }
    else if (opcao==5)
    {
        InsertHexagono(&h[PoligonoCount],b);
        b.setTipoPoligono()ipo(PoligonoCount,opcao);
        PoligonoCount++;
        system("pause");
        break;
    }
    else if (opcao==6)
    {
        cout << "============================Informacao dos poligonos=============================="<<endl;
        if (PoligonoCount==0){cout<<"Nenhum poligono foi adicionado ainda\n"<<endl;}
        for(int i=0 ; i<PoligonoCount ; i++)
        {
            PoligonoInfo(&r[i],&c[i],&t[i],&h[i],&b,i);
        }
    cout << "================================================================================"<<endl;
    system("pause");
    break;
    }
    else if (opcao==7)
    {
        cout << "=============================EXCLUIR POLIGONOS================================"<<endl;
        if (PoligonoCount==0){cout<<"\nNenhum poligono foi adicionado\n\n";  cout << "================================================================================"<<endl; system("pause");  break;}
        cout << "Qual poligono de acordo com a ordem de insercao voce deseja excluir?"<<endl;
        cout<<"Voce possui "<<PoligonoCount<<" poligonos adicionados.\n\n"<<endl;
        int e;
        cin>>e;
        ExcluirPoligono(&r[e-1],&c[e-1],&t[e-1],&h[e-1],&b,e-1);
        cout << "\n==============================EXCLUIDO COM SUCESSO============================="<<endl;
        system("pause");
        break;
    }
    else if(opcao==8)
    {
        int SomaAux=0;
        for(int i=0; i<PoligonoCount;i++)
        {
            SomaAux+=SomaArea(&r[i],&c[i],&t[i],&h[i],&b,i);
        }
    cout << "=========================Soma das areas dos poligonos==========================="<<endl;
        cout << "O resultado eh: "<<SomaAux<<endl<<endl;
    cout << "================================================================================"<<endl;
        system("pause");
        break;
    }
    else if(opcao==9)
    {
        int PerimeterAux=0;
        for (int i=0; i<PoligonoCount;i++)
        {
            PerimeterAux+=SomaPerimeter(&r[i],&c[i],&t[i],&h[i],&b,i);
        }
        cout << "=======================Soma dos perimetros dos poligonos========================"<<endl;
        cout << "O resultado eh: "<<PerimeterAux<<endl<<endl;
        cout << "================================================================================"<<endl;
        system("pause");
        break;
    }
    else if(opcao==10)
    {
        break;
    }
    else {cout<<"Opcao invalida, digite novamente.\n"; continue;}
    }while(opcao!=10);
     if (opcao1==2){break;}
    }while(opcao!=10);
     if (opcao1==2){break;}
    }while (opcao1!=0);

}