source: orxonox.OLD/orxonox/trunk/src/world.cc @ 2624

/* 
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Patrick Boenzli
   co-programmer: Christian Meyer
*/

#include "world.h"
#include "world_entity.h"
#include "collision.h"
#include "track.h"
#include "player.h"
#include "command_node.h"
#include "camera.h"

using namespace std;


/** 
    \brief create a new World
    
    This creates a new empty world!
*/
World::World ()
{
  entities = new List<WorldEntity>();
}

/** 
    \brief remove the World from memory
*/
World::~World ()
{
  unload ();
  delete entities;
}

/** 
    \brief checks for collisions
    
    This method runs through all WorldEntities known to the world and checks for collisions 
    between them. In case of collisions the collide() method of the corresponding entities 
    is called.
*/
void World::collide ()
{
  List<WorldEntity> *a, *b;
  WorldEntity *aobj, *bobj;
  
  a = entities->get_next();
  
  while( a != NULL)
    {
      aobj = a->get_object();
      if( aobj->bCollide && aobj->collisioncluster != NULL)
        {
          b = a->get_next();
          while( b != NULL )
            {
              bobj = b->get_object();
              if( bobj->bCollide && bobj->collisioncluster != NULL )
                {
                  unsigned long ahitflg, bhitflg;
                  if( check_collision ( &aobj->place, aobj->collisioncluster, 
                                        &ahitflg, &bobj->place, bobj->collisioncluster, 
                                        &bhitflg) );
                  {
                    aobj->collide (bobj, ahitflg, bhitflg);
                    bobj->collide (aobj, bhitflg, ahitflg);
                  }
                }
              b = b->get_next();
            }
        }
      a = a->get_next();
    }
}

/** 
    \brief runs through all entities calling their draw() methods
*/
void World::draw ()
{
  // draw geometry
  
  // draw entities
  List<WorldEntity> *l;
  WorldEntity* entity;
  
  l = entities->get_next();  
  while( l != NULL ) 
    { 
      entity = l->get_object();
      if( entity->bDraw ) entity->draw();
      l = l->get_next();
    }
  
  
  // draw debug coord system
  glLoadIdentity();
  

  glBegin(GL_LINES);
  
  for( float x = -128.0; x < 128.0; x += 25.0)
    {
      for( float y = -128.0; y < 128.0; y += 25.0)
        {
          glColor3f(1,0,0);
          glVertex3f(x,y,-128.0);
          glVertex3f(x,y,0.0);
          glColor3f(0.5,0,0);
          glVertex3f(x,y,0.0);
          glVertex3f(x,y,128.0);
        }
    }
  for( float y = -128.0; y < 128.0; y += 25.0)
    {
      for( float z = -128.0; z < 128.0; z += 25.0)
        {
          glColor3f(0,1,0);
          glVertex3f(-128.0,y,z);
          glVertex3f(0.0,y,z);
          glColor3f(0,0.5,0);
          glVertex3f(0.0,y,z);
          glVertex3f(128.0,y,z);
        }
    }
  for( float x = -128.0; x < 128.0; x += 25.0)
    {
      for( float z = -128.0; z < 128.0; z += 25.0)
        {
          glColor3f(0,0,1);
          glVertex3f(x,-128.0,z);
          glVertex3f(x,0.0,z);
          glColor3f(0,0,0.5);
          glVertex3f(x,0.0,z);
          glVertex3f(x,128.0,z);
        }
      
    }
  
  //draw track
  glColor3f(0,1,1);
  for( int i = 0; i < tracklen; i++)
    {
      glVertex3f(pathnodes[i].x,pathnodes[i].y,pathnodes[i].z);
      glVertex3f(pathnodes[(i+1)%tracklen].x,pathnodes[(i+1)%tracklen].y,pathnodes[(i+1)%tracklen].z);
    }
  glEnd();
}

/** 
    \brief updates Placements and notifies entities when they left the 
    world
    
    This runs trough all WorldEntities and maps Locations to Placements 
    if they are bound, checks whether they left the level boundaries 
    and calls appropriate functions.
*/
void World::update ()
{
  List<WorldEntity> *l;
  WorldEntity* entity;
  Location* loc;
  Placement* plc;
  Uint32 t;
  
  l = entities->get_next();  
  while( l != NULL ) 
    { 
      entity = l->get_object();
      
      if( !entity->isFree() )
        {
          loc = entity->get_location();
          plc = entity->get_placement();
          t = loc->part;
          
          /* check if entity has still a legal track-id */
          if( t >= tracklen )
            {
              printf("An entity is out of the game area\n");
              entity->left_world ();
            }
          else
            {
              while( track[t].map_coords( loc, plc) )
                {
                  track[t].post_leave (entity);
                  if( loc->part >= tracklen )
                    {
                      printf("An entity has left the game area\n");
                      entity->left_world ();
                      break;
                    }
                  track[loc->part].post_enter (entity);
                }
            }
        }
      else
        {
          /* TO DO: implement check whether this particular free entity 
             is out of the game area
             TO DO: call function to notify the entity that it left 
             the game area
          */
        }
      
      l = l->get_next();
    }
  
}

/** 
    \brief relays the passed time since the last frame to entities and Track parts
    \param deltaT: the time passed since the last frame in milliseconds
*/
void World::time_slice (Uint32 deltaT)
{
  List<WorldEntity> *l;
  WorldEntity* entity;
  float seconds = deltaT;
  
  seconds /= 1000;
  
  l = entities->get_next();  
  while( l != NULL) 
    { 
      entity = l->get_object();
      entity->tick (seconds);
      l = l->get_next();
    }
  
  for( int i = 0; i < tracklen; i++) track[i].tick (seconds);
}

/**
   \brief removes level data from memory
*/
void World::unload()
{
  if( pathnodes) delete []pathnodes;
  if( track) delete []pathnodes;
}

/**
   \brief loads a simple level for testing purposes
*/
void World::load_debug_level()
{
  // create some path nodes
  pathnodes = new Vector[6];
  pathnodes[0] = Vector(0, 0, 0);
  pathnodes[1] = Vector(-100, 40, 0);
  pathnodes[2] = Vector(-100, 140, 0);
  pathnodes[3] = Vector(0, 180, 0);
  pathnodes[4] = Vector(100, 140, 0);
  pathnodes[5] = Vector(100, 40, 0);    
  
  // create the tracks
  tracklen = 6;
  track = new Track[6];
  for( int i = 0; i < tracklen; i++)
    {
      track[i] = Track( i, (i+1)%tracklen, &pathnodes[i], &pathnodes[(i+1)%tracklen]);
    }
  
  // create a player
  WorldEntity* myPlayer = (WorldEntity*) spawn<Player>();
  
  // bind input
  Orxonox *orx = Orxonox::getInstance();
  orx->get_localinput()->bind (myPlayer);
  
  // bind camera
  orx->get_camera()->bind (myPlayer);
}

/**
   \brief calls the correct mapping function to convert a given "look at"-Location to a 
   Camera Placement
*/
void World::calc_camera_pos (Location* loc, Placement* plc)
{
  track[loc->part].map_camera (loc, plc);
}