Operacja "Mennica"

#include "pch.h"
#include <iostream>

using namespace std;

class Point {
public:
        float x, y, z;
};

class Node {
public:
    Point start, end;
    bool is_inside;
    Node *leaf[8];
};

int counter = 1;
int divisions_number = 0;

// Wczytanie danych
void Space_input(Node trunk)
{
    cout << "Wczytywanie danych przestrzeni, podaj wsp poczatku: ";
    cin >> trunk.start.x >> trunk.start.y >> trunk.start.z;
    cout << "Wczytywanie danych przestrzeni, podaj wsp konca: ";
    cin >> trunk.end.x >> trunk.end.y >> trunk.end.z;
}

void Object_input(Node object)
{
    cout << "Wczytywanie danych obiektu, podaj wsp poczatku: ";
    cin >> object.start.x >> object.start.y >> object.start.z;
    cout << "Wczytywanie danych obiektu, podaj wsp konca: ";
    cin >> object.end.x >> object.end.y >> object.end.z;
}

// Wyswietlanie wpisanych wartosci
void First_screen(Node &trunk, Node &object)
{
    cout << "MATRIX v1.1" << endl << endl;
    cout << "Obiekt" << endl;
    cout << "Wspolrzedne:" << " X " << object.end.x << " Y " << object.end.y << " Z " << object.end.z << endl << endl;
    cout << endl << "Przestrzen" << endl;
    cout << "Wspolrzedne:" << " X " << trunk.end.x << " Y " << trunk.end.y << " Z " << trunk.end.z << endl << endl;
}

// Funkcja od wciec w wyswietlaniu drzewa
void T_cout(int t_counter)
{
    for (int i = 0; i < t_counter; i++)
    {
        cout << "\t";
    }
}

void Check(Node &leaf, Node object, int leaf_number, int pktX, int pktY, int pktZ)
{
    leaf.is_inside = 0;
    //W zależności od nr liścia, sprawdzamy różne warunki współrzędnych
    switch (leaf_number)
    {
    case 0:
        if (object.start.x < pktX && object.start.y < pktY && object.start.z < pktZ)leaf.is_inside = true;
        break;
    case 1:
        if (object.end.x > pktX && object.start.y < pktY && object.start.z < pktZ)leaf.is_inside = true;
        break;
    case 2:
        if (object.end.x > pktX && object.start.y < pktY && object.end.z > pktZ)leaf.is_inside = true;
        break;
    case 3:
        if (object.start.x < pktX && object.start.y < pktY && object.end.z > pktZ)leaf.is_inside = true;
        break;
    case 4:
        if (object.start.x < pktX && object.end.y > pktY && object.start.z < pktZ)leaf.is_inside = true;
        break;
    case 5:
        if (object.end.x > pktX && object.end.y > pktY && object.start.z < pktZ)leaf.is_inside = true;
        break;
    case 6:
        if (object.end.x > pktX && object.end.y > pktY && object.end.z > pktZ)leaf.is_inside = true;
        break;
    case 7:
        if (object.start.x < pktX && object.end.y > pktY && object.end.z > pktZ)leaf.is_inside = true;
        break;
    }
}

void Division(Node &branch, Node object, int pktX, int pktY, int pktZ, int gen, int &t_counter)
{
    divisions_number++;

    for (int leaf_number = 0; leaf_number < 8; leaf_number++)
    {
        branch.leaf[leaf_number] = new Node;
        branch.leaf[leaf_number]->is_inside = 0;

        cout << endl;
        T_cout(t_counter);
        cout << "Nr liscia: " << leaf_number << endl;
        T_cout(t_counter);
        cout << "Wspolrzedne konca: X " << pktX << " Y " << pktY << " Z " << pktZ << endl;


        Check(*branch.leaf[leaf_number], object, leaf_number, pktX, pktY, pktZ);
        if (branch.leaf[leaf_number]->is_inside)
        {
            T_cout(t_counter);
            cout << "Obiekt w obszarze, aktualny licznik: " << counter << endl;
            t_counter++;
            counter++;
            if (gen >= 2)
            {
                switch (leaf_number)
                {
                case 0:
                    Division(*branch.leaf[leaf_number], object, pktX - gen / 2, pktY - gen / 2, pktZ - gen / 2, gen / 2, t_counter);
                    break;
                case 1:
                    Division(*branch.leaf[leaf_number], object, pktX + gen / 2, pktY - gen / 2, pktZ - gen / 2, gen / 2, t_counter);
                    break;
                case 2:
                    Division(*branch.leaf[leaf_number], object, pktX + gen / 2, pktY - gen / 2, pktZ + gen / 2, gen / 2, t_counter);
                    break;
                case 3:
                    Division(*branch.leaf[leaf_number], object, pktX - gen / 2, pktY - gen / 2, pktZ + gen / 2, gen / 2, t_counter);
                    break;
                case 4:
                    Division(*branch.leaf[leaf_number], object, pktX - gen / 2, pktY + gen / 2, pktZ - gen / 2, gen / 2, t_counter);
                    break;
                case 5:
                    Division(*branch.leaf[leaf_number], object, pktX + gen / 2, pktY + gen / 2, pktZ - gen / 2, gen / 2, t_counter);
                    break;
                case 6:
                    Division(*branch.leaf[leaf_number], object, pktX + gen / 2, pktY + gen / 2, pktZ + gen / 2, gen / 2, t_counter);
                    break;
                case 7:
                    Division(*branch.leaf[leaf_number], object, pktX - gen / 2, pktY + gen / 2, pktZ + gen / 2, gen / 2, t_counter);
                    break;
                }
            }
            else t_counter = 1;
        }
        else
        {
            t_counter = 1;
            counter++;
        }
    }
}

int main()
{
    Node trunk, object;

    // Dziala dla wielokrotnosci 2 i szescianow
    trunk.start.x = trunk.start.y = trunk.start.z = 0;
    trunk.end.x = trunk.end.y = trunk.end.z = 8;
    object.start.x = object.start.y = object.start.z = 0;
    object.end.x = object.end.y = object.end.z = 1;

    //Space_input(trunk);
    //Object_input(object);

    int start_point = (trunk.end.x - trunk.start.x) / 2;
    int gen = start_point;
    int t_counter = 1;

    First_screen(trunk, object);
    Division(trunk, object, start_point, start_point, start_point, gen, t_counter);

    cout << endl << "Liczba podzialow: " << divisions_number << endl;

    return 0;
}