---

objmgr.cpp

Go to the documentation of this file.

#include <iostream>
#include <list>
#include <vector>
#include "object.h"
#include "graphics.h"
#include "objmgr.h"
#include "bear.h"

ObjectManager::ObjectManager()
{
        crosshair = NULL;
        mainchar  = NULL;
}

ObjectManager::~ObjectManager()
{
cout << "ObjectManager List: (count = " << object_list.size() << ")" << endl;

        for(list<Object *>::iterator it = object_list.begin();
            it != object_list.end(); ++it) {

cout << "\t" << (*it)->obj->getName() << ": Layer " << (*it)->obj->GetLayer()
     << " at Y = " << (*it)->obj->GetY() << endl;

                delete (*it)->obj;
                delete (*it);
        }
        object_list.clear();    
}

void ObjectManager::AddToAnyObjectList(list<Object *>& ol, Object *obj)
{
        if ( !(obj->obj) ) {    // Let's hope this never happens!
cout << "THIS SHOULD NEVER HAPPEN " << endl;
                ol.insert (ol.end(), obj);
                return;
        }

        list<Object *>::iterator beg = ol.begin(), it;

        // If the list is empty, don't insert sort
        if (ol.size() == 0) {
                ol.push_back(obj);
                return;
        }

//      The following peice of code used to sort only based on
//      the object's Y value. The new code sorts based on a layer,
//      then the object's Y value.
//      if (obj->obj->GetLayer() == 0) {
//              // Put the object into the list in increasing Y order
//              while ( (it != ol.end()) && 
//                      (obj->obj->GetY() > (*it)->obj->GetY()) )
//                      it++;
//
//              // Insert wherever our iterator is
//              if ( it == ol.end() )
//                      ol.push_back(obj);
//              else
//                      ol.insert(it, obj);
//
//      } else {

        // Start at the end..
        it = ol.end();
        it--;

        int sortlayer = obj->obj->GetLayer();
        double sorty  = obj->obj->GetY();

        while ( (it != beg) &&
                (( sortlayer < (*it)->obj->GetLayer()) ||
                 (( sortlayer == (*it)->obj->GetLayer()) &&
                  ( sorty < (*it)->obj->GetY()))) )
                it--;

        if ( it == beg ) {
                bool before = false;

                if ( ( sortlayer < (*it)->obj->GetLayer()) )
                        before = true;

                else if ( (sortlayer == (*it)->obj->GetLayer()) &&
                          (sorty < (*it)->obj->GetY()))
                        before = true;

                if (!before)
                        it++;

                ol.insert (it, obj);
        } else {
                it++;

                ol.insert (it, obj);    // Insert inserts "before" the iterator
        }

        return;
}

void ObjectManager::AddToObjectList(Object *obj)
{
        AddToAnyObjectList (object_list, obj);
}

void ObjectManager::AddObject(GameObject *go, objecttype ot)
{
        Object *n = new Object;
        n->obj    = go;
        n->type   = ot;

        AddToObjectList(n);
}

GameObject* ObjectManager::AddObject(objecttype ot)
{
        Object *n = new Object;

        switch(ot) {
        case OT_MAINCHAR: n->obj = mainchar = new MainChar(*this); break;
        case OT_CROSSHAIR: n->obj = crosshair = new Crosshair(*this); break;
        case OT_UFO: n->obj = new UFO(*this); break;
        case OT_EXPLODE: n->obj = new ExplodeObject(*this); break;
        case OT_BEAR: n->obj = new Bear(*this); break;
        case OT_BEARSPAWN: n->obj = new BearSpawnPoint(*this); break;
        default: break;
        }

        n->type = ot;

        AddToObjectList(n);

        return n->obj;
}

vector<Rect> &ObjectManager::draw(Graphics &GD)
{

        // beginning
        list<Object *>::iterator it = object_list.begin();

        // Loop through all objects. This list should be
        // sorted in the way we want objects to be drawn on screen
        for (; it != object_list.end(); ++it) {
                // otherwise, draw object
                if ( (*it)->obj )       // if it contains a game object, draw it
                        object_draw_list.push_back ( (*it)->obj->draw (GD) );
        }

        return object_draw_list;
}

void ObjectManager::think()
{
        list<Object *>::iterator begin = object_list.begin(),   // for quick access
                                 end   = object_list.end(),     // for quick access
                                 itnext,                // Used for incrementing
                                 it,                    // Temporary iterator
                                 tmp;                   // Used once for removing elements

        // Loop from the beginning of the list to the end       
        for (it = begin; it != end; it = itnext) {
                itnext = it;
                itnext ++;      // the it iterator changes, save it's next ptr

                // Some Quick access variables
                Object *obj = (*it);
                GameObject *go = obj->obj;
        
                if (go) {
                        // Make our object think
                        go->think();

                        // Store its Y value for quick access
                        double ysort = go->GetY();
                        double layer = go->GetLayer();

                        // Sort this guy based on his Y going downward.
                        if (it != begin) {      // If we're not at the head...
                                tmp = it--;     // make a temporary iterator
                                object_list.erase (tmp);        // so we can delete and reinsert


//      The following peice of code used to sort only based on
//      the object's Y value. The new code sorts based on a layer,
//      then the object's Y value.
//                              if (layer == 0) {
//                                      // Find where it belongs in the list
//                                      for(; it != begin; --it) {
//                                              // If the previous is less than, don't go any farther
//                                              if ( (*it)->obj->GetY() <= ysort )
//                                                      break;
//      
//                                              // If the previous is more, go farther
//                                              if ( (*it)->obj->GetY() >  ysort )
//                                                      continue;
//                                      }
//
//                                      // If the previous is more than, insert before it
//                                      if ( (*it)->obj->GetY() > ysort )
//                                              object_list.insert (it, obj);
//
//                                      // otherwise insert after it.
//                                      else if ( (*it)->obj->GetY() <= ysort ) {
//                                              it++;
//                                              object_list.insert (it, obj);
//                                      }
//                              } else {

                                // Find where it belongs in the list
                                for(; it != begin; --it) {
                                        // If the previous is the same,
                                        // sort by Y value
                                        if ( (*it)->obj->GetLayer() == layer ) {
                                                // If the previous Y is less than, don't go any farther
                                                if ( (*it)->obj->GetY() <= ysort )
                                                        break;

                                                // If the previus is more, go farther
                                                if ( (*it)->obj->GetY() > ysort )
                                                        continue;
                                        }

                                        // If the previous layer is less than, don't go any farther
                                        if ( (*it)->obj->GetLayer() < layer )
                                                break;

                                        // If the previous is more, go farther
                                        if ( (*it)->obj->GetLayer() > layer )
                                                continue;
                                }

                                // "it" should be at begin, so compare
                                // against begin and order with begin.
                                if (it == begin) {
                                        double before = false;

                                        if ( (layer < (*it)->obj->GetLayer()) )
                                                before = true;
                                        else if ( (layer == (*it)->obj->GetLayer()) &&
                                                  (ysort < (*it)->obj->GetY()) )
                                                before = true;

                                        if (!before)
                                                it++;

                                } else if (it != end) // always insert after the iterator
                                        it++;

                                object_list.insert (it, obj);
                        }
                }
        }
}

void ObjectManager::animate() 
{
        list<Object *>::iterator it = object_list.begin();

        for(; it != object_list.end(); ++it) {
                if ( (*it)->obj )
                        (*it)->obj->animate();
        }
}

void ObjectManager::recenter()
{
        list<Object *>::iterator it = object_list.begin();

        for(; it != object_list.end(); ++it) {
                if ( (*it)->obj )
                        (*it)->obj->Recenter();
        }
}

GameObject *ObjectManager::GetObject(objecttype ot)
{
        switch(ot) {
        case OT_MAINCHAR:
                return mainchar;
        case OT_CROSSHAIR:
                return crosshair;
        default:
                list<Object *>::iterator it = object_list.begin();

                for(; it != object_list.end(); ++it) {
                        if ( (*it)->type == ot )
                                return (*it)->obj;
                }
                break;
        }
        return NULL;
}

void ObjectManager::update()
{
        list<Object *>::iterator tmp, it = object_list.begin();

        for(; it != object_list.end();) {
                tmp = it++;
                
                if ( (*tmp)->obj && (*tmp)->obj->IsDead() ) {
                        delete (*tmp)->obj;
                        delete (*tmp);
                        object_list.erase(tmp);
                }
        }
}

GameObject* ObjectManager::FindFirstCollision(Rect &R, bool exclude)
{
        list<Object *>::iterator it = object_list.begin();

        // exclude excludes cross hair and main character

        for (; it != object_list.end(); it++) {
                if(exclude) {
                        if ( (*it)->type == OT_CROSSHAIR ) continue;
                        if ( (*it)->type == OT_MAINCHAR  ) continue;
                }

                if ( (*it)->obj && (*it)->obj->IsCollidable() ) {
                        Rect S = (*it)->obj->GetBoundingRect();
                        if (Util_Intersect(R, S)) {
                                return (*it)->obj;
                        }
                }
        }

        return (GameObject *)NULL;
}

---