// main.cpp
#include <iostream>
#include "Trojkat.h"

using namespace std;

int main()
{
    Punkt A, B, C;
    A.x = 0;
    A.y = 0;
    B.x = 10;
    B.y = 0;
    C.x = 5;
    C.y = 5;
    Trojkat trojkat(A, B, C);
    cout << trojkat.get_obwod() << endl;
    cout << trojkat.get_pole() << endl;
    cout << trojkat.rownoboczny() << endl;
    cout << trojkat.rownoramienny() << endl;
    cout << trojkat.prostokatny() << endl;
    return 0;
}

// Trojkat.h
#ifndef TROJKAT_H
#define TROJKAT_H
#include "../head.h"

class Trojkat
{
        friend double dlugosc(Punkt, Punkt);
    public:
        Trojkat(Punkt, Punkt, Punkt);
        void set_points(Punkt, Punkt, Punkt);
        double get_pole() const;
        double get_obwod() const;
        bool rownoboczny() const;
        bool rownoramienny() const;
        bool prostokatny() const;
        bool przesun_trojkat(Punkt);
    private:
        Punkt A;
        Punkt B;
        Punkt C;
};

#endif // TROJKAT_H

// Trojkat.cpp
#include "Trojkat.h"
#include <cmath>

/*class Trojkat
{
        friend double dlugosc(Punkt, Punkt);
    public:
        Trojkat(Punkt, Punkt, Punkt);               ok
        void set_points(Punkt, Punkt, Punkt);       ok
        double get_pole() const;                    ok
        double get_obwod() const;                   ok
        bool rownoboczny() const;                   ok
        bool rownoramienny() const;                 ok
        bool prostokatny() const;                   ok
        bool przesun_trojkat(Punkt);                ok
    private:
        Punkt A;
        Punkt B;
        Punkt C;
};*/

double dlugosc(Punkt A, Punkt B)
{
    return pow((A.x - B.x)*(A.x - B.x) + (A.y - B.y)*(A.y - B.y), 0.5);
}

Trojkat::Trojkat(Punkt a, Punkt b, Punkt c) : A(a), B(b), C(c)
{
}

double Trojkat::get_obwod() const
{
    return dlugosc(A, B) + dlugosc(B, C) + dlugosc(A, C);
}

double Trojkat::get_pole() const
{
    double p = get_obwod() / 2;
    double a = dlugosc(B, C);
    double b = dlugosc(A, C);
    double c = dlugosc(A, B);
    return pow(p*(p - a) * (p - b) * (p - c), 0.5);
}

void Trojkat::set_points(Punkt a, Punkt b, Punkt c)
{
    A = a;
    B = b;
    C = c;
}

bool Trojkat::rownoboczny() const
{
    double a = dlugosc(B, C);
    double b = dlugosc(A, C);
    double c = dlugosc(A, B);
    if(a != b || a != c || b != c)
        return false;
    return true;
}

bool Trojkat::rownoramienny() const
{
    double a = dlugosc(B, C);
    double b = dlugosc(A, C);
    double c = dlugosc(A, B);
    if(a == b || a == c || b == c)
        return true;
    return false;
}

bool Trojkat::prostokatny() const
{
    double a = dlugosc(B, C);
    double b = dlugosc(A, C);
    double c = dlugosc(A, B);
    double przyp1, przyp2;
    if(a >= b && a >= c)
    {
        przyp1 = b;
        przyp2 = c;
    }
    else if(b >= a && b >= c)
    {
        przyp1 = a;
        przyp2 = c;
    }
    else
    {
        przyp1 = a;
        przyp2 = b;
    }
    if(przyp1 * przyp2 / 2 == get_pole())
        return true;
    return false;
}

bool Trojkat::przesun_trojkat(Punkt wektor)
{
    if((A.x + wektor.x < 0) || (A.y + wektor.y < 0) || (B.x + wektor.x < 0) || (B.y + wektor.y < 0) || (C.x + wektor.x < 0) || (C.y + wektor.y < 0))
        return false;
    A.x += wektor.x;
    A.y += wektor.y;
    B.x += wektor.x;
    B.y += wektor.y;
    C.x += wektor.x;
    C.y += wektor.y;
    return true;
}

// head.h
#ifndef HEAD_H_INCLUDED
#define HEAD_H_INCLUDED

class Trojkat;

struct Punkt
{
    unsigned x;
    unsigned y;
};

double dlugosc(Punkt, Punkt);

#endif // HEAD_H_INCLUDED