Changeset 2190 for orxonox/trunk/src – Orxonox

orxonox/trunk/src/Makefile.am

-                      r2077
+                      r2190
 AM_CXXFLAGS="-I/usr/X11R6/include"
 AM_LDFLAGS="-L/usr/Mesa-6.0.1/lib  -L/usr/X11R6/lib -lXt -lX11"
+AM_LDFLAGS="-L/usr/Mesa-6.0.1/lib  -L/usr/X11R6/lib -lXt -lX11" $(MWINDOWS)
 #"-O3 -pedantic -fPIC -ffast-math -I/usr/X11R6/include"
 …
 bin_PROGRAMS=orxonox
 orxonox_SOURCES=orxonox.cc world.cc environment.cc player.cc npc.cc input_output.cc data_tank.cc ai.cc shoot_laser.cc shoot_rocket.cc world_entity.cc synchronisable.cc vector.cc ability.cc power_up.cc
+orxonox_SOURCES=orxonox.cc world.cc player.cc data_tank.cc world_entity.cc vector.cc camera.cc collision.cc command_node.cc ini_parser.cc keynames.cc track.cc
 #  uncomment the following if bencoder requires the math library
 #gui_LDADD=-lm
+#orxonox_LDADD=-lm
 #EXTRA_DIST=orxonox.lsm.in orxonox.spec.in orxonox.texinfo

orxonox/trunk/src/Makefile.in

-                      r2077
+                      r2190
 target_alias = @target_alias@
 AM_CXXFLAGS = "-I/usr/X11R6/include"
 AM_LDFLAGS = "-L/usr/Mesa-6.0.1/lib  -L/usr/X11R6/lib -lXt -lX11"
+AM_LDFLAGS = "-L/usr/Mesa-6.0.1/lib  -L/usr/X11R6/lib -lXt -lX11" $(MWINDOWS)
 #"-O3 -pedantic -fPIC -ffast-math -I/usr/X11R6/include"
 bin_PROGRAMS = orxonox
 orxonox_SOURCES = orxonox.cc world.cc environment.cc player.cc npc.cc input_output.cc data_tank.cc ai.cc shoot_laser.cc shoot_rocket.cc world_entity.cc synchronisable.cc vector.cc ability.cc power_up.cc
+orxonox_SOURCES = orxonox.cc world.cc player.cc data_tank.cc world_entity.cc vector.cc camera.cc collision.cc command_node.cc ini_parser.cc keynames.cc track.cc
 subdir = src
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 …
 PROGRAMS = $(bin_PROGRAMS)
+am_orxonox_OBJECTS = orxonox.$(OBJEXT) world.$(OBJEXT) \
+        environment.$(OBJEXT) player.$(OBJEXT) npc.$(OBJEXT) \
+        input_output.$(OBJEXT) data_tank.$(OBJEXT) ai.$(OBJEXT) \
+        shoot_laser.$(OBJEXT) shoot_rocket.$(OBJEXT) \
+        world_entity.$(OBJEXT) synchronisable.$(OBJEXT) \
+        vector.$(OBJEXT) ability.$(OBJEXT) power_up.$(OBJEXT)
+am_orxonox_OBJECTS = orxonox.$(OBJEXT) world.$(OBJEXT) player.$(OBJEXT) \
+        data_tank.$(OBJEXT) world_entity.$(OBJEXT) vector.$(OBJEXT) \
+        camera.$(OBJEXT) collision.$(OBJEXT) command_node.$(OBJEXT) \
+        ini_parser.$(OBJEXT) keynames.$(OBJEXT) track.$(OBJEXT)
 orxonox_OBJECTS = $(am_orxonox_OBJECTS)
 orxonox_LDADD = $(LDADD)
 …
 depcomp = $(SHELL) $(top_srcdir)/depcomp
 am__depfiles_maybe = depfiles
+@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/ability.Po ./$(DEPDIR)/ai.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/data_tank.Po ./$(DEPDIR)/environment.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/input_output.Po ./$(DEPDIR)/npc.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/orxonox.Po ./$(DEPDIR)/player.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/power_up.Po ./$(DEPDIR)/shoot_laser.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/shoot_rocket.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/synchronisable.Po ./$(DEPDIR)/vector.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/world.Po ./$(DEPDIR)/world_entity.Po
+@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/camera.Po ./$(DEPDIR)/collision.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/command_node.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/data_tank.Po ./$(DEPDIR)/ini_parser.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/keynames.Po ./$(DEPDIR)/orxonox.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/player.Po ./$(DEPDIR)/track.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/vector.Po ./$(DEPDIR)/world.Po \
+@AMDEP_TRUE@    ./$(DEPDIR)/world_entity.Po
 CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
         $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
 …
         -rm -f *.tab.c
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ability.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ai.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/camera.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/collision.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/command_node.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/data_tank.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/environment.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/input_output.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/npc.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ini_parser.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/keynames.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/orxonox.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/player.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/power_up.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shoot_laser.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/shoot_rocket.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/synchronisable.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/track.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vector.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/world.Po@am__quote@
 …
 #  uncomment the following if bencoder requires the math library
 #gui_LDADD=-lm
+#orxonox_LDADD=-lm
 #EXTRA_DIST=orxonox.lsm.in orxonox.spec.in orxonox.texinfo

orxonox/trunk/src/data_tank.cc

-                      r1956
+                      r2190
 using namespace std;
-float DataTank::xOffset = 0;
-float DataTank::yOffset = 0;
-float DataTank::zOffset = 0;
 DataTank::DataTank () {}
 DataTank::~DataTank () {}

orxonox/trunk/src/data_tank.h

-                      r1956
+                      r2190
   ~DataTank ();
-  static float xOffset;
-  static float yOffset;
-  static float zOffset;
 };

orxonox/trunk/src/orxonox.cc

-                      r2036
+                      r2190
    ### File Specific:
    main-programmer: Patrick Boenzli
+   co-programmer:
+*/
+#include <iostream>
+#include <cstdio>
+#include <GL/glut.h>
+#include "environment.h"
+   co-programmer: Christian Meyer
+*/
+#include "orxonox.h"
 #include "world.h"
 #include "input_output.h"
+#include "camera.h"
 #include "data_tank.h"
+#include "stdincl.h"
+#include "player.h"
+#include "npc.h"
+#include "shoot_laser.h"
+#include "orxonox.h"
+#include "command_node.h"
+#include <string.h>
 using namespace std;
+Orxonox::Orxonox ()
+/**
+        \brief create a new Orxonox
+*/
+Orxonox::Orxonox ()
+{
   pause = false;
+}
+/**
+        \brief remove Orxonox from memory
+*/
 Orxonox::~Orxonox ()
+{}
+/* this is a singleton class to prevent dublicates */
+{
+        Orxonox::singleton_ref = NULL;
+        if( world != NULL) delete world;
+        if( localinput != NULL) delete world;
+        if( localcamera != NULL) delete localcamera;
+        if( resources != NULL) delete resources;
+}
+/* this is a singleton class to prevent duplicates */
 Orxonox* Orxonox::singleton_ref = 0;
-World* Orxonox::world = 0;
-InputOutput* Orxonox::io = 0;
-Player* Orxonox::localPlayer = 0;
-bool Orxonox::pause = false;
-bool Orxonox::inputEnabled = false;
-bool Orxonox::upWeGo = false;
-bool Orxonox::downWeGo = false;
-bool Orxonox::rightWeGo = false;
-bool Orxonox::leftWeGo = false;
-bool Orxonox::shoot1 = false;
-int Orxonox::fps = 0;
-int Orxonox::alpha = 0;
-int Orxonox::beta = 0;
-//int Orxonox::offsetX = 0;
-//int Orxonox::offsetY = 0;
 Orxonox* Orxonox::getInstance (void)
 …
+}
+int Orxonox::globalInit (int argc, char** argv)
+{
+  glutInit(&argc, argv);
+  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
+/**
+        \brief this finds the config file
+        Since the config file varies from user to user and since one may want to specify different config files
+        for certain occasions or platforms this function finds the right config file for every occasion and stores
+        it's path and name into configfilename
+*/
+void Orxonox::get_config_file (int argc, char** argv)
+{
+/*      char* path;
+        #ifdef __WIN32__
+        path = getenv("");
+        #else
+        path = getenv("HOME");
+        #endif
+        if( path != NULL) strcpy (configfilename, path);
+        else strcpy (configfilename, "./");
+        strcat (configfilename, "/.orxonox.conf");*/
+        strcpy (configfilename, "orxonox.conf");
+}
+/**
+        \brief initialize Orxonox with command line
+*/
+int Orxonox::init (int argc, char** argv)
+{
+                // parse command line
+                // config file
+        get_config_file (argc, argv);
+                // initialize SDL
+  printf("> Initializing SDL\n");
+  if( SDL_Init (SDL_INIT_EVERYTHING) == -1)
+  {
+    printf ("Could not SDL_Init(): %s\n", SDL_GetError());
+    return -1;
+  }
+        // initialize everything
+  printf("> Initializing video\n");
+        if( init_video () == -1) return -1;
+  printf("> Initializing sound\n");
+        if( init_sound () == -1) return -1;
+  printf("> Initializing input\n");
+        if( init_input () == -1) return -1;
+  printf("> Initializing networking\n");
+        if( init_networking () == -1) return -1;
+  printf("> Initializing resources\n");
+        if( init_resources () == -1) return -1;
+  printf("> Initializing world\n");
+        if( init_world () == -1) return -1;
+        return 0;
+}
+/**
+        \brief initializes SDL and OpenGL
+*/
+int Orxonox::init_video ()
+{
+  // Set video mode
+  // TO DO: parse arguments for settings
+  SDL_GL_SetAttribute (SDL_GL_RED_SIZE, 5);
+  SDL_GL_SetAttribute (SDL_GL_GREEN_SIZE, 5);
+  SDL_GL_SetAttribute (SDL_GL_BLUE_SIZE, 5);
+  SDL_GL_SetAttribute (SDL_GL_DEPTH_SIZE, 16);
+  int bpp = 16;
+  int width = 640;
+  int height = 480;
+  Uint32 flags = SDL_HWSURFACE | SDL_OPENGL | SDL_GL_DOUBLEBUFFER;
+  if( (screen = SDL_SetVideoMode (width, height, bpp, flags)) == NULL)
+  {
+    printf ("Could not SDL_SetVideoMode(%d, %d, %d, %d): %s\n", width, height, bpp, flags, SDL_GetError());
+    SDL_Quit();
+    return -1;
+  }
+  // Set window labeling
+  // TO DO: Add version information to caption
+  SDL_WM_SetCaption( "Orxonox", "Orxonox");
+  // TO DO: Create a cool icon and use it here
+  // SDL_WM_SetIcon(SDL_Surface *icon, Uint8 *mask);
+  // OpenGL stuff
+  // (Is this all we initialize globally???)
+  glClearColor(0.0, 0.0, 0.0, 0.0);
   glEnable(GL_DEPTH_TEST);
+  glutInitWindowSize(500, 500);
+  //glutFullScreen();
+  glutInitWindowPosition(100, 100);
+  glutCreateWindow("OrxonoX");
+  glEnable(GL_COLOR);
   glShadeModel(GL_FLAT);
+  /* window event dispatchers */
+  glutDisplayFunc(display);
+  glutReshapeFunc(reshape);
+  glutKeyboardFunc(keyboard);
+  glutKeyboardUpFunc(upKeyboard);
+  glutTimerFunc(1000, timeSlice, 0);
+  cout << "measuring performance...";
+}
+int Orxonox::menuInit (void)
+{
+  glClearColor(0.0, 0.0, 0.0, 0.0);
+}
+int Orxonox::gameInit (void)
+{
+  glClearColor(0.0, 0.0, 0.0, 0.0);
+  /* world init, shouldnt be done here later */
+  world = new World;
+  (*world).initEnvironement();
+  localPlayer = new Player;
+  localPlayer->setPosition(0.0, -10.0, 3.0);
+  localPlayer->setCollisionRadius(2.0);
+  io = new InputOutput(world, localPlayer);
+  (*world).addPlayer(localPlayer);
+  Environment *env = new Environment;
+  (*world).addEnv(env);
+  NPC* npc = new NPC;
+  npc->setPosition(3.0, 0.0, 3.0);
+  npc->setCollisionRadius(1.0);
+  world->addNPC(npc);
+  NPC* npc2 = new NPC;
+  npc2->setPosition(-2.0, 10.0, 3.0);
+  npc2->setCollisionRadius(1.0);
+  world->addNPC(npc2);
+  glutSpecialFunc(specFunc);
+  glutSpecialUpFunc(releaseKey);
+  glutIdleFunc(continousRedraw);
+  //cout << "Orxonox::gameInit" << endl;
+}
+/* this is the time triggered function. heart beat*/
+void Orxonox::timeSlice(int value)
+{
+  cout << "got " << fps << " fps" << endl;
+  /* this is very very unsafe: io could be uninit */
+  io->setPlayerStep(19.2/fps); /* set player to propper speed */
+  localPlayer->shootLaser->setShootStep(20.0/fps); /* set shoot speed */
+  world->setWorldStep(7.0/fps); /* set the speed of the terrain moving away */
+  fps = 0;
+  inputEnabled = true;
+  glutTimerFunc(1000, timeSlice, 0);
+}
+void Orxonox::keyboard(unsigned char key, int x, int y)
+{
+  switch(key) {
+    /* perspectiv control */
+  case 'w':
+    beta -= 1;
+    break;
+  case 's':
+    beta += 1;
+    break;
+  case 'a':
+    alpha -= 1;
+    break;
+  case 'd':
+    alpha += 1;
+    break;
+    /* game controls */
+  case 'p':
+    if (pause)
+      {
+        cout << "unset pause" << endl;
+        glutIdleFunc(continousRedraw);
+        pause = false;
+      }
+    else
+      {
+        cout << "set pause" << endl;
+        glutIdleFunc(NULL);
+        pause = true;
+      }
+    break;
+  case 32:
+    shoot1 = true;
+    break;
+  case 27:
+  case 'q':
+    quitGame();
+    break;
+  // create camera
+  localcamera = new Camera();
+  return 0;
+}
+/**
+        \brief initializes the sound engine
+*/
+int Orxonox::init_sound ()
+{
+        printf("Not yet implemented\n");
+        return 0;
+}
+/**
+        \brief initializes input functions
+*/
+int Orxonox::init_input ()
+{
+        // create localinput
+        localinput = new CommandNode( configfilename);
+        return 0;
+}
+/**
+        \brief initializes network system
+*/
+int Orxonox::init_networking ()
+{
+        printf("Not yet implemented\n");
+        return 0;
+}
+/**
+        \brief initializes and loads resource files
+*/
+int Orxonox::init_resources ()
+{
+        printf("Not yet implemented\n");
+        return 0;
+}
+/**
+        \brief initializes the world
+*/
+int Orxonox::init_world ()
+{
+        world = new World();
+        // TO DO: replace this with a menu/intro
+        world->load_debug_level();
+        return 0;
+}
+/**
+        \brief exits Orxonox
+*/
+void Orxonox::quitGame()
+{
+        bQuitOrxonox = true;
+}
+/**
+        \brief this runs all of Orxonox
+*/
+void Orxonox::mainLoop()
+{
+        lastframe = SDL_GetTicks();
+        bQuitOrxonox = false;
+  // This is where everything is run
+printf("Orxonox|Entering main loop\n");
+  while( !bQuitOrxonox)
+  {
+        // Network
+        synchronize();
+    // Process input
+    handle_input();
+    // Process time
+    time_slice();
+    // Process collision
+    collision();
+    // Draw
+    display();
+  }
+}
+void Orxonox::upKeyboard(unsigned char key, int x, int y)
+{
+  switch(key) {
+  case 32:
+    shoot1 = false;
+    break;
+  }
+}
+void Orxonox::quitGame()
+{
+  //cout << "finished garbage colletion, quitting..." << endl;
+  exit(0);
+}
+void Orxonox::releaseKey(int key, int x, int y)
+{
+  switch(key) {
+  case GLUT_KEY_UP:
+    upWeGo = false;
+    break;
+  case GLUT_KEY_DOWN:
+    downWeGo = false;
+    break;
+  case GLUT_KEY_RIGHT:
+    rightWeGo = false;
+    break;
+  case GLUT_KEY_LEFT:
+    leftWeGo = false;
+    break;
+  }
+}
+/**
+   \brief special keys function. called by glut
+   Here are all special key function defined.
+*/
+void Orxonox::specFunc(int key, int x, int y)
+{
+  switch(key) {
+    /* spacecraft controls */
+  case GLUT_KEY_UP:
+    upWeGo = true;
+    break;
+  case GLUT_KEY_DOWN:
+    downWeGo = true;
+    break;
+  case GLUT_KEY_RIGHT:
+    rightWeGo = true;
+    break;
+  case GLUT_KEY_LEFT:
+    leftWeGo = true;
+    break;
+  }
+}
+void Orxonox::display()
+{
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  glColor3f(0.0, 0.5, 0.6);
+  glLoadIdentity();
+  gluLookAt(0.0, -14.0, 15.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
+  (*world).drawWorld();
+  glutSwapBuffers();
+}
+void Orxonox::continousRedraw()
+{
+  /* increment the frames-per-second counter*/
+  fps++;
+  /* check for collisions */
+  world->detectCollision();
+  /* check for input to pass it over */
+  if ( !pause && inputEnabled &&
+       (rightWeGo || leftWeGo || upWeGo || downWeGo || shoot1))
+    {
+      if (upWeGo)
+        (*io).goUp();
+      if (downWeGo)
+      (*io).goDown();
+      if (rightWeGo)
+        (*io).goRight();
+      if (leftWeGo)
+      (*io).goLeft();
+      if (shoot1)
+        (*io).shoot();
+    }
+  /* request repaint */
+  glutPostRedisplay();
+  //cout << "Orxonox::continousRedraw" << endl;
+}
+void Orxonox::reshape (int w, int h)
+{
+  glViewport(0, 0, (GLsizei) w, (GLsizei) h);
+  glMatrixMode(GL_PROJECTION);
+  glLoadIdentity();
+  glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 200.0);
+  glMatrixMode(GL_MODELVIEW);
+  glLoadIdentity(); //pb why a second time?
+}
+void Orxonox::testTheShit()
+{
+  //Player* pl = new Player;
+  //(*pl).setPosition(1, 1, 1);
+  //(*world).addPlayer(pl);
+  //NPC* nl = new NPC;
+  //(*world).addNPC(nl);
+  //(*world).addNPC(nl);
+  //(*world).addNPC(nl);
+  //(*world).addNPC(nl);
+  //(*world).addNPC(nl);
+  //(*world).addNPC(nl);
+  //(*world).testThaTest();
+}
+printf("Orxonox|Exiting the main loop\n");
+}
+/**
+        \brief handles sprecial events from localinput
+        \param event: an event not handled by the CommandNode
+*/
+void Orxonox::event_handler (SDL_Event* event)
+{
+        // Handle special events such as reshape, quit, focus changes
+}
+/**
+        \brief synchronize local data with remote data
+*/
+void Orxonox::synchronize ()
+{
+        // Get remote input
+        // Update synchronizables
+}
+/**
+        \brief run all input processing
+*/
+void Orxonox::handle_input ()
+{
+        // localinput
+                localinput->process();
+        // remoteinput
+}
+/**
+        \brief advance the timeline
+*/
+void Orxonox::time_slice ()
+{
+        Uint32 curframe = SDL_GetTicks();
+        if( !pause)
+        {
+                world->time_slice (curframe - lastframe);
+                world->update ();
+                localcamera->time_slice (curframe - lastframe);
+        }
+        lastframe = curframe;
+}
+/**
+        \brief compute collision detection
+*/
+void Orxonox::collision ()
+{
+        world->collide ();
+}
+/**
+        \brief handle keyboard commands that are not meant for WorldEntities
+        \param cmd: the command to handle
+        \return true if the command was handled by the system or false if it may be passed to the WorldEntities
+*/
+bool Orxonox::system_command (Command* cmd)
+{
+        if( !strcmp( cmd->cmd, "quit"))
+        {
+                if( !cmd->bUp) bQuitOrxonox = true;
+                return true;
+        }
+        return false;
+}
+/**
+        \brief render the current frame
+*/
+void Orxonox::display ()
+{
+                // clear buffer
+        glClear( GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+                // set camera
+        localcamera->apply ();
+                // draw world
+        world->draw ();
+                // draw HUD
+                // flip buffers
+        SDL_GL_SwapBuffers();
+}
+/**
+        \brief retrieve a pointer to the local Camera
+        \return a pointer to localcamera
+*/
+Camera* Orxonox::get_camera ()
+{
+        return localcamera;
+}
+/**
+        \brief retrieve a pointer to the local CommandNode
+        \return a pointer to localinput
+*/
+CommandNode* Orxonox::get_localinput ()
+{
+        return localinput;
+}
+/**
+        \brief retrieve a pointer to the local World
+        \return a pointer to world
+*/
+World* Orxonox::get_world ()
+{
+        return world;
+}
 int main (int argc, char** argv)
+{
+        printf(">>> Starting Orxonox <<<\n");
   Orxonox *orx = Orxonox::getInstance();
+  (*orx).globalInit(argc, argv);
+  //(*orx).menuInit(); pb: directly jump to the game, no menu
+  (*orx).gameInit();
+  glutMainLoop();
+  if( (*orx).init(argc, argv) == -1)
+  {
+    printf("! Orxonox initialization failed\n");
+    return -1;
+  }
+  (*orx).mainLoop();
+  //delete orx;
   return 0;
+}

orxonox/trunk/src/orxonox.h

-                      r2036
+                      r2190
+/*!
+    \file orxonox.h
+    \brief Orxonox core functions
+*/
 #ifndef ORXONOX_H
 #define ORXONOX_H
+#include <SDL/SDL.h>
+#include "stdincl.h"
+class CommandNode;
+class WorldEntity;
+class DataTank;
 class World;
+class InputOutput;
+class Player;
+class Camera;
+//! Orxonox core singleton class
+/**
+*/
 class Orxonox {
 …
   Orxonox ();
   ~Orxonox ();
   static World* world;
   static InputOutput* io;
   static Player* localPlayer;
   static bool pause;
   static bool inputEnabled;
   static bool upWeGo;
   static bool downWeGo;
   static bool rightWeGo;
   static bool leftWeGo;
   static bool shoot1;
   static int fps;
+  char configfilename[256];
+  World* world;
+  DataTank* resources;
+  CommandNode* localinput;
+  Camera* localcamera;
+  SDL_Surface* screen;
+  bool bQuitOrxonox;
+  bool pause;
+        Uint32 lastframe;
+  static int alpha;
+  static int beta;
+  static int offsetX;
+  static int offsetY;
+        void get_config_file (int argc, char** argv);
+                // main loop functions
+  void synchronize ();
+  void handle_input ();
+  void time_slice ();
+  void collision ();
+  void display ();
+        // subsystem initialization
+  int init_video ();
+  int init_sound ();
+  int init_input ();
+  int init_networking ();
+  int init_resources ();
+  int init_world ();
+ public:
+  static Orxonox* getInstance ();
+  void quitGame();
+  static void timeSlice(int value);
+  void event_handler (SDL_Event* event);
+  bool system_command (Command* cmd);
+ public:
+  static Orxonox* getInstance (void);
+  int globalInit (int argc, char** argv);
+  int menuInit (void);
+  int gameInit (void);
+  void testTheShit(void);
+  static void display (void);
+  static void continousRedraw(void);
+  static void reshape (int w, int h);
+  static void keyboard(unsigned char key, int x, int y);
+  static void upKeyboard(unsigned char key, int x, int y);
+  static void releaseKey(int key, int x, int y);
+  static void specFunc(int key, int x, int y);
+  static void quitGame(void);
+  int init (int argc, char** argv);
+        CommandNode* get_localinput();
+        Camera* get_camera();
+        World* get_world();
+  void mainLoop();
 };

orxonox/trunk/src/player.cc

-                      r2036
+                      r2190
    ### File Specific:
    main-programmer: Patrick Boenzli
    co-programmer:
+   co-programmer: Christian Meyer
 */
-#include <iostream>
-#include <stdlib.h>
-#include <GL/glut.h>
-#include "shoot_laser.h"
-#include "shoot_rocket.h"
-#include "data_tank.h"
 #include "player.h"
+#include "stdincl.h"
+#include "collision.h"
 using namespace std;
+Player::Player()
+   : WorldEntity() {
+  //cout << "Player::Player" << endl;
+  xCor = yCor = zCor = 0;
+  shootLaser = new ShootLaser;
+  shootRocket = new ShootRocket;
+Player::Player(bool isFree) : WorldEntity(isFree)
+{
+}
 Player::~Player ()
+{
-  //delete shootLaser;
+}
+void Player::setPosition( float x, float y, float z)
+void Player::post_spawn ()
+{
+  xCor = x; yCor = y; zCor = z;
+        travel_speed = 10.0;
+        velocity = Vector();
+        bUp = bDown = bLeft = bRight = bAscend = bDescend = false;
+        bFire = false;
+        acceleration = 10.0;
+        set_collision (new CollisionCluster (1.0, Vector(0,0,0)));
+}
+void Player::getPosition(float* x, float* y, float* z)
+void Player::tick (float time)
+{
+  *x = xCor; *y = yCor; *z = zCor;
+        // movement
+        move (time);
+}
+void Player::setCollisionRadius(float radius)
+void Player::hit (WorldEntity* weapon, Vector loc)
+{
-  collisionRadius = radius;
+}
+void Player::goX(float x)
+void Player::destroy ()
+{
-  xCor += x;
+}
+void Player::goY(float y)
+void Player::collide (WorldEntity* other,  Uint32 ownhitflags, Uint32 otherhitflags)
+{
-  yCor += y;
+}
 void Player::goZ(float z)
+void Player::command (Command* cmd)
+{
+  zCor += z;
+        printf("Player|recieved command [%s]\n", cmd->cmd);
+        if( !strcmp( cmd->cmd, "up")) bUp = !cmd->bUp;
+        else if( !strcmp( cmd->cmd, "down")) bDown = !cmd->bUp;
+        else if( !strcmp( cmd->cmd, "left")) bLeft = !cmd->bUp;
+        else if( !strcmp( cmd->cmd, "right")) bRight = !cmd->bUp;
+        else if( !strcmp( cmd->cmd, "fire")) bFire = !cmd->bUp;
+}
+void Player::draw ()
+{
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        float matrix[4][4];
+void Player::shoot(int n)
+{
+  //  if (shootLaser->inhibitor++ <= 100)
+  shootLaser->addShoot(xCor, yCor, zCor);
+  // else if (shootLaser->inhibitor++ <= 200)
+  shootLaser->addShootExt(xCor, yCor, zCor, .1, .4, .0);
+  //  else if (shootLaser->inhibitor++ <= 300)
+  shootLaser->addShootExt(xCor, yCor, zCor, -0.1, .4, .0);
+  //  else
+  shootLaser->inhibitor =0;
+  //  if (shootRocket->inhibitor++ >=80)
+  {
+    shootRocket->addBackParable(xCor, yCor, zCor);
+    shootRocket->addSideAcc(xCor, yCor, zCor, RIGHT);
+    shootRocket->addSideAcc(xCor, yCor, zCor, LEFT);
+    shootRocket->addRotater(xCor, yCor, zCor);
+    //  if (shootRocket->inhibitor >=90)
+    //        shootRocket->inhibitor =0;
+  }
+  //cout << "Player::shoot" << endl;
+  /*
+  shootLaser->addShoot(xCor, yCor, zCor);
+  shootLaser->addShootExt(xCor, yCor, zCor, .1, .4, .0);
+  shootLaser->addShootExt(xCor, yCor, zCor, -0.1, .4, .0);
+  //shootRocket->addShoot(xCor, yCor, zCor);
+  //cout << "Player::shoot" << endl;
+  */
+        glTranslatef(get_placement()->r.x,get_placement()->r.y,get_placement()->r.z);
+  get_placement()->w.matrix (matrix);
+  glMultMatrixf ((float*)matrix);
+        glBegin(GL_TRIANGLES);
+        glColor3f(1,0,0);
+        glVertex3f(0,0,0.5);
+        glColor3f(0,1,0);
+        glVertex3f(-0.5,0,-1);
+        glColor3f(0,0,1);
+        glVertex3f(0.5,0,-1);
+        glEnd();
+        printf("Player@%f/%f/%f\n", get_placement()->r.x, get_placement()->r.y, get_placement()->r.z);
+}
+void Player::get_lookat (Location* locbuf)
+{
+        *locbuf = *get_location();
+        //locbuf->dist += 5.0;
+}
+//void Player::addIO(InputOutput *io) {}
+void Player::left_world ()
+{
+}
+void Player::paint()
+void Player::move (float time)
+{
+  //cout << "Player::drawPlayer" << endl;
+  glPushMatrix();
+  glTranslatef(xCor, yCor, 3.0);
+  glScalef(1.0, 3.0, 1.0);
+  glutWireCube(1.0);
+  glPopMatrix();
+  /* draw all the shoots additionaly */
+  shootLaser->drawShoot();
+  shootRocket->drawShoot();
+  //cout << "Player::drawPlayer, end" << endl;
+        float xAccel, yAccel, zAccel;
+        xAccel = yAccel = zAccel = 0;
+        if( bUp) xAccel += acceleration;
+        if( bDown) xAccel -= acceleration;
+        if( bLeft) yAccel += acceleration;
+        if( bRight) yAccel -= acceleration;
+        if( bAscend) zAccel += acceleration;
+        if( bDescend) zAccel -= acceleration;
+        Vector accel( xAccel, yAccel, zAccel);
+        Location* l = get_location();
+        // r(t) = r(0) + v(0)*t + 1/2*a*t^2
+        // r = position
+        // v = velocity
+        // a = acceleration
+        l->pos = l->pos + velocity*time + (accel*(0.5*time*time));
+        l->dist += travel_speed * time;
+        velocity = velocity + (accel * time);
+        printf("Player|velocity %f/%f/%f\n", velocity.x, velocity.y, velocity.z);
+}
 …

orxonox/trunk/src/player.h

-                      r2036
+                      r2190
+/*!
+    \file player.h
+    \brief Implements a basic controllable WorldEntity
+*/
 #ifndef PLAYER_H
 …
 #include "world_entity.h"
+class ShootLaser;
+class ShootRocket;
+//! Basic controllable WorldEntity
 class Player : public WorldEntity
+{
+        friend class World;
  public:
   Player ();
+  Player (bool isFree = false);
   ~Player ();
+  /* position of the spacecraft */
+  float xCor;
+  float yCor;
+  float zCor;
+        virtual void post_spawn ();
+  virtual void tick (float time);
+  virtual void hit (WorldEntity* weapon, Vector loc);
+  virtual void destroy ();
+  virtual void collide (WorldEntity* other,  Uint32 ownhitflags, Uint32 otherhitflags);
+        virtual void command (Command* cmd);
+  float collisionRadius;
+  virtual void draw ();
+  virtual void get_lookat (Location* locbuf);
+  /* this player wanna shoot? so include a ref to ShootLaser */
+  ShootLaser* shootLaser;
+  ShootRocket* shootRocket;
+  void setPosition(float x, float y, float z);
+  void getPosition(float* x, float* y, float* z);
+  void setCollisionRadius(float radius);
+  void paint();
+  void goX(float x);
+  void goY(float y);
+  void goZ(float x);
+  void shoot(int n);
+  //  void addIO(InputOutput *io);
+  void drawPlayer(void);
+        virtual void left_world ();
  private:
+        bool bUp, bDown, bLeft, bRight, bAscend, bDescend;
+        bool bFire;
+        Vector velocity;
+        float travel_speed;
+        float acceleration;
+        void move (float time);
 };

orxonox/trunk/src/stdincl.h

-                      r1956
+                      r2190
 #define null 0
+#ifdef __WIN32__
+#include <windows.h>
 #endif
+#include <SDL/SDL.h>
+#include <GL/gl.h>
+#include "vector.h"
+#include "coordinates.h"
+#include "list.h"
+#include "message_structures.h"
+#include "orxonox.h"
+#endif

orxonox/trunk/src/vector.cc

-                      r2043
+                      r2190
    main-programmer: Christian Meyer
    co-programmer: ...
+   Quaternion code borrowed from an Gamasutra article by Nick Bobick and Ken Shoemake
 */
 …
   f = acos( v1 * v2 / (v1.len() * v2.len()));
   return f * 180 / PI;
+}
+/**
+        \brief creates a multiplicational identity Quaternion
+*/
+Quaternion::Quaternion ()
+{
+        w = 1;
+        v = Vector(0,0,0);
+}
+/**
+        \brief turns a rotation along an axis into a Quaternion
+        \param angle: the amount of radians to rotate
+        \param axis: the axis to rotate around
+*/
+Quaternion::Quaternion (float angle, const Vector& axis)
+{
+        w = cos(angle/2);
+        v = axis * sin(angle/2);
+}
+/**
+        \brief calculates a look_at rotation
+        \param dir: the direction you want to look
+        \param up: specify what direction up should be
+        Mathematically this determines the rotation a (0,0,1)-Vector has to undergo to point the same way as dir.
+        If you want to use this with cameras, you'll have to reverse the dir Vector (Vector(0,0,0) - your viewing direction)
+        or you'll point the wrong way. You can use this for meshes as well (then you do not have to reverse the vector), but keep in mind that if you do that, the model's front
+        has to point in +z direction, and left and right should be -x or +x respectively or the mesh wont rotate correctly.
+*/
+Quaternion::Quaternion (const Vector& dir, const Vector& up)
+{
+        Vector z = dir;
+  z.normalize();
+  Vector x = up.cross(z);
+  x.normalize();
+  Vector y = z.cross(x);
+  float m[4][4];
+  m[0][0] = x.x;
+  m[0][1] = x.y;
+  m[0][2] = x.z;
+  m[0][3] = 0;
+  m[1][0] = y.x;
+  m[1][1] = y.y;
+  m[1][2] = y.z;
+  m[1][3] = 0;
+  m[2][0] = z.x;
+  m[2][1] = z.y;
+  m[2][2] = z.z;
+  m[2][3] = 0;
+  m[3][0] = 0;
+  m[3][1] = 0;
+  m[3][2] = 0;
+  m[3][3] = 1;
+  *this = Quaternion (m);
+}
+/**
+        \brief calculates a rotation from euler angles
+        \param roll: the roll in radians
+        \param pitch: the pitch in radians
+        \param yaw: the yaw in radians
+        I DO HONESTLY NOT EXACTLY KNOW WHICH ANGLE REPRESENTS WHICH ROTATION. And I do not know in what order they are applied,
+        I just copy-pasted the code.
+*/
+Quaternion::Quaternion (float roll, float pitch, float yaw)
+{
+        float cr, cp, cy, sr, sp, sy, cpcy, spsy;
+        // calculate trig identities
+        cr = cos(roll/2);
+        cp = cos(pitch/2);
+        cy = cos(yaw/2);
+        sr = sin(roll/2);
+        sp = sin(pitch/2);
+        sy = sin(yaw/2);
+        cpcy = cp * cy;
+        spsy = sp * sy;
+        w = cr * cpcy + sr * spsy;
+        v.x = sr * cpcy - cr * spsy;
+        v.y = cr * sp * cy + sr * cp * sy;
+        v.z = cr * cp * sy - sr * sp * cy;
+}
+/**
+        \brief rotates one Quaternion by another
+        \param q: another Quaternion to rotate this by
+        \return a quaternion that represents the first one rotated by the second one (WARUNING: this operation is not commutative! e.g. (A*B) != (B*A))
+*/
+Quaternion Quaternion::operator*(const Quaternion& q) const
+{
+        float A, B, C, D, E, F, G, H;
+        Quaternion r;
+        A = (w   + v.x)*(q.w   + q.v.x);
+        B = (v.z - v.y)*(q.v.y - q.v.z);
+        C = (w   - v.x)*(q.v.y + q.v.z);
+        D = (v.y + v.z)*(q.w   - q.v.x);
+        E = (v.x + v.z)*(q.v.x + q.v.y);
+        F = (v.x - v.z)*(q.v.x - q.v.y);
+        G = (w   + v.y)*(q.w   - q.v.z);
+        H = (w   - v.y)*(q.w   + q.v.z);
+        r.w = B +  (-E - F + G + H)/2;
+        r.v.x = A - (E + F + G + H)/2;
+        r.v.y = C + (E - F + G - H)/2;
+        r.v.z = D + (E - F - G + H)/2;
+        return r;
+}
+/**
+        \brief add two Quaternions
+        \param q: another Quaternion
+        \return the sum of both Quaternions
+*/
+Quaternion Quaternion::operator+(const Quaternion& q) const
+{
+        Quaternion r(*this);
+        r.w = r.w + q.w;
+        r.v = r.v + q.v;
+        return r;
+}
+/**
+        \brief subtract two Quaternions
+        \param q: another Quaternion
+        \return the difference of both Quaternions
+*/
+Quaternion Quaternion::operator- (const Quaternion& q) const
+{
+        Quaternion r(*this);
+        r.w = r.w - q.w;
+        r.v = r.v - q.v;
+        return r;
+}
+/**
+        \brief rotate a Vector by a Quaternion
+        \param v: the Vector
+        \return a new Vector representing v rotated by the Quaternion
+*/
+Vector Quaternion::apply (Vector& v) const
+{
+        Quaternion q;
+        q.v = v;
+        q.w = 0;
+        q = *this * q * conjugate();
+        return q.v;
+}
+/**
+        \brief multiply a Quaternion with a real value
+        \param f: a real value
+        \return a new Quaternion containing the product
+*/
+Quaternion Quaternion::operator*(const float& f) const
+{
+        Quaternion r(*this);
+        r.w = r.w*f;
+        r.v = r.v*f;
+        return r;
+}
+/**
+        \brief divide a Quaternion by a real value
+        \param f: a real value
+        \return a new Quaternion containing the quotient
+*/
+Quaternion Quaternion::operator/(const float& f) const
+{
+        if( f == 0) return Quaternion();
+        Quaternion r(*this);
+        r.w = r.w/f;
+        r.v = r.v/f;
+        return r;
+}
+/**
+        \brief calculate the conjugate value of the Quaternion
+        \return the conjugate Quaternion
+*/
+Quaternion Quaternion::conjugate() const
+{
+        Quaternion r(*this);
+        r.v = Vector() - r.v;
+        return r;
+}
+/**
+        \brief calculate the norm of the Quaternion
+        \return the norm of The Quaternion
+*/
+float Quaternion::norm() const
+{
+        return w*w + v.x*v.x + v.y*v.y + v.z*v.z;
+}
+/**
+        \brief calculate the inverse value of the Quaternion
+        \return the inverse Quaternion
+        Note that this is equal to conjugate() if the Quaternion's norm is 1
+*/
+Quaternion Quaternion::inverse() const
+{
+        float n = norm();
+        if (n != 0)
+        {
+                return conjugate() / norm();
+        }
+        else return Quaternion();
+}
+/**
+        \brief convert the Quaternion to a 4x4 rotational glMatrix
+        \param m: a buffer to store the Matrix in
+*/
+void Quaternion::matrix (float m[4][4]) const
+{
+        float wx, wy, wz, xx, yy, yz, xy, xz, zz, x2, y2, z2;
+        // calculate coefficients
+        x2 = v.x + v.x;
+  y2 = v.y + v.y;
+        z2 = v.z + v.z;
+        xx = v.x * x2; xy = v.x * y2; xz = v.x * z2;
+        yy = v.y * y2; yz = v.y * z2; zz = v.z * z2;
+        wx = w * x2; wy = w * y2; wz = w * z2;
+        m[0][0] = 1.0 - (yy + zz); m[1][0] = xy - wz;
+        m[2][0] = xz + wy; m[3][0] = 0.0;
+        m[0][1] = xy + wz; m[1][1] = 1.0 - (xx + zz);
+        m[2][1] = yz - wx; m[3][1] = 0.0;
+        m[0][2] = xz - wy; m[1][2] = yz + wx;
+        m[2][2] = 1.0 - (xx + yy); m[3][2] = 0.0;
+        m[0][3] = 0; m[1][3] = 0;
+        m[2][3] = 0; m[3][3] = 1;
+}
+/**
+        \brief convert a rotational 4x4 glMatrix into a Quaternion
+        \param m: a 4x4 matrix in glMatrix order
+*/
+Quaternion::Quaternion (float m[4][4])
+{
+  float  tr, s, q[4];
+  int    i, j, k;
+  int nxt[3] = {1, 2, 0};
+  tr = m[0][0] + m[1][1] + m[2][2];
+        // check the diagonal
+  if (tr > 0.0)
+  {
+    s = sqrt (tr + 1.0);
+    w = s / 2.0;
+    s = 0.5 / s;
+    v.x = (m[1][2] - m[2][1]) * s;
+    v.y = (m[2][0] - m[0][2]) * s;
+    v.z = (m[0][1] - m[1][0]) * s;
+        }
+        else
+        {
+                // diagonal is negative
+        i = 0;
+        if (m[1][1] > m[0][0]) i = 1;
+    if (m[2][2] > m[i][i]) i = 2;
+    j = nxt[i];
+    k = nxt[j];
+    s = sqrt ((m[i][i] - (m[j][j] + m[k][k])) + 1.0);
+    q[i] = s * 0.5;
+    if (s != 0.0) s = 0.5 / s;
+          q[3] = (m[j][k] - m[k][j]) * s;
+    q[j] = (m[i][j] + m[j][i]) * s;
+    q[k] = (m[i][k] + m[k][i]) * s;
+        v.x = q[0];
+        v.y = q[1];
+        v.z = q[2];
+        w = q[3];
+  }
+}
 …
 /**
+   \brief fills the specified buffer with a 4x4 glmatrix
+   \param buffer: Pointer to an array of 16 floats
+   Use this to get the rotation in a gl-compatible format
+*/
+void Rotation::glmatrix (float* buffer)
+{
+        buffer[0] = m[0];
+        buffer[1] = m[3];
+        buffer[2] = m[6];
+        buffer[3] = m[0];
+        buffer[4] = m[1];
+        buffer[5] = m[4];
+        buffer[6] = m[7];
+        buffer[7] = m[0];
+        buffer[8] = m[2];
+        buffer[9] = m[5];
+        buffer[10] = m[8];
+        buffer[11] = m[0];
+        buffer[12] = m[0];
+        buffer[13] = m[0];
+        buffer[14] = m[0];
+        buffer[15] = m[1];
+}
+/**
+   \brief multiplies two rotational matrices
+   \param r: another Rotation
+   \return the matrix product of the Rotations
+   Use this to rotate one rotation by another
+*/
+Rotation Rotation::operator* (const Rotation& r)
+{
+        Rotation p;
+        p.m[0] = m[0]*r.m[0] + m[1]*r.m[3] + m[2]*r.m[6];
+        p.m[1] = m[0]*r.m[1] + m[1]*r.m[4] + m[2]*r.m[7];
+        p.m[2] = m[0]*r.m[2] + m[1]*r.m[5] + m[2]*r.m[8];
+        p.m[3] = m[3]*r.m[0] + m[4]*r.m[3] + m[5]*r.m[6];
+        p.m[4] = m[3]*r.m[1] + m[4]*r.m[4] + m[5]*r.m[7];
+        p.m[5] = m[3]*r.m[2] + m[4]*r.m[5] + m[5]*r.m[8];
+        p.m[6] = m[6]*r.m[0] + m[7]*r.m[3] + m[8]*r.m[6];
+        p.m[7] = m[6]*r.m[1] + m[7]*r.m[4] + m[8]*r.m[7];
+        p.m[8] = m[6]*r.m[2] + m[7]*r.m[5] + m[8]*r.m[8];
+        return p;
+}
+/**
    \brief rotates the vector by the given rotation
    \param v: a vector

orxonox/trunk/src/vector.h

-                      r2043
+                      r2190
 #define PI 3.14159265359f
 //! 3D vector
+//! 3D Vector
 /**
+  Class for 3-dimensional vector calculation
+  Supports all common vector operations (dot, cross, lenght and so on)
+        Class to handle 3D Vectors
 */
 class Vector {
 …
 float angle_rad (const Vector& v1, const Vector& v2);
+//! 3D rotation
+//! Quaternion
+/**
+        Class to handle 3-dimensional rotation efficiently
+*/
+class Quaternion
+{
+ public:
+        Vector v;       //!< Imaginary Vector
+        float w; //!< Real part of the number
+        Quaternion ();
+        Quaternion (float m[4][4]);
+        Quaternion (float angle, const Vector& axis);
+        Quaternion (const Vector& dir, const Vector& up);
+        Quaternion (float roll, float pitch, float yaw);
+        Quaternion operator/ (const float& f) const;
+        Quaternion operator* (const float& f) const;
+        Quaternion operator* (const Quaternion& q) const;
+        Quaternion operator+ (const Quaternion& q) const;
+        Quaternion operator- (const Quaternion& q) const;
+        Quaternion conjugate () const;
+        Quaternion inverse () const;
+        Vector apply (Vector& f) const;
+        float norm () const;
+        void matrix (float m[4][4]) const;
+};
+//! 3D rotation (OBSOLETE)
 /**
   Class to handle 3-dimensional rotations.
 …
   ~Rotation () {}
+  Rotation operator* (const Rotation& r);
+  void glmatrix (float* buffer);
 };

orxonox/trunk/src/world.cc

-                      r2077
+                      r2190
    ### File Specific:
    main-programmer: Patrick Boenzli
+   co-programmer:
+*/
+#include <iostream>
+#include <stdlib.h>
+#include <cmath>
+#include <GL/glut.h>
+#include "npc.h"
+   co-programmer: Christian Meyer
+*/
+#include "world.h"
+#include "world_entity.h"
+#include "collision.h"
+#include "track.h"
 #include "player.h"
+#include "environment.h"
+#include "shoot_laser.h"
+#include "shoot_rocket.h"
+#include "stdincl.h"
+#include "data_tank.h"
+#include "list.h"
+#include "world_entity.h"
+#include "world.h"
+#include "command_node.h"
+#include "camera.h"
 using namespace std;
 …
 /**
    \brief Create a new World
+   \brief create a new World
+   This creates a new, empty world!
+*/
+World::World () {
+  //lastPlayer = null;
+  //lastNPC = null;
+  //lastEnv = null;
+  primitiveMove = 0;
+  step = 0;
+  //List<int> *list = new List<int>();
+  npcList = new List<WorldEntity*>();
+  playerList = new List<WorldEntity*>();
+  envList = new List<WorldEntity*>();
+}
+World::~World () {}
+/**
+   \brief Load 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
+   Load a new world. The old world (if any) will be unloaded and becomes unrecoverable.
+*/
+void World::loadWorld() {}
+/**
+   \brief Unloads a new World
+   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
+   Unloads a world and frees the memory. You cant game until you have a new world loaded.
+*/
+void World::unloadWorld() {}
+/**
+   \brief Pause the game
+   Pauses the game until the pause is released. During this time nothing moves at all and nothing is calculated. Use it if you have to go out of the game to read some mails...
+*/
+void World::pauseWorld() {}
+/**
+   \brief Save the game to file
+   \param filename: the filename where the savegame should be saved to
+   Saves the state of the game to a file. The state is catched like in a multiplayer game over a synchronisable interface.
+*/
+void World::saveGameState(char* filename) {}
+/**
+   \brief Add Player
+   \param player A reference to the new player object
+   Add a new Player to the game. Player has to be initialised previously
+*/
+bool World::addPlayer(Player* player)
+{
+  WorldEntity *we;
+  playerList->add(we);
+  /*
+  playerList* listMember = new playerList;
+  listMember->player = player;
+  if ( lastPlayer != null )
+    {
+      listMember->number = lastPlayer->number + 1;
+      listMember->next = lastPlayer;
+    }
+  else
+    {
+      listMember->number = 0;
+      listMember->next = null;
+    }
+  lastPlayer = listMember;
+  */
+}
+/**
+   \brief Remove Player
+   \param player A reference to the new npc object
+   Remove a new Player to the game. This kills the player objects.
+*/
+bool World::removePlayer(Player* player) {
+  playerList->remove(player, LIST_FIND_BW);
+}
+/**
+   \brief Returns the player-entity controlled by the local gamer
+   \return pointer to player object
+   Remove a new Player to the game. This kills the player objects.
+*/
+Player* World::getLocalPlayer()
+{
+  return localPlayer;
+}
+/**
+   \brief Add Non-Player-Character
+   \param player A reference to the new npc object
+   Add a new Non-Player-Character to the game. Player has to be initialised previously
+*/
+bool World::addNPC(NPC* npc)
+{
+  npcList->add(npc, LIST_ADD_NEXT);
+  /*
+  npcList* listMember = new npcList;
+  listMember->npc = npc;
+  if ( lastNPC != null )
+    {
+      listMember->number = lastNPC->number + 1;
+      listMember->next = lastNPC;
+    }
+  else
+    {
+      listMember->number = 0;
+      listMember->next = null;
+    }
+  lastNPC = listMember;
+  */
+}
+/**
+   \brief Remove Non-Player Character
+   \param player A reference to the npc object
+   Remove a Non-Player-Character to the game.
+*/
+bool World::removeNPC(NPC* npc)
+{
+  npcList->remove(npc, LIST_FIND_FW);
+  /*
+  npcList* npcRef = lastNPC;
+  npcList* lastRef = lastNPC;
+  while ( npcRef != null )
+    {
+      if ( npcRef->npc == npc ) {
+        cout <
+< "found" << endl;
+        if ( npcRef == lastRef ) {
+          lastNPC = lastNPC->next;
+          delete npcRef;
+          npcRef = lastNPC;
+          lastRef = lastNPC;
+        }
+        else {
+          lastRef->next = npcRef->next;
+          delete npcRef;
+          npcRef = lastRef->next;
+        }
+        cout << "killed ..." << endl;
+      }
+      else {
+        lastRef = npcRef;
+        npcRef = npcRef->next;
+      }
+    }
+  cout << "npc left" << endl;
+  */
+}
+/**
+   \brief Add environmental object
+   \param player A reference to the new env object
+   Add a new Environment to the world. Env has to be initialised before.
+*/
+bool World::addEnv(Environment* env)
+{
+  /*
+  envList* listMember = new envList;
+  listMember->env = env;
+  if ( lastEnv != null )
+    {
+      listMember->number = lastEnv->number + 1;
+      listMember->next = lastEnv;
+    }
+  else
+    {
+      listMember->number = 0;
+      listMember->next = null;
+    }
+  lastEnv = listMember;
+  */
+}
+/**
+   \brief Remove an environmental object
+   \param player A reference to the env object
+   Remove a environment from the game.
+*/
+bool World::removeEnv(Environment* env)
+{
+   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;
+                        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);
+}
+/**
+   \brief Draws the World and all Objects contained
+   Calls the draw function of all: Objects, Players, Environement. This is the core of all graphics here.
+*/
+void World::drawWorld(void)
+{
+  glLoadIdentity();
+  gluLookAt(0.0, -14.0 + DataTank::yOffset, 15.0, 0.0, 0.0 + DataTank::yOffset, 0.0, 0.0, 1.0, 0.0);
+  /* first draw all players */
+  /*
+  playerList* tmpPlayer = lastPlayer;
+  Player* player = tmpPlayer->player;
+  while( tmpPlayer != null )
+    {
+      tmpPlayer->player->paint();
+      tmpPlayer = tmpPlayer->next;
+    }
+  */
+  /* second draw all npcs */
+  /*
+  npcList* tmpNPC = lastNPC;
+  while( tmpNPC != null )
+    {
+      (*tmpNPC->npc).paint();
+      tmpNPC = tmpNPC->next;
+    }
+  */
+  /* now draw the rest of the world: environement */
+  /*
+  envList* tmpEnv = lastEnv;
+  while( tmpEnv != null )
+    {
+      (*tmpEnv->env).drawEnvironment();
+      tmpEnv = tmpEnv->next;
+    }
+  */
+  /* draw the ground grid  */
+  glColor3f(0.0, 1.0, 0.0);
+  glBegin(GL_LINES);
+  /* for the moment, we've got only pseudo moving ground */
+  for (int y = 0; y < 60; y += 2)
+    {
+      for (int x = 0; x < 60; x += 2)
+        {
+          glVertex3f((float)(x - 30), (float)(y - 30), surface[x][y]);
+          glVertex3f((float)(x - 28), (float)(y - 30), surface[x+2][y]);
+        }
+    }
+  glEnd();
+  glBegin(GL_LINES);
+  for (int x = 0; x < 60; x += 2)
+    {
+      for (int y = 0; y < 60; y += 2)
+        {
+          glVertex3f((float)(x - 30), (float)(y - 30), surface[x][y]);
+          glVertex3f((float)(x - 30), (float)(y - 28), surface[x][y+2]);
+        }
+    }
+  glEnd();
+  //primitiveMove+=0.07;
+  DataTank::yOffset += step;
+  /*
+  tmpPlayer = lastPlayer;
+  while( tmpPlayer != null )
+    {
+      tmpPlayer->player->yCor += step;
+      tmpPlayer = tmpPlayer->next;
+    }
+  */
+}
+void World::initEnvironement()
+{
+ for (int x = 0; x < 60; x += 2)
+    {
+      for (int y = 0; y < 60; y += 2)
+        {
+          surface[x][y] = 0;
+        }
+    }
+}
+void World::setWorldStep(float step)
+{
+  //cout << "World::setWorldStep(" << step << ");" << endl;
+  this->step = step;
+  //cout << "setting speed to " << step << endl;
+}
+/**
+   \brief Updates the world and all its objects
+   Calculates the new state of the world. User-input and AI of
+   the enemies are accounted for.
+*/
+void World::updateWorld(void)
+{
+}
+/* collision detection */
+/* fix: bad efficency: stupid brute force */
+void World::detectCollision()
+{
+  /*
+  //cout << "World::detectCollision" << endl;
+  float xOff, yOff, zOff, radius;
+  npcList* tmpNPC, *tmpRef;
+  */
+  //cout << "World::detectCollsions" << endl;
+  /* first: check if any player's shoots trigger a collision */
+  /*
+  playerList* tmpPlayer = lastPlayer;
+  Player* player = tmpPlayer->player;
+  int state;
+  while( tmpPlayer != null )
+    {
+      tmpNPC = lastNPC;
+      while( tmpNPC != null )
+        {
+          //cout << "npc != null" << endl;
+          radius = tmpNPC->npc->collisionRadius;
+          //cout << "worki" << endl;
+          ShootLaser::shoot* shoota = tmpPlayer->player->shootLaser->lastShoot;
+          while( shoota != null )
+            {
+              xOff = shoota->xCor - tmpNPC->npc->xCor;
+              yOff = shoota->yCor - tmpNPC->npc->yCor;
+              zOff = shoota->zCor - tmpNPC->npc->zCor;
+              if ( sqrt(xOff*xOff + yOff*yOff + zOff*zOff) < radius )
+                {
+                  //cout << "COLLISION " << endl;
+                  int state = tmpNPC->npc->hit();
+  */
+                  /* state is a value that marks if the ship dies or not */
+                  /* if state == 0 the ship dies and we have to remove it */
+                  /*
+                  if ( state == 0 ) {
+                    tmpRef = tmpNPC;
+                    tmpNPC = tmpNPC->next;
+                    removeNPC(tmpRef->npc);
+                    break;
+                  }
+                }
+              shoota = shoota->next;
+            }
+          //cout << "changing npc..." << endl;
+          tmpNPC = tmpNPC->next;
+          //cout << "..changing npc done" << endl;
+        }
+      //cout << "changing play..." << endl;
+      tmpPlayer = tmpPlayer->next;
+      //cout << "changing play done" << endl;
+    }
+                  */
+  //cout << "World::detectCollisions middle" << endl;
+  /* second: check if any player hits an enemy */
+/*
+  tmpPlayer = lastPlayer;
+  while( tmpPlayer != null )
+    {
+      tmpNPC = lastNPC;
+      while( tmpNPC != null )
+        {
+          radius = tmpNPC->npc->collisionRadius + tmpPlayer->player->collisionRadius;
+          xOff = tmpPlayer->player->xCor - tmpNPC->npc->xCor;
+          yOff = tmpPlayer->player->yCor - tmpNPC->npc->yCor;
+          zOff = tmpPlayer->player->zCor - tmpNPC->npc->zCor;
+          if ( sqrt(xOff*xOff + yOff*yOff + zOff*zOff) < radius ) {
+            //cout << "COLLISION " << endl;
+            tmpNPC->npc->hit();
+          }
+          tmpNPC = tmpNPC->next;
+        }
+      tmpPlayer = tmpPlayer->next;
+    }
+*/
+  /* third: check if any enemy shoots a player */
+  //cout << "World::detectCollisions end" << endl;
+}
+/**
+   \brief Routine for testing purposes.
+   testing, testing, testing...
+*/
+void World::testThaTest(void)
+{
+/*
+  cout << "World::testThaTest() called" << endl;
+  cout << "addPlayer test..." << endl;
+  playerList* pl = lastPlayer;
+  while ( pl != null )
+    {
+      cout << "player " << pl->number << " was found" << endl;
+      pl = pl->next;
+    }
+  cout << "addNPC test..." << endl;
+  npcList* nl = lastNPC;
+  while ( nl != null )
+    {
+      cout << "npc " << nl->number << " was found" << endl;
+      nl = nl->next;
+    }
+  cout << "addEnv test..." << endl;
+  envList* en = lastEnv;
+  while ( en != null )
+    {
+      cout << "env " << en->number << " was found" << endl;
+      en = en->next;
+    }
+*/
+}
+        // 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);
+}

orxonox/trunk/src/world.h

-                      r2077
+                      r2190
+/**
+  Class representating the game-world
+  It contains a list of players (if multiplayer game), a list of Non-Player-Characters (nps), a list of Environment Entities. All this things together are building the orxonox-world. This class also handels the story-line (track), the world start/stop, init/uninit abilities. It is the middle point of every orxonox world.
+*/
+/*!
+    \file world.h
+    \brief Holds and manages all game data
+*/
 #ifndef WORLD_H
 #define WORLD_H
+class Player;
+class NPC;
 class Environment;
+#include "stdincl.h"
+class Track;
 class WorldEntity;
+template<class T> class List;
+//! World Class
+/**
+  Class for World representation
+  It contains a list of players (if multiplayer game), a list of Non-Player-Characters (nps), a list of Environment Entities. All this things together are building the orxonox-world. This class also handels the story-line (track), the world start/stop, init/uninit abilities. It is the middle point of every orxonox world.
+*/
+//! The game environment
 class World {
 …
   ~World ();
+        template<typename T>
+          T* spawn(Location* loc, WorldEntity* owner);  // template to be able to spawn any derivation of WorldEntity
+        template<typename T>
+          T* spawn(Placement* plc, WorldEntity* owner);
+  float primitiveMove; //!< deprecated, do not use
+  Player *localPlayer; //!< a pointer to the local player object
+  Player *player1;     //!< a pointer to the second player object
+  Player *player2;     //!< a pointer to the third player object
+  /*
+  struct playerList {
+    playerList* next;
+    Player* player;
+    int number;
+  };
+  playerList* lastPlayer;
+  struct npcList {
+    npcList* next;
+    NPC* npc;
+    int number;
+  };
+  npcList* lastNPC;
+  struct envList {
+    envList* next;
+    Environment* env;
+    int number;
+  };
+  envList* lastEnv;
+  */
+  void loadWorld();
+  void unloadWorld();
+  void pauseWorld();
+  void saveGameState(char* filename);
+  bool addPlayer(Player* player);
+  bool removePlayer(Player* player);
+  Player* getLocalPlayer();
+  bool addNPC(NPC* npc);
+  bool removeNPC(NPC* npc);
+  bool addEnv(Environment* env);
+  bool removeEnv(Environment* env);
+  void drawWorld(void);
+  void initEnvironement(void);
+  void setWorldStep(float step);
+  void updateWorld(void);
+  void detectCollision(void);
+  void testThaTest(void);
+        void time_slice (Uint32 deltaT);
+        void collide ();
+        void draw ();
+        void update (); // maps Locations to Placements
+        void calc_camera_pos (Location* loc, Placement* plc);
+        void unload ();
+        void load_debug_level ();
  private:
   float surface[120][120]; //!< deprecated: used to build a surface
+  float step; //!< this is the step
+  List<WorldEntity*> *playerList; //!< the list of players, usualy very short
+  List<WorldEntity*> *npcList;  //!< list of non player characters (npc)
+  List<WorldEntity*> *envList;  //!< list of environment objects
+        List<WorldEntity>* entities;
+                // base level data
+        Track* track;
+        Uint32 tracklen;
+        Vector* pathnodes;
 };
+/**
+    \brief spawn a new WorldEntity at a Location
+    \param loc: the Location where the Entity should be spawned
+    \param owner: a pointer to the parent of the Entity
+    \return a pointer to the new WorldEntity or NULL if there was an error
+    You can use this function to spawn any derivation of WorldEntity you want, just specify the desired
+    class within the template specification brackets. Do not attempt to spawn any classes that have NOT been
+    derived from WorldEntity, you won't even be able to compile the code. Note that this version of spawn()
+    works with both free and bound WorldEntities.
+*/
+template<typename T> T* World::spawn(Location* loc = NULL, WorldEntity* owner = NULL)
+{
+        Location zeroloc;
+        T* entity = new T();
+        entities->add ((WorldEntity*)entity, LIST_ADD_NEXT);
+        if( loc == NULL)
+        {
+                zeroloc.dist = 0;
+                zeroloc.part = 0;
+                zeroloc.pos = Vector();
+                zeroloc.rot = Quaternion();
+                loc = &zeroloc;
+        }
+        entity->init (loc, owner);
+        if (entity->bFree)
+        {
+                track[loc->part].map_coords( loc, entity->get_placement());
+        }
+        entity->post_spawn ();
+        return entity;
+}
+/**
+    \brief spawn a new WorldEntity at a Placement
+    \param lplc: the placement where the Entity should be spawned
+    \param owner: a pointer to the parent of the Entity
+    \return a pointer to the new WorldEntity or NULL if there was an error
+    You can use this function to spawn any FREE derivation of WorldEntity you want, just specify the desired
+    class within the template specification brackets. Do not attempt to spawn any classes that have NOT been
+    derived from WorldEntity, you won't even be able to compile the code. Note that this version of spawn()
+    works with free WorldEntities only, you will provoke an error message if you try to spawn a bound Entity with
+    a Placement.
+*/
+template<typename T> T* World::spawn(Placement* plc, WorldEntity* owner = NULL)
+{
+        T* entity = new T();
+        entities->add ((WorldEntity*)entity, LIST_ADD_NEXT);
+        entity->init (plc, owner);
+        if (!entity->bFree)
+        {
+                printf("Can't spawn unfree entity with placement\n");
+                entities->remove( (WorldEntity*)entity, LIST_FIND_FW);
+                return NULL;
+        }
+        entity->post_spawn ();
+        return entity;
+}
 #endif

orxonox/trunk/src/world_entity.cc

-                      r2077
+                      r2190
    ### File Specific:
    main-programmer: Patrick Boenzli
    co-programmer: ...
+   co-programmer: Christian Meyer
 */
 …
 #include "world_entity.h"
 #include "vector.h"
+#include "stdincl.h"
+#include "collision.h"
 using namespace std;
 /**
+   \brief
+   \param v:
+   \return
+   \brief standard constructor
+   Every derived contructor HAS to call the previous one supplying the isFree parameter. This is necessary to distunguish
+   between free and bound entities. The difference between them is simply the fact that the movement of a free entity is
+   not bound to the track of a world. Use this to implement projectile or effect classes that do not have to travel along the track.
+   To specify an entity to be free or bound set the default parameter in the declaration of the constructor.
+   Theoretically you should never have to call the constructor of an Entity directly, for it is called by the spawn() function of the World
+   class. So if you want to create a new entity at any time, call World::spawn(). It will handle everything that is necessary.
 */
+/**
+   \brief Constructor
+   This Constructor initializises the all WorldEntities. Everything, that is a part of the game-world is a child of WorldEntity. This class implements empty functions for all sort of operation a WorldEntity has to or can implement.
+This is some sort of standard interface to all WorldEntities...
+*/
+WorldEntity::WorldEntity ()
+WorldEntity::WorldEntity (bool isFree) : bFree(isFree)
+{
+  health = 100;
+  speed = 0;
+}
+WorldEntity::~WorldEntity () {}
+/**
+   \brief sets the position of this entity
+   \param position: Vector, pointing (from 0,0,0) to the new position
+*/
+void WorldEntity::setPosition(Vector* position) {}
+/**
+   \brief gets the postion of this entity
+   \return a Vector, pointing (from 0,0,0) to the new position
+*/
+Vector* getPosition() {}
+/**
+   \brief sets orientation of this entity
+   \param orientation: vector specifying in which direction the entity looks
+*/
+void WorldEntity::setOrientation(Vector* orientation) {}
+/**
+   \brief gets orientation of this entity
+   \return vector specifying in which direction the entity looks
+*/
+Vector* WorldEntity::getOrientation() {}
+/**
+   \brief sets the speed of the entity, if any
+   \param speed: the speed in points (openGL points) per seconds
+*/
+void WorldEntity::setSpeed(float speed)
+{
+  this->speed = speed;
+        collisioncluster = NULL;
+        owner = NULL;
+}
 /**
+   \brief gets the speed of the entity, if any
+   \return the speed in points (openGL points) per seconds
+        \brief standard destructor
 */
 float WorldEntity::getSpeed()
+WorldEntity::~WorldEntity ()
+{
   return speed;
+        if( collisioncluster != NULL) delete collisioncluster;
+}
 /**
    \brief sets the health of the entity
+   \param health: number for the life count, normaly {0..100}
+        \brief get the Location of the WorldEntity
+        \return a pointer to location
 */
 void WorldEntity::setHealth(float health)
+Location* WorldEntity::get_location ()
+{
   this->health = health;
+        return &loc;
+}
 /**
    \brief gets the health of the entity
+   \return number for the life count, normaly {0..100}
+        \brief get the Placement of the WorldEntity
+        \return a pointer to placement
 */
 float WorldEntity::getHealth()
+Placement* WorldEntity::get_placement ()
+{
   return health;
+        return &place;
+}
 /**
+   \brief this method is called every tick
+   \param time: the time since the last frame was painted
+   This function is called before every repaint of the world, to update every time dependent variable of the entity. If the entity moves, it has to calculate the new position every tick here in this function. Do not use this for animations.
+        \brief query whether the WorldEntity in question is free
+        \return true if the WorldEntity is free or false if it isn't
 */
+void WorldEntity::tick(float dt)
+{}
+bool WorldEntity::isFree ()
+{
+  return bFree;
+}
 /**
+   \brief the entity is painted to the screen with this function
+        \brief set the WorldEntity's collision hull
+        \param newhull: a pointer to a completely assembled CollisionCluster
+        Any previously assigned collision hull will be deleted on reassignment
+*/
+void WorldEntity::set_collision (CollisionCluster* newhull)
+{
+        if( newhull == NULL) return;
+        if( collisioncluster != NULL) delete collisioncluster;
+        collisioncluster = newhull;
+}
+/**
+        \brief this method is called every frame
+        \param time: the time in seconds that has passed since the last tick
+        Handle all stuff that should update with time inside this method (movement, animation, etc.)
+*/
+void WorldEntity::tick(float time)
+{
+}
+/**
+   \brief the entity is drawn onto the screen with this function
    This is a central function of an entity: call it to let the entity painted to the screen. Just override this function with whatever you want to be drawn.
 */
+void WorldEntity::paint()
+{}
+void WorldEntity::draw()
+{
+}
-/* virtual void WorldEntity::actionEvent(Event* event); */
 /**
+   \brief this function is called, when two entities collide
+   \param we: the world entity, with whom it collides
+   \param loc: place where the collision happens
+        \brief this function is called, when two entities collide
+        \param other: the world entity with whom it collides
+        \param ownhitflags: flags to the CollisionCluster subsections that registered an impact
+        \param otherhitflags: flags to the CollisionCluster subsections of the other entity that registered an impact
+        Implement behaviour like damage application or other miscellaneous collision stuff in this function
 */
 void WorldEntity::collide(WorldEntity* we, Vector loc) {}
+void WorldEntity::collide(WorldEntity* other, Uint32 ownhitflags, Uint32 otherhitflags) {}
 /**
 …
 /**
    \brief this function is called, if the entity is to be destroied
+   \brief this function is called when the entity is to be destroied
    This can be called, if eg. something realy bad happens :)
 …
 void WorldEntity::destroy() {}
-/**
-   \brief this function is automatically called before the entity enters the world
-*/
-void WorldEntity::entityPreEnter() {}
 /**
+   \brief this function is automatically called after the entity enters the world
+        \brief basic initialisation for bound Entities
 */
+void WorldEntity::entityPostEnter() {}
+void WorldEntity::init( Location* spawnloc, WorldEntity* spawnowner)
+{
+        loc = *spawnloc;
+        owner = spawnowner;
+}
 /**
+   \brief this function is automatically called before the entity quits the world
+        \brief basic initialisation for free Entities
 */
+void WorldEntity::entityPreQuit() {}
+void WorldEntity::init( Placement* spawnplc, WorldEntity* spawnowner)
+{
+        place = *spawnplc;
+        owner = spawnowner;
+}
 /**
+   \brief this function is automatically called after the entity quits the world
+        \brief this is called immediately after the Entity has been constructed and initialized
+        Put any initialisation code that requires knowledge of location (placement if the Entity is free) and owner of the entity here.
+        DO NOT place such code in the constructor, those variables are set AFTER the entity is constucted.
 */
+void WorldEntity::entityPostQuit() {}
+void WorldEntity::post_spawn ()
+{
+}
+/**
+        \brief this handles incoming command messages
+        \param cmd: a pointer to the incoming Command structure
+        Put all code that handles Command messages here, this will mainly be called by the assigned CommandNode but can also be used
+        to send commands from one WorldEntity to another.
+*/
+void WorldEntity::command (Command* cmd)
+{
+}
+/**
+        \brief this is called by the local Camera to determine the point it should look at on the WorldEntity
+        \param locbuf: a pointer to the buffer to fill with a location to look at
+        You may put any Location you want into locbuf, the Camera will determine via the corresponding Track how
+        to look at the location you return with this.
+*/
+void WorldEntity::get_lookat (Location* locbuf)
+{
+}
+/**
+        \brief this method is called by the world if the WorldEntity leaves valid gamespace
+        For free entities this means it left the Track boundaries. With bound entities it means its Location adresses a
+        place that is not in the world anymore. In both cases you might have to take extreme measures (a.k.a. call destroy).
+*/
+void WorldEntity::left_world ()
+{
+}

orxonox/trunk/src/world_entity.h

-                      r2077
+                      r2190
 /*!
     \file world_entity.h
+    \brief A base class for all objects in the world
+    This is the base class of all objects in the game-world. If you want to have an object in the world, that can realy interact with other objects and that is also dispbayable etc. you have to extend this class and override the needed functions.
+*/
+    \brief Definition of the basic WorldEntity
+*/
 #ifndef WORLD_ENTITY_H
 #define WORLD_ENTITY_H
 #include "data_tank.h"
+#include "stdincl.h"
+class Vector;
+class Ability;
+class CollisionCluster;
+//! WorldEntity
+/**
+  A base class for all objects in the world
+  This is the base class of all objects in the game-world. If you want to have an object in the world, that can realy interact with other objects and that is also dispbayable etc. you have to extend this class and override the needed functions.
+*/
+class WorldEntity {
+//! Basic class from which all interactive stuff in the world is derived from
+class WorldEntity
+{
+        friend class World;
  public:
   WorldEntity ();
+  WorldEntity (bool isFree = false);
   ~WorldEntity ();
+        Location* get_location ();
+        Placement* get_placement ();
+        void set_collision (CollisionCluster* newhull);
+  void setPosition(Vector* position);
+  Vector* getPosition();
+  void setOrientation(Vector* orientation);
+  Vector* getOrientation();
+  void setSpawnPoint(Vector* place);
+  void setSpeed(float speed);
+  float getSpeed();
+  void setHealth(float health);
+  float getHealth();
+        bool isFree ();
+  //void addAbility(Ability* ability);
+  //void removeAbility(Ability* ability);
+  void addAbility(Ability* ability);
+  void removeAbility(Ability* ability);
+        virtual void post_spawn ();
+  virtual void tick (float time);
+  virtual void hit (WorldEntity* weapon, Vector loc);
+  virtual void destroy ();
+  virtual void collide (WorldEntity* other,  Uint32 ownhitflags, Uint32 otherhitflags);
+        virtual void command (Command* cmd);
+  virtual void draw ();
+  virtual void get_lookat (Location* locbuf);
+  virtual void tick(float dt);
+  virtual void paint();
+  /* virtual void actionEvent(Event* event); */
+  virtual void collide(WorldEntity* we, Vector loc);
+  virtual void hit(WorldEntity* weapon, Vector loc);
+  virtual void destroy();
+  virtual void entityPreEnter();
+  virtual void entityPostEnter();
+  virtual void entityPreQuit();
+  virtual void entityPostQuit();
+        virtual void left_world ();
  private:
+  Vector* position;    //!< position of the entity
+  Vector* orientation; //!< orientation of the entity
+  /* List of abilities */
+  float health; //!< health of the entity, if any
+  float speed; //!< speed of the entity if any
+  /* entity can be in the air or at ground: */
+  int airGround; //!< is it air or bound to the ground (ground=0, air=1)
+  const bool bFree;
+  bool bCollide;
+  bool bDraw;
+        WorldEntity* owner;
+        CollisionCluster* collisioncluster;
+        Placement place;
+        Location loc;
+        void init( Location* spawnloc, WorldEntity* spawnowner);
+        void init( Placement* spawnplc, WorldEntity* spawnowner);
 };

Context Navigation

Changeset 2190 in orxonox.OLD for orxonox/trunk/src

Legend:

orxonox/trunk/src/Makefile.am

orxonox/trunk/src/Makefile.in

orxonox/trunk/src/data_tank.cc

orxonox/trunk/src/data_tank.h

orxonox/trunk/src/orxonox.cc

orxonox/trunk/src/orxonox.h

orxonox/trunk/src/player.cc

orxonox/trunk/src/player.h

orxonox/trunk/src/stdincl.h

orxonox/trunk/src/vector.cc

orxonox/trunk/src/vector.h

orxonox/trunk/src/world.cc

orxonox/trunk/src/world.h

orxonox/trunk/src/world_entity.cc

orxonox/trunk/src/world_entity.h

Download in other formats: