---

world.cc

Go to the documentation of this file.

#include "world.hh"
#include "vector.hh"
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include "loader.hh"
#include "event.hh"
#include "message.hh"
#include "context.hh"
#include "collisionevent.hh"

namespace anoid {
    namespace main {

        using namespace std;
        using namespace simple;
        using namespace base;
        using namespace config;
        using namespace context;

        void collisionCallback(void *client_data, DtObjectRef object1, DtObjectRef object2, const DtCollData *coll_data) {
            if (coll_data->normal[0] || coll_data->normal[1] || coll_data->normal[2]) {
                AbstractWorld *theWorld = (AbstractWorld *)client_data;
                Event *e = new CollisionEvent;
                e->addArgument((Object *) object1);
                e->addArgument((Object *) object2);
                e->addData(new Vector(coll_data->normal[0], coll_data->normal[1], coll_data->normal[2]));
                e->addData(new Vector(coll_data->point1[0], coll_data->point1[1], coll_data->point1[2]));
                e->addData(new Vector(coll_data->point2[0], coll_data->point2[1], coll_data->point2[2]));
                theWorld->send(e);
            }
        }

        World::World(Configuration &c, Context *context, double g): maxid(1), time(0.0), G(g), _context(context) {
            world = this;
            init(c);
        }

        void World::init(Configuration &c) {
            if (c.hasElement("G"))
                G = c.getDouble("G");

            old = SDL_GetTicks();

            AbstractWorld::init(c);
        }

        Event *World::loadEvent(const string &name) {
            Event *e = (Event *) loadObject(name);
            return e;
        }

        Event *World::loadEvent(const string &name, Configuration &c) {
            Event *e = (Event *) loadObject(name);
            e->init(c);
            return e;
        }

        Event *World::sendEvent(const string &name) {
            Event *e = loadEvent(name);
            send(e);
            return e;
        }

        Event *World::sendEvent(const string &name, Object *o1) {
            Event *e = sendEvent(name);
            e->addArgument(o1);
            return e;
        }

        Event *World::sendEvent(const string &name, Object *o1, Object *o2) {
            Event *e = sendEvent(name, o1);
            e->addArgument(o2);
            return e;
        }

        Event *World::sendEvent(const string &name, Object *o1, Object *o2, Object *o3) {
            Event *e = sendEvent(name, o1, o2);
            e->addArgument(o3);
            return e;
        }

        int World::getFreshID() {
            return ++maxid;
        }

        Object *World::loadObject(const string &name) {
            return New<Object>(name);
        }

        vector<Object*>::iterator World::begin() {
            return children.begin();
        }

        vector<Object*>::iterator World::end() {
            return children.end();
        }

        Object* World::add(Object *o) {
            Element *e = dynamic_cast<Element *>(o);
            if (e)
                childrenE.push_back(e);
            return AbstractWorld::add(o);
        }

        void World::update() {
            Uint32 now = SDL_GetTicks();
            time = ((double) (now - old)) / 1000.0;
            old = now;
            AbstractWorld::update();
        }

        void World::redraw() {
            AbstractWorld::redraw();
            if (!dtTest())
                dtProceed();
        }

        void World::send(Event *e) {
            events.push_back(e);
        }

        void World::listen(Object *o, const string &m) {
            listeners[strdup(m.c_str())].push_back(o);
            if (m == "CollisionMessage") {
                dtSetObjectResponse(o, collisionCallback, DT_SMART_RESPONSE, this);
            }
        }

        void World::fireEvents() {
            while (!events.empty()) {
                Event *e = events.front();
                if (dynamic_cast<Message *>(e)) {
                    vector<Object *>::iterator i = listeners[e->getType().c_str()].begin();
                    vector<Object *>::iterator j = listeners[e->getType().c_str()].end();
                    while (i != j) {
                        e->addArgument(*i);
                        ++i;
                    }
                }
                e->fire();
                delete e;
                events.pop_front();
            }
        }

    };
};

---

Anoid NG © Michael Westergaard, Martin Stig Stissing, Ronni Michael Laursen, and Kristian Bisgaard Lassen