CollisionsManager.cpp

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#include "config.h"
#include "CollisionsManager.h"
#include "ObjectManager.h"
#include "Configuration.h"
#include "Message.h"
#include "Window.h"

CollisionsManager::CollisionsManager(list<Collisionspair> *colpairs, list<Object*> *obj) {
    collisionpairs = colpairs;
    objects = obj;
}

void CollisionsManager::collide() {
    // sortiere Kollisionsliste, es werden dabei die Relationen aus der Klasse
    // Collisionspair verwendet
    collisionpairs->sort();

    // doppelte Paare loeschen
    collisionpairs->unique();

    // Anzahl der Kollisionspaare bestimmen
    int pairnumber = collisionpairs->size();
    // Objektanzahl bestimmen
    int objnumber = objects->size();

    // allokiere Speicher fuer pair (Verwendung: siehe unten) und initialisiere
    int *pair = new int[pairnumber] - 1;
    for(int i=1; i<=pairnumber; i++)
        pair[i] = i;

    // die folgenden for-Schleife weisst allen Paaren pair[i] den gleichen Wert
    // zu, wenn sie miteinander kollidieren
    list<Collisionspair>::iterator it;
    for(int i=1; i<=pairnumber; i++) {

        // setze Iterator auf i-tes Paar
        it=collisionpairs->begin();
        for(int j=1; j<i; j++)
            it++;

        // speichere Objektnummern des i-ten Paares
        int obj1 = it->i;
        int obj2 = it->j;

        // da die Kollisionspaare geordnet sind, reicht es aus nur die
        // groesseren Paare zu betrachten
        it++;
        int counter = i+1;
        while(it != collisionpairs->end()) {
            // wenn ein Objekt der beiden Paare gleich, dann bekommt das
            // groessere Paar den gleichen Wert wie das kleinere Paar
            if(obj1 == it->i || obj1 == it->j || obj2 == it->i || obj2 == it->j) {
                pair[counter] = pair[i];
            }
            it++;
            counter++;
        }
    }

    // Liste fuer neue Objekte
    list<Object*> newobjects;
    objectList::iterator it2;
    Object *obj=NULL, *obj2=NULL, *objmaxmass=NULL;

    // used wird verwendet, um sich zu merken, welches Objekt schon zu
    // Kollisionen herangezogen wurde (siehe unten)
    bool *used = new bool[objnumber]-1;

    // initialisiere used
    for(int i=1; i<=objnumber; i++)
        used[i]=false;

    for(int i=1; i<=pairnumber; i++) {

        // tue nicht wenn pair[i] schon verwendet wurde
        if(pair[i] == 0)
            continue;

        // Variablen fuer neue Daten
        Vector newpos(0.0,0.0,0.0);
        Vector zeros(0.0,0.0,0.0);
        Vector newv(0.0,0.0,0.0);
        double newradius=0.0;
        double newmass=0.0;
        double newvol=0.0;
        double maxmass=0.0;

        // initialisiere changeRef
        bool changeRef = false;

        for(int j=i; j<=pairnumber; j++) {
            // haben zwei Paare in pair[i] nicht den gleichen Wert, so muessen
            // sie nicht kollidiert werden
            if(pair[i] != pair[j])
                continue;
            if(j>i)
                // setze pair[j] auf 0, so dass es nicht mehr verwendet wird
                pair[j] = 0;

            // setze Iterator 1 auf j-tes Paar
            it=collisionpairs->begin();
            for(int z=1; z<j; z++)
                it++;

            if(! used[it->i]) {
                // setze Iterator 2 auf das Objekt i im j-ten Paar
                it2=objects->begin();
                for(int z=1; z<(it->i); z++)
                    it2++;

                obj = *it2;

                // falls obj das aktuell ausgewaehlte Objekt ist, setze
                // changeRef auf true (siehe unten)
                if(obj == ourConfiguration.clickedObject)
                    changeRef = true;

                // berechne Daten des neuen Objekts
                newv += obj->v * obj->mass;
                newradius += obj->radius;
                newmass += obj->mass;
                newvol += cubic(obj->radius)*4.0/3.0*PI;

                // anhand von objmaxmass wird spaeter der Typ des neuen Objekts
                // bestimmt
                if(obj->mass > maxmass) {
                    maxmass = obj->mass;
                    objmaxmass = obj;
                }
                used[it->i] = true;
            }
            // // setze Iterator 2 auf das j-te Objekt
            if(! used[it->j]) {
                it2=objects->begin();
                for(int z=1; z<(it->j); z++)
                    it2++;
                obj2 = *it2;

                // falls obj2 das aktuell ausgewaehlte Objekt ist, setze
                // changeRef auf true (siehe unten)
                if(obj2 == ourConfiguration.clickedObject)
                    changeRef = true;

                // berechne Daten des neuen Objekts
                newv += obj2->v * obj2->mass;
                newradius += obj2->radius;
                newmass += obj2->mass;
                newvol += cubic(obj2->radius)*4.0/3.0*PI;

                // anhand von objmaxmass wird spaeter der Typ des neuen Objekts
                // bestimmt
                if(obj2->mass > maxmass) {
                    maxmass = obj2->mass;
                    objmaxmass = obj2;
                }

                used[it->j] = true;
            }
            // berechne die neue Position: es wird hier ein gewichteter
            // Mittelwert des euklidischen Abstandes verwendet
            if(newpos == zeros) {
                newpos = (obj->pos - obj2->pos)* (obj->mass) /
                         (obj->mass+obj2->mass) + obj2->pos;
            } else {
                double massObj12=(obj->mass+obj2->mass);
                newpos = (((obj->pos - obj2->pos)* (obj->mass) / massObj12  +
                           obj2->pos)
                          - newpos)*(massObj12)/(massObj12+newmass)  + newpos;
            }

        }

        // markiere Paar als benutzt
        pair[i]=0;

        // berechne neuen radius, abhaenig vom Volumen
        newradius = pow((double)(newvol/4.0*3.0/PI),(double)(1.0/3.0));

        // neue Geschwindigkeit noch durch Masse teilen (Impulserhaltung)
        newv /= newmass;

        // erzeuge neues Objekt, wobei der Typ duch die
        Object * obj = ourObjectManager.createFreeObject(objmaxmass->getType());

        // fuege neues Objekt in die Liste der neuen Objekte ein
        newobjects.push_back(obj);

        // aktualisiere die Daten des neuen Objekts
        obj->pos = newpos;
        obj->v = newv;
        obj->radius = newradius;
        obj->mass = newmass;
        obj->setTexture(objmaxmass->getTexture());
        obj->setName(objmaxmass->getName());

        // falls eins der kollisierten Objekte das ausgewaehlte war, so muss
        // nun das neue Objekt, das clickedObject sein
        if (changeRef)
            ourConfiguration.clickedObject = obj;
    }

    // erstelle Liste mit Nummern der Objekte, die geloescht werden muessen
    list<int> deletelist;
    for(it=collisionpairs->begin();it != collisionpairs->end(); it++) {
        deletelist.push_back(it->i);
        deletelist.push_back(it->j);
    }
    // sortiere die deletelist
    deletelist.sort();

    // loesche mehrfach vorkommende
    deletelist.unique();

    string colmsg = "";
    unsigned int counter = 1;
    // loesche Objekte, die in der deletelist stehen
    for(list<int>::iterator it3=deletelist.end();it3 != deletelist.begin(); ) {
        it3--;
        // setze Iterator 2
        it2=objects->begin();
        for(int z=1; z<*it3; z++)
            it2++;

        // erzeuge Kollisionsnachricht
        if(counter > 1) {
            if(counter < deletelist.size())
                colmsg = colmsg + ", ";
            else
                colmsg = colmsg + " and ";
        }
        colmsg = colmsg + (*it2)->getName();
        counter++;

        // loesche die Objekte entgueltig
        ourObjectManager.deleteObject(it2);
    }
    // stelle Kollisionsnachricht fertig und gebe sie an Message weiter
    colmsg = colmsg + " collided";
    Message::msg(Message::COLLISION, colmsg);

    // loesche Liste der Kollisionspaare
    collisionpairs->clear();

    // fuege die neuen Objekte in die Objektliste ein
    for(list<Object*>::iterator it4=newobjects.begin();it4 != newobjects.end();
            it4++) {
        ourObjectManager.addFreeObjectToObjectList(*it4);
    }

    // aktualisiere Objektselektion
    Window::reloadObjectSelector();
}

---