Changeset 9656 – Orxonox

trunk/src/defs/class_id.h

-                      r9406
+                      r9656
   CL_GROUND_TURRET              =    0x000003e5,
   CL_SPACE_TURRET               =    0x000003e6,
+  CL_GUIDED_MISSILE             =    0x000003e7,
+  CL_HYPERBLAST                 =    0x000003e8,
+  CL_BOOMERANG_PROJECTILE       =    0x00000309,
+  CL_NETWORK_TURRET             =    0x000003e7,
+  CL_GUIDED_MISSILE             =    0x000003e8,
+  CL_HYPERBLAST                 =    0x000003e9,
+  CL_BOOMERANG_PROJECTILE       =    0x0000030a,
   // NPC's
 …
   CL_SIMPLE_SYNC                =    0x00000d0a,
   CL_NETWORK_MONITOR            =    0x00000d0b,
+  CL_PROXY_CONTROL              =    0x00000d0c,

trunk/src/lib/BuildLibs.am

-                      r8368
+                      r9656
                 $(LIB_PREFIX)/util/libORXlibutil.a \
                 $(LIB_PREFIX)/shell/libORXshell.a \
+                $(LIB_PREFIX)/event/libORXevent.a \
                 $(LIB_PREFIX)/gui/qt/libORXqtgui.a \
                 $(LIB_PREFIX)/gui/gl/libORXglgui.a \
 …
                 $(LIB_PREFIX)/graphics/importer/libtc.a \
                 $(LIB_PREFIX)/sound/libORXsound.a \
-                $(LIB_PREFIX)/event/libORXevent.a \
                 $(LIB_PREFIX)/particles/libORXparticles.a \
                 $(LIB_PREFIX)/collision_detection/libORXcd.a \
 …
                 $(LIB_PREFIX)/parser/ini_parser/libIniParser.a \
                 $(LIB_PREFIX)/physics/libORXphysics.a \
+                $(LIB_PREFIX)/gui/gl/libORXglgui.a \
                 $(LIB_PREFIX)/shell/libORXshell.a \
                 $(LIB_PREFIX)/math/libORXmath.a \

trunk/src/lib/coord/p_node.cc

-                      r9406
+                      r9656
     parent->addChild(this);
   this->relCoordinate_handle = this->registerVarId( new SynchronizeableVector( &relCoordinate, &relCoordinate_write, "coordinate" ) );
   this->relDirection_handle = this->registerVarId( new SynchronizeableQuaternion( &relDirection, &relDirection_write, "direction" ) );
+  this->relCoordinate_handle = this->registerVarId( new SynchronizeableVector( &relCoordinate, &relCoordinate_write, "coordinate", PERMISSION_SERVER ) );
+  this->relDirection_handle = this->registerVarId( new SynchronizeableQuaternion( &relDirection, &relDirection_write, "direction", PERMISSION_SERVER ) );
+}
 …
 void PNode::addChild (PNode* child)
+{
+  if (unlikely(child->parent == this))
+    return;
   if( likely(child->parent != NULL))
     child->parent->eraseChild(child);
 …
+{
   const PNode* parent = this;
+  if (this == NULL)
+    return true;
   while ( (parent = parent->getParent()) != NULL)
     if (unlikely(parent == checkParent))

trunk/src/lib/event/event_handler.cc

r9406	r9656
25	25	#include "compiler.h"
26	26	#include "debug.h"
27		~~#include "class_list.h"~~
28	27
29	28	#include <algorithm>

trunk/src/lib/gui/gl/Makefile.am

-                      r9406
+                      r9656
+                \
                 glgui_handler.cc \
+                glgui_widget.cc \
                 glgui_mainwidget.cc \
-                glgui_widget.cc \
                 glgui_button.cc \
                 glgui_pushbutton.cc \
 …
                 glgui_bar.cc \
                 glgui_box.cc \
+                glgui_fixedposition_box.cc \
                 glgui_frame.cc \
                 glgui_text.cc \
 …
                 glgui_defs.h \
                 glgui_handler.h \
+                glgui_widget.h \
                 glgui_mainwidget.h \
-                glgui_widget.h \
                 glgui_button.h \
                 glgui_pushbutton.h \
 …
                 glgui_bar.h \
                 glgui_box.h \
+                glgui_fixedposition_box.h \
                 glgui_frame.h \
                 glgui_text.h \

trunk/src/lib/gui/gl/glgui.h

r9015	r9656
14	14	#include "glgui_bar.h"
15	15	#include "glgui_box.h"
	16	#include "glgui_fixedposition_box.h"
16	17	#include "glgui_button.h"
17	18	#include "glgui_checkbutton.h"

trunk/src/lib/gui/gl/glgui_box.cc

-                      r9110
+                      r9656
 #include "glgui_box.h"
 #include <cassert>
+#include "debug.h"
 namespace OrxGui
 …
   */
   GLGuiBox::~GLGuiBox()
+  {}
+  {
+    // unpack all the widgets.
+    while(!this->_children.empty())
+    {
+      /// not deleting children here.
+      this->_children.front()->setParentWidget(NULL);
+      this->_children.pop_front();
+    }
+  }
   /**
 …
+  {
     assert (widget != NULL);
+    this->children.push_back(widget);
+    this->_children.push_back(widget);
+    this->packing(widget);
+  }
+  void GLGuiBox::pack(GLGuiWidget* widget, std::list<GLGuiWidget*>::iterator pos)
+  {
+    this->_children.insert(pos, widget);
+    this->packing(widget);
+  }
+  void GLGuiBox::pack(GLGuiWidget* widget, unsigned int position)
+  {
+    if (this->_children.empty())
+      this->pack(widget);
+    unsigned int pos = 0;
+    std::list<GLGuiWidget*>::iterator it = this->_children.begin();
+    for (; pos < position; ++pos)
+    {
+      if (this->_children.end() == ++it)
+      {
+        PRINTF(2)("Reached end of packing list, without getting to the designated position %d (i am at %d)\n", position, pos);
+        this->pack(widget);
+      }
+    }
+    this->_children.insert(it, widget);
+    this->packing(widget);
+  }
+  void GLGuiBox::pack(GLGuiWidget* widget, const GLGuiWidget* widgetPointer)
+  {
+    assert (widget != NULL && widgetPointer != NULL);
+    std::list<GLGuiWidget*>::iterator it = this->_children.begin();
+    for (; it != this->_children.end(); ++it)
+    {
+      if (widgetPointer == *it)
+      {
+        this->_children.insert(it, widget);
+        this->packing(widget);
+        return;
+      }
+    }
+    PRINTF(2)("WidgetPointer %p not found, inserting at the end\n", widgetPointer);
+    this->pack(widget);
+  }
+  void GLGuiBox::packFront(GLGuiWidget* widget)
+  {
+    this->_children.push_front(widget);
+    this->packing(widget);
+  }
+  void GLGuiBox::packBack(GLGuiWidget* widget)
+  {
+    this->pack(widget);
+  }
+  void GLGuiBox::packing(GLGuiWidget* widget)
+  {
     widget->setParentWidget(this);
     this->resize();
+  }
   void GLGuiBox::unpack(GLGuiWidget* widget)
+  {
     assert(widget != NULL);
     std::vector<GLGuiWidget*>::iterator delWidget = std::find(this->children.begin(), this->children.end(), widget);
     if (delWidget != this->children.end())
+    std::list<GLGuiWidget*>::iterator delWidget = std::find(this->_children.begin(), this->_children.end(), widget);
+    if (delWidget != this->_children.end())
+    {
       (*delWidget)->setParentWidget(NULL);
       this->children.erase(delWidget);
+      this->_children.erase(delWidget);
+    }
     this->resize();
 …
   void GLGuiBox::clear()
+  {
     this->children.clear();
+    this->_children.clear();
     this->resize();
+  }
 …
   void GLGuiBox::showAll()
+  {
     std::vector<GLGuiWidget*>::iterator itC = this->children.begin();
     while (itC != this->children.end())
+    std::list<GLGuiWidget*>::iterator itC = this->_children.begin();
+    while (itC != this->_children.end())
+    {
       if ((*itC)->isA(CL_GLGUI_CONTAINER))
 …
   void GLGuiBox::hideAll()
+  {
     std::vector<GLGuiWidget*>::iterator itC = this->children.begin();
     while (itC != this->children.end())
+    std::list<GLGuiWidget*>::iterator itC = this->_children.begin();
+    while (itC != this->_children.end())
+    {
       if ((*itC)->isA(CL_GLGUI_CONTAINER))
 …
       float height = borderTop();
       float width = 0.0f;
       std::vector<GLGuiWidget*>::iterator widget;
+      std::list<GLGuiWidget*>::iterator widget;
       // find out how big the Widgets are.
       for (widget = this->children.begin(); widget != this->children.end(); ++widget)
+      for (widget = this->_children.begin(); widget != this->_children.end(); ++widget)
+      {
         (*widget)->setRelCoor2D(borderLeft(), height);
 …
       float height = borderTop();
       float width = borderLeft();
       std::vector<GLGuiWidget*>::iterator widget;
+      std::list<GLGuiWidget*>::iterator widget;
       // find out how big the Widgets are.
       for (widget = this->children.begin(); widget != this->children.end(); ++widget)
+      for (widget = this->_children.begin(); widget != this->_children.end(); ++widget)
+      {
         (*widget)->setRelCoor2D(width, borderTop());
 …
     // resize everything.
     //for (widget = this->children.begin(); widget != this->children.end(); ++widget)
+    //for (widget = this->_children.begin(); widget != this->_children.end(); ++widget)
     //{}
+  }

trunk/src/lib/gui/gl/glgui_box.h

-                      r8145
+                      r9656
 /*!
  * @file glgui_.h
+ * @file glgui_box.h
  * The gl_box widget of th openglGUI
+ *
 …
     virtual void pack(GLGuiWidget* widget);
+    void pack(GLGuiWidget* widget, unsigned int position);
+    void pack(GLGuiWidget* widget, const GLGuiWidget* widgetPointer);
+    void packFront(GLGuiWidget* widget);
+    void packBack(GLGuiWidget* widget);
     virtual void unpack(GLGuiWidget* widget);
     virtual void clear();
 …
   private:
     void init();
+    void packing(GLGuiWidget* widget); // the action executing when packing a widget.
+    void pack(GLGuiWidget* widget, std::list<GLGuiWidget*>::iterator pos);
+  private:
     Orientation                _orientation;
     std::vector<GLGuiWidget*>  children;
+    std::list<GLGuiWidget*>    _children;
   };
+}

trunk/src/lib/gui/gl/glgui_container.cc

-                      r8619
+                      r9656
+  void GLGuiContainer::removeChildWidget(GLGuiWidget* widget)
+  {
+    this->unpack(widget);
+  }
   /**
    * draws the GLGuiContainer

trunk/src/lib/gui/gl/glgui_container.h

-                      r8145
+                      r9656
     virtual void draw();
+  protected:
+    virtual void removeChildWidget(GLGuiWidget* widget);
   private:
     void init();

trunk/src/lib/gui/gl/glgui_defs.h

-                      r8619
+                      r9656
   //! Names of Orientations
+  const std::string OrientationString[] = {
+    "Horizontal",
+    "Vertical"
+  };
+  const std::string OrientationString[] =
+    {
+      "Horizontal",
+      "Vertical"
+    };
+  //! An enumeration for the Positions of some Elements (FixedPositionBox as an example).
+  typedef enum {
+    Left,               //!< Left
+    Right,              //!< Right
+    Top,                //!< Top
+    Bottom,             //!< Bottom
+    TopLeft,            //!< TopLeft
+    TopRight,           //!< TopRight
+    BottomLeft,         //!< BottomLeft
+    BottomRight,        //!< BottomRight
+    Center,             //!< Centered
+  } Position;
+  //! Names of Positions
+  const std::string PositionString[] =
+    {
+      "Left",
+      "Right",
+      "Top",
+      "Bottom",
+      "TopLeft",
+      "TopRight",
+      "BottomLeft",
+      "BottomRight",
+      "Center"
+    };
   //! An enumerator that defines the different states Widgets may be in.
 …
 #define GLGUI_DEFAULT_STYLE OrxGui::Normal
 //! names of the States.
+  //! names of the States.
   const std::string StateString[] =
+    {
 …
     };
     //! Where a Certain feature will be positioned at.
     typedef enum {
       FeatureLeft,          //!< On the Left side.
       FeatureRight,         //!< On the Right side.
       FeatureTop,           //!< On Top of the rest of the Widget.
       FeatureBottom,        //!< At the Bottom of the rest of the Widget.
     } FeaturePosition;
+  //! Where a Certain feature will be positioned at.
+  typedef enum {
+    FeatureLeft,          //!< On the Left side.
+    FeatureRight,         //!< On the Right side.
+    FeatureTop,           //!< On Top of the rest of the Widget.
+    FeatureBottom,        //!< At the Bottom of the rest of the Widget.
+  } FeaturePosition;
     //! Names of Feature-Positions
     const std::string FeaturePositionString[] =
+  //! Names of Feature-Positions
+  const std::string FeaturePositionString[] =
+    {
       "Left",

trunk/src/lib/gui/gl/glgui_handler.cc

-                      r9240
+                      r9656
 #include "debug.h"
-#include <cassert>
 /// TAKE THIS OUT OF HERE.
 …
     this->setName("GLGuiHandler");
+    this->_resolution = Vector2D(GraphicsEngine::getInstance()->getResolutionX(), GraphicsEngine::getInstance()->getResolutionY());
     EventHandler::getInstance()->withUNICODE(ES_MENU, true );
 …
     for (unsigned int i = 0; i < EV_NUMBER; i++)
+    {
+      this->subscribeEvent(ES_ALL, i);
+      this->subscribeEvent(ES_GAME, i);
+      this->subscribeEvent(ES_GAME_MENU, i);
+      this->subscribeEvent(ES_MENU, i);
+    }
+  }
 …
       this->_cursor = NULL;
+    }
+  }
+  const Vector2D& GLGuiHandler::resolution()
+  {
+    if (this->_resolution == Vector2D::nullVector())
+      this->_resolution = Vector2D(GraphicsEngine::getInstance()->getResolutionX(), GraphicsEngine::getInstance()->getResolutionY());
+    return _resolution;
+  }
 …
         if (this->_cursor != NULL)
           this->_cursor->setMaxBorders(Vector2D(event.resize.w, event.resize.h));
+        break;
+        this->_resolution = Vector2D(event.resize.w, event.resize.h);
+        break;
       case SDLK_TAB:
         if (event.bPressed)

trunk/src/lib/gui/gl/glgui_handler.h

-                      r9240
+                      r9656
 namespace OrxGui
+{
+ // FORWARD DECLARATION
   class GLGuiCursor;
-  // FORWARD DECLARATION
   //! A singleton class for the GLGui-Handler
 …
   public:
-    virtual ~GLGuiHandler(void);
     /** @returns a Pointer to the only object of this Class */
     inline static GLGuiHandler* getInstance(void) { if (!GLGuiHandler::singletonRef) GLGuiHandler::singletonRef = new GLGuiHandler();  return GLGuiHandler::singletonRef; };
+    /** @brief deletes the instance if it exists */
+    inline static void deleteInstance() { if (GLGuiHandler::singletonRef) delete GLGuiHandler::singletonRef; };
     void activateCursor();
 …
     const Vector2D& cursorPositionAbs() const;
     Vector2D cursorPositionRel(const GLGuiWidget* const widget) const;
+    const Vector2D& resolution();
     void selectNext();
 …
   private:
     GLGuiHandler(void);
+    virtual ~GLGuiHandler(void);
     static GLGuiHandler* singletonRef;
 …
     bool                 isActive;
     GLGuiCursor*         _cursor;
+    Vector2D             _resolution;
   };

trunk/src/lib/gui/gl/glgui_text.cc

-                      r9406
+                      r9656
+  {
     this->_text.clear();
     this->changedText();
+    this->resize();
+  }
   /**
 …
     this->setFrontColor(_changedTextColor, true);
     this->textChanged.emit(this->_text.text());
+  }
+  void GLGuiText::setTextSize(float size)
+  {
+    this->_text.setSize(size);
+    this->changedText();
+  }
+  void GLGuiText::setFont(const Font& font)
+  {
+    GLGuiWidget::setFont(font);
+    this->_text.setFont(font);
+  }

trunk/src/lib/gui/gl/glgui_text.h

r9406	r9656
31	31	void clear();
32	32
	33	void setTextSize(float size);
	34	virtual void setFont(const Font& font);
33	35	void setChangedTextColor(const Color& color);
34	36

trunk/src/lib/gui/gl/glgui_widget.cc

-                      r9406
+                      r9656
     if (this == GLGuiWidget::selected())
       this->unselect();
+    if (this->_parent != NULL)
+      this->_parent->removeChildWidget(this);
+  }
 …
   GLGuiWidget* GLGuiWidget::_mouseFocused = NULL;
   GLGuiWidget* GLGuiWidget::_inputGrabber = NULL;
+  Font* GLGuiWidget::_defaultFont = NULL;
 …
     this->_state = OrxGui::Normal;
+    this->_font = Font(ResourceManager::getInstance()->getDataDir() + "/fonts/final_frontier.ttf", 20);
+    if(GLGuiWidget::_defaultFont == NULL)
+      GLGuiWidget::_defaultFont = new Font(ResourceManager::getInstance()->getDataDir() + "/fonts/final_frontier.ttf", 20);
+    this->_font = *GLGuiWidget::_defaultFont;
     this->resetStyle();
 …
   void GLGuiWidget::setFont(const std::string& fontName, unsigned int renderSize)
+  {
     this->_font = Font(fontName, renderSize);
+    this->setFont(Font(fontName, renderSize));
+  }

trunk/src/lib/gui/gl/glgui_widget.h

-                      r9406
+                      r9656
     void setFeaturePositionS(const std::string& featurePosition);
     void setFont(const Font& font);
     void setFont(const std::string& fontName, unsigned int renderSize);
+    virtual void setFont(const Font& font);
+    void setFont(const std::string& fontName, unsigned int renderSize = FONT_DEFAULT_RENDER_SIZE);
     void setAnimatedStateChanges(bool animated);
 …
     virtual void destroying();
+    // unparent the widget and from this widget seen as parent
+    virtual void removeChildWidget(GLGuiWidget* widget) {};
     virtual void debug(unsigned int level) const;
 …
     Font                           _font;                 //!< The Font used in the current Widget.
+    static Font*                   _defaultFont;          //!< The default Font.
     /// ANIMATION STUFF:

trunk/src/lib/math/quaternion.cc

-                      r9110
+                      r9656
   // check the diagonal
   float tr = mat[0][0] + mat[1][1] + mat[2][2];
+  if( tr > 0.0f) {
+  if( tr > 0.0f)
+  {
     float s = (float)sqrtf(tr + 1.0f);
     this->w = s * 0.5f;
 …
+}
+Quaternion Quaternion::lookAt(Vector from, Vector to, Vector up)
+{
+  Vector n = to - from;
+  n.normalize();
+  Vector v = n.cross(up);
+  v.normalize();
+  Vector u = v.cross(n);
+  float matrix[3][3];
+  matrix[0][0] = v.x;
+  matrix[0][1] = v.y;
+  matrix[0][2] = v.z;
+  matrix[1][0] = u.x;
+  matrix[1][1] = u.y;
+  matrix[1][2] = u.z;
+  matrix[2][0] = -n.x;
+  matrix[2][1] = -n.y;
+  matrix[2][2] = -n.z;
+  Quaternion quat;
+  quat.from3x3(matrix);
+  return quat;
+}
 /**
  * @brief outputs some nice formated debug information about this quaternion

trunk/src/lib/math/quaternion.h

-                      r9110
+                      r9656
 class Quaternion
+{
  public:
   /** creates a Default quaternion (multiplicational identity Quaternion)*/
   inline Quaternion () { w = 1; v = Vector(0,0,0); }
   /** Copy constructor @param q the Quaternion to copy. */
   inline Quaternion (const Quaternion& q) { w = q.w; v = q.v; };
   /** creates a Quaternion looking into the direction v @param v: the direction @param f: the value */
   inline Quaternion (const Vector& v, float f) { this->w = f; this->v = v; }
   /** turns a rotation along an axis into a Quaternion @param angle: the amount of radians to rotate @param axis: the axis to rotate around */
   inline Quaternion (float angle, const Vector& axis) { w = cos(angle/2.0); v = axis * sin(angle/2.0); }
   Quaternion (const Vector& dir, const Vector& up);
   Quaternion (float roll, float pitch, float yaw);
+  public:
+    /** creates a Default quaternion (multiplicational identity Quaternion)*/
+    inline Quaternion () { w = 1; v = Vector(0,0,0); }
+    /** Copy constructor @param q the Quaternion to copy. */
+    inline Quaternion (const Quaternion& q) { w = q.w; v = q.v; };
+    /** creates a Quaternion looking into the direction v @param v: the direction @param f: the value */
+    inline Quaternion (const Vector& v, float f) { this->w = f; this->v = v; }
+    /** turns a rotation along an axis into a Quaternion @param angle: the amount of radians to rotate @param axis: the axis to rotate around */
+    inline Quaternion (float angle, const Vector& axis) { w = cos(angle/2.0); v = axis * sin(angle/2.0); }
+    Quaternion (const Vector& dir, const Vector& up);
+    Quaternion (float roll, float pitch, float yaw);
   void from3x3(float m[3][3]);
   void from4x4(float m[4][4]);
+    void from3x3(float m[3][3]);
+    void from4x4(float m[4][4]);
   /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
+    /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
   inline bool operator== (const Quaternion& q) const { return (unlikely(this->v==q.v&&this->w==q.w))?true:false; };
   /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
+    /** @param q: the Quaternion to compare with this one. @returns true if the Quaternions are the same, false otherwise */
   inline bool operator!= (const Quaternion& q) const { return (unlikely(this->v!=q.v||this->w!=q.w))?true:false; };
+  /** @param f: a real value @return a Quaternion containing the quotient */
+  inline Quaternion operator/ (const float& f) const { return (unlikely(f==0.0)) ? Quaternion() : Quaternion(this->v/f, this->w/f); };
+  /** @param f: the value to divide by @returns the quaternion devided by f (this /= f) */
+  inline const Quaternion& operator/= (const float& f) {*this = *this / f; return *this;}
+  /** @param f: a real value @return a Quaternion containing the product */
+  inline Quaternion operator* (const float& f) const { return Quaternion(this->v*f, this->w*f); };
+  /** @param f: the value to multiply by @returns the quaternion multiplied by f (this *= f) */
+  inline const Quaternion& operator*= (const float& f) {*this = *this * f; return *this;}
+  /** @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 operator* (const Quaternion& q) const { return Quaternion(Vector(this->w*q.v.x + this->v.x*q.w + this->v.y*q.v.z - this->v.z*q.v.y,
+                                                                         this->w*q.v.y + this->v.y*q.w + this->v.z*q.v.x - this->v.x*q.v.z,
+                                                                         this->w*q.v.z + this->v.z*q.w + this->v.x*q.v.y - this->v.y*q.v.x),
+                                                                         this->w*q.w - this->v.x*q.v.x - this->v.y*q.v.y - this->v.z*q.v.z); };
+  /** @param q: the Quaternion to multiply by @returns the quaternion multiplied by q (this *= q) */
+  inline const Quaternion& operator*= (const Quaternion& q) {*this = *this * q; return *this; };
+  /** @param q the Quaternion by which to devide @returns the division from this by q (this / q) */
+  inline Quaternion operator/ (const Quaternion& q) const { return *this * q.inverse(); };
+  /** @param q the Quaternion by which to devide @returns the division from this by q (this /= q) */
+  inline const Quaternion& operator/= (const Quaternion& q) { *this = *this * q.inverse(); return *this; };
+  /** @param q the Quaternion to add to this @returns the quaternion added with q (this + q) */
+  inline Quaternion operator+ (const Quaternion& q) const { return Quaternion(q.v + v, q.w + w); };
+  /** @param q the Quaternion to add to this @returns the quaternion added with q (this += q) */
+  inline const Quaternion& operator+= (const Quaternion& q) { this->v += q.v; this->w += q.w; return *this; };
+  /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this - q) */
+  inline Quaternion operator- (const Quaternion& q) const { return Quaternion(q.v - v, q.w - w); }
+  /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this -= q) */
+  inline const Quaternion& operator-= (const Quaternion& q) { this->v -= q.v; this->w -= q.w; return *this; };
+  /** copy constructor @param q: the Quaternion to set this to. @returns the Quaternion q (or this) */
+  inline Quaternion operator= (const Quaternion& q) {this->v = q.v; this->w = q.w; return *this;}
+  /** conjugates this Quaternion @returns the conjugate */
+  inline Quaternion conjugate () const { return Quaternion(Vector(-v.x, -v.y, -v.z), this->w); };
+  /** @returns the norm of The Quaternion */
+  inline float norm () const { return sqrt(w*w + v.x*v.x + v.y*v.y + v.z*v.z); };
+  /** @returns the inverted Quaterntion of this */
+  inline Quaternion inverse () const { return conjugate() / (w*w + v.x*v.x + v.y*v.y + v.z*v.z); };
+  /** @returns the dot Product of a Quaternion */
+  inline float dot (const Quaternion& q) const { return v.x*q.v.x + v.y*q.v.y + v.z*q.v.z + w*q.w; };
+  /** @retuns the Distance between two Quaternions */
+  inline float distance(const Quaternion& q) const { return 2*acos(fabsf(this->dot(q))); };
+  /** @param v: the Vector  @return a new Vector representing v rotated by the Quaternion */
+  inline Vector apply (const Vector& v) const { return (*this * Quaternion(v, 0) * conjugate()).v; };
+  void matrix (float m[4][4]) const;
+  /** @returns the normalized Quaternion (|this|) */
+  inline Quaternion getNormalized() const { float n = this->norm(); return Quaternion(this->v/n, this->w/n); };
+  /** normalizes the current Quaternion */
+  inline void normalize() { float n = this->norm(); this->v /= n; this->w/=n; };
+    /** @param f: a real value @return a Quaternion containing the quotient */
+    inline Quaternion operator/ (const float& f) const { return (unlikely(f==0.0)) ? Quaternion() : Quaternion(this->v/f, this->w/f); };
+    /** @param f: the value to divide by @returns the quaternion devided by f (this /= f) */
+    inline const Quaternion& operator/= (const float& f) {*this = *this / f; return *this;}
+    /** @param f: a real value @return a Quaternion containing the product */
+    inline Quaternion operator* (const float& f) const { return Quaternion(this->v*f, this->w*f); };
+    /** @param f: the value to multiply by @returns the quaternion multiplied by f (this *= f) */
+    inline const Quaternion& operator*= (const float& f) {*this = *this * f; return *this;}
+    /** @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 operator* (const Quaternion& q) const
+    {
+      return Quaternion(Vector(this->w*q.v.x + this->v.x*q.w + this->v.y*q.v.z - this->v.z*q.v.y,
+                               this->w*q.v.y + this->v.y*q.w + this->v.z*q.v.x - this->v.x*q.v.z,
+                               this->w*q.v.z + this->v.z*q.w + this->v.x*q.v.y - this->v.y*q.v.x),
+                        this->w*q.w - this->v.x*q.v.x - this->v.y*q.v.y - this->v.z*q.v.z);
+    };
+    /** @param q: the Quaternion to multiply by @returns the quaternion multiplied by q (this *= q) */
+    inline const Quaternion& operator*= (const Quaternion& q) {*this = *this * q; return *this; };
+    /** @param q the Quaternion by which to devide @returns the division from this by q (this / q) */
+    inline Quaternion operator/ (const Quaternion& q) const { return *this * q.inverse(); };
+    /** @param q the Quaternion by which to devide @returns the division from this by q (this /= q) */
+    inline const Quaternion& operator/= (const Quaternion& q) { *this = *this * q.inverse(); return *this; };
+    /** @param q the Quaternion to add to this @returns the quaternion added with q (this + q) */
+    inline Quaternion operator+ (const Quaternion& q) const { return Quaternion(q.v + v, q.w + w); };
+    /** @param q the Quaternion to add to this @returns the quaternion added with q (this += q) */
+    inline const Quaternion& operator+= (const Quaternion& q) { this->v += q.v; this->w += q.w; return *this; };
+    /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this - q) */
+    inline Quaternion operator- (const Quaternion& q) const { return Quaternion(q.v - v, q.w - w); }
+    /** @param q the Quaternion to substrace from this @returns the quaternion substracted by q (this -= q) */
+    inline const Quaternion& operator-= (const Quaternion& q) { this->v -= q.v; this->w -= q.w; return *this; };
+    /** copy constructor @param q: the Quaternion to set this to. @returns the Quaternion q (or this) */
+    inline Quaternion operator= (const Quaternion& q) {this->v = q.v; this->w = q.w; return *this;}
+    /** conjugates this Quaternion @returns the conjugate */
+    inline Quaternion conjugate () const { return Quaternion(Vector(-v.x, -v.y, -v.z), this->w); };
+    /** @returns the norm of The Quaternion */
+    inline float norm () const { return sqrt(w*w + v.x*v.x + v.y*v.y + v.z*v.z); };
+    /** @returns the inverted Quaterntion of this */
+    inline Quaternion inverse () const { return conjugate() / (w*w + v.x*v.x + v.y*v.y + v.z*v.z); };
+    /** @returns the dot Product of a Quaternion */
+    inline float dot (const Quaternion& q) const { return v.x*q.v.x + v.y*q.v.y + v.z*q.v.z + w*q.w; };
+    /** @retuns the Distance between two Quaternions */
+    inline float distance(const Quaternion& q) const { return 2*acos(fabsf(this->dot(q))); };
+    /** @param v: the Vector  @return a new Vector representing v rotated by the Quaternion */
+    inline Vector apply (const Vector& v) const { return (*this * Quaternion(v, 0) * conjugate()).v; };
+    void matrix (float m[4][4]) const;
+    /** @returns the normalized Quaternion (|this|) */
+    inline Quaternion getNormalized() const { float n = this->norm(); return Quaternion(this->v/n, this->w/n); };
+    /** normalizes the current Quaternion */
+    inline void normalize() { float n = this->norm(); this->v /= n; this->w/=n; };
   float getHeading() const;
   Quaternion getHeadingQuat() const;
   float getAttitude() const;
   Quaternion getAttitudeQuat() const;
   float getBank() const;
   Quaternion getBankQuat() const;
   /** @returns the rotational axis of this Quaternion */
   inline Vector getSpacialAxis() const { return this->v / sin(acos(w));/*sqrt(v.x*v.x + v.y*v.y + v.z+v.z);*/ };
   /** @returns the rotational angle of this Quaternion around getSpacialAxis()  !! IN DEGREE !! */
   inline float getSpacialAxisAngle() const { return 360.0 / M_PI * acos( this->w ); };
+    float getHeading() const;
+    Quaternion getHeadingQuat() const;
+    float getAttitude() const;
+    Quaternion getAttitudeQuat() const;
+    float getBank() const;
+    Quaternion getBankQuat() const;
+    /** @returns the rotational axis of this Quaternion */
+    inline Vector getSpacialAxis() const { return this->v / sin(acos(w));/*sqrt(v.x*v.x + v.y*v.y + v.z+v.z);*/ };
+    /** @returns the rotational angle of this Quaternion around getSpacialAxis()  !! IN DEGREE !! */
+    inline float getSpacialAxisAngle() const { return 360.0 / M_PI * acos( this->w ); };
+  inline void slerpTo(const Quaternion& toQuat, float t);
+  static Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);
+  void debug() const;
+  void debug2() const;
+    inline void slerpTo(const Quaternion& toQuat, float t);
+    static Quaternion quatSlerp(const Quaternion& from, const Quaternion& to, float t);
+ public:
+  Vector    v;        //!< Imaginary Vector
+  float     w;        //!< Real part of the number
+    static Quaternion lookAt(Vector from, Vector to, Vector up);
+    void debug() const;
+    void debug2() const;
+  public:
+    Vector    v;        //!< Imaginary Vector
+    float     w;        //!< Real part of the number
 };

trunk/src/lib/network/Makefile.am

r9494	r9656
27	27	\
28	28	proxy/network_settings.cc \
	29	proxy/proxy_control.cc \
29	30	\
30	31	monitor/connection_monitor.cc \
…	…
76	77	udp_broadcast.h \
77	78	\
78		proxy/network_settings.cc \
	79	proxy/network_settings.h \
	80	proxy/proxy_control.h \
79	81	\
80	82	monitor/connection_monitor.h \

trunk/src/lib/network/README.NETWORK

-                      r9494
+                      r9656
+WORD OF WARNING:
+================
+ - Allways keep the network_settings.conf file from the data repos up-to-date!! Its very important, that the user numbers are synchronized!
 WORKING_STACK:
 ==============
+ - it works to connecto to a master server which is connected to a proxy itself
+ - removed compiler warnings in some modules
+ - totaly rework of the permission system
+ - introduced a new PERMISSION layer: PERMISSION_SERVER which gives the nearest server the authority to handle
 UNSOLVED:
 =========
+ - what if the proxy server gets a new client and wants to add it to the game? There are some problems waiting in the network game manager
+ - actualy the whole message sending system won't work in this network topic. proxys have to relay messages to clients
+ - the clients cant get its ip in the handleHandshakes without throuwing sigseg
+ - the clients cant get its ip in the handleHandshakes without throwing sigseg
+ - MessageManager: proxy/server forward the messages always. Perhaps there is a case, where messages get forwarded forever if there is a loop in the network. think about it again.
+ - Permissions: Proxy Servers shouldn't be able to create new eneitites on the server
+ - the nick name must be handled new
 …
+The ids are created by the master/proxy servers. Each server receives an address space of 1000 nodes where it is able to assign nodes to. This address space could be extended quite easely, since we got plenty of numbers in 4bytes (integer)
+The handshake sync has always the uniqueId == userId. This is why there are some reserved uniqueIds
 uniqueId:
 =========
 uniqueId is an id (unique :D) for each synchronizeable to be identified in a network. the number space for uniqueIds goes from 0 to maxplayers - 1
+The handshake sync has always the uniqueId == userId. This is why there are some reserved uniqueIds
 …
 PERMISSION_ALL                 : all clients can write this variable
+Only the master server should have the permission to create new WorldEntities and to add them to the game
 …
+MessageManager:
+===============
+The message manager has special handling if its a master/proxy: the messages will simply be forwarded to the other server
+Proxy Control:
+==============
+The ProxyControl class manages the state of the network by exchanging state messages.

trunk/src/lib/network/handshake.cc

r9494	r9656
71	71	remoteState.error = 0;
72	72	remoteState.errorString = "";
73		remoteState.hostId = -1;
	73	remoteState.hostId = NET_ID_UNASSIGNED;
74	74	remoteState.networkManagerId = -1;
75	75	remoteState.messageManagerId = -1;

trunk/src/lib/network/message_manager.cc

-                      r9494
+                      r9656
    ### File Specific:
    main-programmer: Christoph Renner
+   co-programmer: ...
+   co-programmer: Patrick Boenzli (patrick@orxonox.ethz.ch)
+     June 2006: finishing work on the network stream for pps presentation (rennerc@ee.ethz.ch)
+     July 2006: some code rearangement and integration of the proxy server mechanism (boenzlip@ee.ethz.ch)
+     July 2006: message forwarding algorithms
 */
 …
 MessageManager::~MessageManager ()
+{
   for ( MessageQueue::iterator it = messageQueue.begin(); it != messageQueue.end(); it++ )
+  for ( MessageQueue::iterator it = outgoingMessageQueue.begin(); it != outgoingMessageQueue.end(); it++ )
+  {
     for ( std::list<NetworkMessage>::iterator it2 = it->second.messages.begin(); it2 != it->second.messages.end(); it2++ )
 …
+  }
   messageQueue.clear();
+  outgoingMessageQueue.clear();
   this->messageHandlerMap.clear();
 …
   int n;
   n = Converter::intToByteArray( messageQueue[userId].toAck.size(), data + i, maxLength );
+  n = Converter::intToByteArray( outgoingMessageQueue[userId].toAck.size(), data + i, maxLength );
   i += n;
   assert( n == INTSIZE );
   for ( std::list<int>::iterator it = messageQueue[userId].toAck.begin(); it != messageQueue[userId].toAck.end(); it++)
+  for ( std::list<int>::iterator it = outgoingMessageQueue[userId].toAck.begin(); it != outgoingMessageQueue[userId].toAck.end(); it++)
+  {
     n = Converter::intToByteArray( *it, data + i, maxLength );
 …
+  }
   messageQueue[userId].toAck.clear();
   n = Converter::intToByteArray( messageQueue[userId].messages.size(), data + i, maxLength );
+  outgoingMessageQueue[userId].toAck.clear();
+  n = Converter::intToByteArray( outgoingMessageQueue[userId].messages.size(), data + i, maxLength );
   i += n;
   assert( n == INTSIZE );
+  for ( std::list<NetworkMessage>::iterator it = messageQueue[userId].messages.begin(); it != messageQueue[userId].messages.end(); it++ )
+  {
+  // write the message down, a message has this structure:
+  //   | data_length | serial_number | message_type | source_id | dest_id | ...data... |
+  //      4byte        4byte            4byte         4byte      4byte     data_length
+  for ( std::list<NetworkMessage>::iterator it = outgoingMessageQueue[userId].messages.begin(); it != outgoingMessageQueue[userId].messages.end(); it++ )
+  {
+    // send data length
     n = Converter::intToByteArray( it->length, data + i, maxLength );
     i += n;
     assert( n == INTSIZE );
+    // send serial number
     n = Converter::intToByteArray( it->number, data + i, maxLength );
     i += n;
     assert( n == INTSIZE );
+    n = Converter::intToByteArray( it->messageId, data + i, maxLength );
+    i += n;
+    assert( n == INTSIZE );
+    // send message type
+    n = Converter::intToByteArray( it->messageType, data + i, maxLength );
+    i += n;
+    assert( n == INTSIZE );
+    // send sender id
+    n = Converter::intToByteArray( it->senderId, data + i, maxLength );
+    i += n;
+    assert( n == INTSIZE );
+    // send destination id
+    n = Converter::intToByteArray( it->destinationId, data + i, maxLength );
+    i += n;
+    assert( n == INTSIZE );
+    // send receiver type
+    n = Converter::intToByteArray( it->recieverType, data + i, maxLength );
+    i += n;
+    assert( n == INTSIZE );
+    // and copy the data
     assert( i + it->length <= maxLength );
     memcpy( data + i, it->data, it->length );
 …
   int nAcks;
   assert( i + INTSIZE <= length );
   n = Converter::byteArrayToInt( data + i, &nAcks );
 …
   i += n;
+  int messageLength, messageId;
+  int messageLength, messageType;
+  int senderId, destinationId, recieverType;
+  // now go through all newly received messages and assemble them
   for ( int j = 0; j < nMessages; j++ )
+  {
+    // read the length
     assert( i + INTSIZE <= length );
     n = Converter::byteArrayToInt( data + i, &messageLength );
 …
     i += n;
+    // read the serial number
     assert( i + INTSIZE <= length );
     n = Converter::byteArrayToInt( data + i, &number );
 …
     i += n;
+    assert( i + INTSIZE <= length );
+    n = Converter::byteArrayToInt( data + i, &messageId );
+    // read the message type
+    assert( i + INTSIZE <= length );
+    n = Converter::byteArrayToInt( data + i, &messageType );
+    assert( n == INTSIZE );
+    i += n;
+    // read the sender id
+    assert( i + INTSIZE <= length );
+    n = Converter::byteArrayToInt( data + i, &senderId );
+    assert( n == INTSIZE );
+    i += n;
+    //read the destination id
+    assert( i + INTSIZE <= length );
+    n = Converter::byteArrayToInt( data + i, &destinationId);
+    assert( n == INTSIZE );
+    i += n;
+    // read the receiver type
+    assert( i + INTSIZE <= length );
+    n = Converter::byteArrayToInt( data + i, &recieverType);
     assert( n == INTSIZE );
     i += n;
     if ( number > 0 )
+      messageQueue[userId].toAck.push_back( number );
+      outgoingMessageQueue[userId].toAck.push_back( number );
+//     PRINTF(0)("got message with type: %i\n", messageType);
     assert( i + messageLength <= length );
+    assert( messageHandlerMap.find( (MessageId)messageId ) != messageHandlerMap.end() );
+    if ( std::find( messageQueue[userId].recievedMessages.begin(), messageQueue[userId].recievedMessages.end(), number )== messageQueue[userId].recievedMessages.end() )
+    // make sure there is a message handler for this message type
+    assert( messageHandlerMap.find( (MessageType)messageType ) != messageHandlerMap.end());
+    if ( std::find( outgoingMessageQueue[userId].recievedMessages.begin(), outgoingMessageQueue[userId].recievedMessages.end(), number ) ==
+         outgoingMessageQueue[userId].recievedMessages.end() )
+    {
+      if ( !(*(messageHandlerMap[(MessageId)messageId].cb))( (MessageId)messageId, data + i, messageLength, messageHandlerMap[(MessageId)messageId].someData, userId ) )
+      // find out if this message is addressed for this client too
+      if( recieverType == RT_ALL_BUT_ME  && SharedNetworkData::getInstance()->getHostID() != senderId ||
+          recieverType == RT_ALL_ME ||
+          recieverType == RT_NOT_USER && SharedNetworkData::getInstance()->getHostID() != destinationId ||
+          recieverType == RT_USER  && SharedNetworkData::getInstance()->getHostID() == destinationId ||
+          recieverType == RT_SERVER && SharedNetworkData::getInstance()->isMasterServer() ||
+          recieverType == RT_SERVER && SharedNetworkData::getInstance()->isProxyServerActive())
+      {
+        NetworkMessage msg;
+        msg.data = new byte[messageLength];
+        memcpy( msg.data, data + i, messageLength );
+        msg.length = messageLength;
+        msg.messageId = (MessageId)messageId;
+        msg.number = userId;
+        incomingMessageBuffer.push_back( msg );
+        PRINTF(0)("<<< MessageManager: got msg with type: %i, from sender %i, to rec: %i\n", messageType, senderId, destinationId);
+      // call the handler function and handle errors
+        if ( !(*(messageHandlerMap[(MessageType)messageType].cb))( (MessageType)messageType, data + i, messageLength,
+                 messageHandlerMap[(MessageType)messageType].someData, senderId, destinationId ) )
+        {
+        // if the message is not handled correctly, bush it back to the incoming packets therefore trying it later
+          NetworkMessage msg;
+          msg.data = new byte[messageLength];
+          memcpy( msg.data, data + i, messageLength );
+          msg.length = messageLength;
+          msg.messageType = (MessageType)messageType;
+          msg.number = userId;
+          msg.senderId = senderId;
+          msg.recieverType = (RecieverType)recieverType;
+          msg.destinationId = destinationId;
+          incomingMessageQueue.push_back( msg );
+        }
+      }
+      messageQueue[userId].recievedMessages.push_back( number );
+      // check if the message needs to be forwarded
+      if( recieverType == RT_ALL_BUT_ME ||
+          recieverType == RT_ALL_ME ||
+          recieverType == RT_NOT_USER ||
+          recieverType == RT_USER  && SharedNetworkData::getInstance()->getHostID() != destinationId ||
+          recieverType == RT_SERVER && SharedNetworkData::getInstance()->isProxyServerActive() )
+      {
+        // forwarding the messages but only if its a proxy
+        if( SharedNetworkData::getInstance()->isProxyServerActive())
+        {
+          PRINTF(0)("===========>> Forwarding Message msg with type: %i, from sender %i, to rec: %i\n", messageType, senderId, destinationId);
+          NetworkMessage msg;
+          msg.data = new byte[messageLength];
+          memcpy( msg.data, data + i, messageLength );
+          msg.length = messageLength;
+          msg.messageType = (MessageType)messageType;
+          msg.number = userId;
+          msg.senderId = senderId;
+          msg.destinationId = destinationId;
+          msg.recieverType = (RecieverType)recieverType;
+          this->sendMessage(msg.messageType, msg.data, msg.length, msg.recieverType, msg.senderId = senderId, msg.destinationId, MP_HIGHBANDWIDTH);
+        }
+      }
+      // save the serial number for ack signaling
+      outgoingMessageQueue[userId].recievedMessages.push_back( number );
+    }
     i += messageLength;
+  }
+  //TODO maybe handle incomingMessage in tick function. else local messages will not be handled if no clients are connected
+  for ( std::list<NetworkMessage>::iterator it = incomingMessageBuffer.begin(); it != incomingMessageBuffer.end();  )
+  {
+    if ( (*(messageHandlerMap[it->messageId].cb))( it->messageId, it->data, it->length, messageHandlerMap[it->messageId].someData, it->number ) )
+  //walk throu message queue and remove acked messages
+  for ( std::list<NetworkMessage>::iterator it = outgoingMessageQueue[userId].messages.begin(); it != outgoingMessageQueue[userId].messages.end();  )
+  {
+    if ( std::find( acks.begin(), acks.end(), it->number) != acks.end() )
+    {
+      std::list<NetworkMessage>::iterator delIt = it;
+      it++;
+      outgoingMessageQueue[userId].messages.erase( delIt );
+      continue;
+    }
+    it++;
+  }
+  //TODO find bether way. maybe with timestamp
+  if ( outgoingMessageQueue[userId].recievedMessages.size() > 1000 )
+  {
+    for ( int j = 0; j < (int)outgoingMessageQueue[userId].recievedMessages.size() - 1000; j++ )
+      outgoingMessageQueue[userId].recievedMessages.erase( outgoingMessageQueue[userId].recievedMessages.begin() );
+  }
+  return i;
+}
+/**
+ * processes the message manager data, specialy check for localy generated messages
+ */
+void MessageManager::processData()
+{
+  // now call the message handlers with the new message
+  for ( std::list<NetworkMessage>::iterator it = incomingMessageQueue.begin(); it != incomingMessageQueue.end();  )
+  {
+    PRINTF(0)("<<< MessageManager: got local msg with type: %i, from sender %i, to rec: %i\n", (*it).messageType, (*it).senderId, (*it).destinationId);
+    if ( (*(messageHandlerMap[it->messageType].cb))( it->messageType, it->data, it->length, messageHandlerMap[it->messageType].someData,
+                                                     /*it->number, */it->senderId, it->destinationId ) )
+    {
       std::list<NetworkMessage>::iterator delIt = it;
 …
         delete it->data;
       it++;
       incomingMessageBuffer.erase( delIt );
+      incomingMessageQueue.erase( delIt );
       continue;
+    }
 …
+  }
+  //walk throu message queue and remove acked messages
+  for ( std::list<NetworkMessage>::iterator it = messageQueue[userId].messages.begin(); it != messageQueue[userId].messages.end();  )
+  {
+    if ( std::find( acks.begin(), acks.end(), it->number) != acks.end() )
+    {
+      std::list<NetworkMessage>::iterator delIt = it;
+      it++;
+      messageQueue[userId].messages.erase( delIt );
+      continue;
+    }
+    it++;
+  }
+  //TODO find bether way. maybe with timestamp
+  if ( messageQueue[userId].recievedMessages.size() > 1000 )
+  {
+    for ( int j = 0; j < messageQueue[userId].recievedMessages.size() - 1000; j++ )
+      messageQueue[userId].recievedMessages.erase( messageQueue[userId].recievedMessages.begin() );
+  }
+  return i;
+}
+}
 /**
 …
 void MessageManager::cleanUpUser( int userId )
+{
   if ( messageQueue.find( userId ) == messageQueue.end() )
+  if ( outgoingMessageQueue.find( userId ) == outgoingMessageQueue.end() )
     return;
   for ( std::list<NetworkMessage>::iterator it = messageQueue[userId].messages.begin(); it != messageQueue[userId].messages.end(); it++ )
+  for ( std::list<NetworkMessage>::iterator it = outgoingMessageQueue[userId].messages.begin(); it != outgoingMessageQueue[userId].messages.end(); it++ )
+  {
     if ( it->data )
 …
+  }
   messageQueue[userId].toAck.clear();
   messageQueue.erase( userId );
+}
 /**
  * registers function to handle messages with id messageId. someData is passed to callbackfuntion
  * @param messageId message id to handle
+  outgoingMessageQueue[userId].toAck.clear();
+  outgoingMessageQueue.erase( userId );
+}
+/**
+ * registers function to handle messages with id messageType. someData is passed to callbackfuntion
+ * @param messageType message id to handle
  * @param cb function pointer to callback function
  * @param someData this pointer is passed to callback function without modification
  * @return true on success
  */
 bool MessageManager::registerMessageHandler( MessageId messageId, MessageCallback cb, void * someData )
+bool MessageManager::registerMessageHandler( MessageType messageType, MessageCallback cb, void * someData )
+{
   MessageHandler messageHandler;
   messageHandler.cb = cb;
   messageHandler.messageId = messageId;
+  messageHandler.messageType = messageType;
   messageHandler.someData = someData;
   messageHandlerMap[messageId] = messageHandler;
+  messageHandlerMap[messageType] = messageHandler;
   return true;
 …
+{
   // just do something so map creates a new entry
+  messageQueue[userId].toAck.clear();
+  //assert( messageQueue[userId].messages.size() == 0 );
+}
+  outgoingMessageQueue[userId].toAck.clear();
+  //assert( outgoingMessageQueue[userId].messages.size() == 0 );
+}
 /**
 …
  *               RT_NOT_USER send to all but reciever
+ *
  * @param messageId message id
+ * @param messageType message id
  * @param data pointer to data
  * @param dataLength length of data
+ * @param recieverType
+ * @param reciever
+ */
+void MessageManager::sendMessage( MessageId messageId, byte * data, int dataLength, RecieverType recieverType, int reciever, MessagePriority messagePriority )
+{
+  for ( MessageQueue::iterator it = messageQueue.begin(); it != messageQueue.end(); it++ )
+  {
+ * @param recieverType type of the receiver
+ * @param reciever the userId of the receiver if needed (depends on the ReceiverType)
+ */
+void MessageManager::sendMessage( MessageType messageType, byte * data, int dataLength, RecieverType recieverType, int reciever, MessagePriority messagePriority )
+{
+  this->sendMessage(messageType, data, dataLength, recieverType, SharedNetworkData::getInstance()->getHostID(), reciever, messagePriority);
+}
+/**
+ * send a message to one or more clients as a special client
+ * recieverType:
+ *               RT_ALL send to all users. reciever is ignored
+ *               RT_USER send only to reciever
+ *               RT_NOT_USER send to all but reciever
+ *
+ * @param messageType message id
+ * @param data pointer to data
+ * @param dataLength length of data
+ * @param recieverType type of the receiver
+ * @param sender the userId of the sender if there is need for shadowing it (eg. for msg forwarding)
+ * @param reciever the userId of the receiver if needed (depends on the ReceiverType)
+ */
+    void MessageManager::sendMessage( MessageType messageType, byte * data, int dataLength, RecieverType recieverType, int sender, int reciever, MessagePriority messagePriority )
+{
+  PRINTF(0)(" >>> MessageManager: sending msg with type: %i, recieverType: %i, reciever %i\n", messageType, recieverType, reciever);
+  // go through all outgoing message queues and add the message if its appropriate
+  for ( MessageQueue::iterator it = this->outgoingMessageQueue.begin(); it != this->outgoingMessageQueue.end(); it++ )
+  {
     if (
+         recieverType == RT_ALL_ME ||
+         recieverType == RT_ALL_BUT_ME ||
+         recieverType == RT_USER && it->first == reciever ||
+         recieverType == RT_NOT_USER && it->first != reciever ||
+         recieverType == RT_SERVER && getNetworkStream()->isUserMasterServer( it->first ) ||
+         recieverType == RT_SERVER && getNetworkStream()->isUserProxyServerActive( it->first )
+       )
+         recieverType == RT_ALL_ME      ||
+         recieverType == RT_ALL_BUT_ME  ||
+         recieverType == RT_USER        && it->first == reciever ||
+         recieverType == RT_USER        && reciever == NET_ID_MASTER_SERVER && !getNetworkStream()->isUserMasterServer( it->first ) ||  //(*)
+         recieverType == RT_NOT_USER    && it->first != reciever ||
+         recieverType == RT_SERVER      && getNetworkStream()->isUserMasterServer( it->first ) ||
+         recieverType == RT_SERVER      && getNetworkStream()->isUserProxyServerActive( it->first )
+       )// (*) special case: forward
+    {
       NetworkMessage msg;
 …
       memcpy( msg.data, data, dataLength );
       msg.length = dataLength;
+      msg.messageId = messageId;
+      msg.number = newNumber++;
+      msg.messageType = messageType;
+      msg.number = this->newNumber++;
+      msg.senderId = sender;
+      msg.destinationId = reciever;
+      msg.recieverType = recieverType;
       msg.priority = messagePriority;
       it->second.messages.push_back( msg );
+    }
+  }
+  if ( recieverType == RT_ALL_ME )
+  }
+  // if the message is also for myself, handle it here
+  if ( recieverType == RT_ALL_ME ||
+       recieverType == RT_USER   && reciever == SharedNetworkData::getInstance()->getHostID()
+     )
+  {
     NetworkMessage msg;
 …
     memcpy( msg.data, data, dataLength );
     msg.length = dataLength;
     msg.messageId = messageId;
+    msg.messageType = messageType;
     msg.number = SharedNetworkData::getInstance()->getHostID();
+    msg.senderId = sender;
+    msg.destinationId = reciever;
+    msg.recieverType = recieverType;
     msg.priority = messagePriority;
     incomingMessageBuffer.push_back( msg );
+  }
+}
+    this->incomingMessageQueue.push_back( msg );
+  }
+}

trunk/src/lib/network/message_manager.h

-                      r9494
+                      r9656
       int length
       int number
       int MessageId
+      int MessageType
       byte * data
     )[1..nmsg]
 …
+enum MessageId
+//!< different message ids
+enum MessageType
+{
+  TESTMESSAGEID = 1,
+  MSGID_DELETESYNCHRONIZEABLE,
+  MSGID_PREFEREDTEAM,
+  MSGID_CHANGENICKNAME,
+  MSGID_CHATMESSAGE,
+  MSGID_RESPAWN
+  TESTMESSAGEID                  = 1,         //!< for testing purposes
+  MSGID_DELETESYNCHRONIZEABLE,                //!< message for sync deletion
+  MSGID_PREFEREDTEAM,                         //!< change prefered team
+  MSGID_CHANGENICKNAME,                       //!< change nicknames
+  MSGID_CHATMESSAGE,                          //!< chat message
+  MSGID_RESPAWN,                              //!< respawn message
+  MSGID_PROXY_NEWCLIENT,                       //!< informs the master server about a new client
+  MSGID_PROXY_LEAVECLIENT,                     //!< informs the master and other proxy servers about a leaving client
+  MSGID_PROXY_COMMAND,                         //!< command handler: delivers commands from and to proxies/clients
 };
-typedef bool (*MessageCallback)( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
+enum RecieverType
+typedef bool (*MessageCallback)( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId );
+typedef enum RecieverType
+{
   RT_ALL_BUT_ME = 1,   //!< message is sent to all users but myself
 …
 struct NetworkMessage
+{
+  MessageId        messageId;
+  byte *           data;
+  int              length;
+  int              number;
+  MessagePriority  priority;
+  MessageType      messageType;                         //!< type of the message
+  byte *           data;                                //!< data
+  int              length;                              //!< length of the data
+  int              number;                              //!< serial number
+  int              senderId;                            //!< userId of the sender
+  int              destinationId;                       //!< userId of the destination
+  RecieverType     recieverType;                        //!< type of the receiver
+  MessagePriority  priority;                            //!< priority of the messages
 };
 …
 typedef std::map<int,MessageUserQueue> MessageQueue;
 struct MessageHandler
+{
   MessageCallback cb;
   MessageId       messageId;
   void *          someData;
+  MessageCallback   cb;
+  MessageType       messageType;
+  void *            someData;
 };
 typedef std::map<MessageId,MessageHandler> MessageHandlerMap;
+typedef std::map<MessageType,MessageHandler> MessageHandlerMap;
 //! A class for sending messages over network
 class MessageManager : public Synchronizeable {
+ protected:
+   MessageManager();
  public:
    inline static MessageManager * getInstance(){ if (!singletonRef) singletonRef = new MessageManager();  return singletonRef; }
 …
    virtual ~MessageManager();
    bool registerMessageHandler( MessageId messageId, MessageCallback cb, void * someData );
+   bool registerMessageHandler( MessageType messageType, MessageCallback cb, void * someData );
+   void sendMessage( MessageId messageId, byte * data, int dataLength, RecieverType recieverType, int reciever, MessagePriority messagePriority );
+   void sendMessage( MessageType messageType, byte * data, int dataLength, RecieverType recieverType, int reciever, MessagePriority messagePriority );
+   void sendMessage( MessageType messageType, byte * data, int dataLength, RecieverType recieverType, int sender, int reciever, MessagePriority messagePriority );
+   void initUser( int userId );
+   void processData();
+  protected:
+    MessageManager();
+  private:
    virtual int getStateDiff( int userId, byte* data, int maxLength, int stateId, int fromStateId, int priorityTH );
    virtual int setStateDiff( int userId, byte* data, int length, int stateId, int fromStateId );
 …
    virtual void handleRecvState( int userId, int stateId, int fromStateId ){}
-   void initUser( int userId );
  private:
+   static MessageManager *   singletonRef;
+   MessageQueue              messageQueue;           //!< stores messages to send
+   static MessageManager *   singletonRef;           //!< the singleton reference
+   std::list<NetworkMessage> incomingMessageQueue;   //!< the incoming message buffer
+   MessageQueue              outgoingMessageQueue;   //!< stores messages to send
    MessageHandlerMap         messageHandlerMap;      //!< contains handlers for messages
    int                       newNumber;              //!< used to create unique message numbers
+   std::list<NetworkMessage> incomingMessageBuffer;
 };
 #endif /* _PROTO_CLASS_H */
+#endif /* _MESSAGE_MANAGER_H */

trunk/src/lib/network/monitor/network_monitor.cc

-                      r9494
+                      r9656
 ### File Specific:
    main-programmer: Patrick Boenzli
+   main-programmer: Patrick Boenzli (patrick@orxonox.ethz.ch)
 */
 …
   this->networkStream = networkStream;
   this->playerNumber = 0;
+  this->connectionNumber = 0;
   // create the localnode, init it and add it to the nodes list
   this->localNode = new NetworkNode( this->networkStream->getPeerInfo());
 …
       PeerInfo* peer = new PeerInfo();
       peer->ip = (*it);
       peer->nodeType = NET_PROXY_SERVER_ACTIVE;
+      peer->nodeType = NET_PROXY_SERVER_PASSIVE;
       peer->userId = -1;
-      NetworkNode* node = new NetworkNode(peer);
-      this->addNode( node);
       this->addActiveProxyServer( this->localNode, peer);
+    }
 …
     return;
+  PRINTF(0)("^^^^^^^^^^^^^^^^^^^^^^^^^^ adding node: %i with type: %s\n\n", pInfo->userId, pInfo->getNodeTypeString().c_str());
   if( pInfo->isClient())
+    this->localNode->addClient(pInfo);
+  {
+    this->localNode->addClient(new NetworkNode(pInfo));
+  }
   else if( pInfo->isProxyServerActive())
+  {
+    this->localNode->addActiveProxyServer(pInfo);
+    // create a new node, since a proxy can connect clients again
+    NetworkNode* node = new NetworkNode(pInfo);
+    this->nodeList.push_back(node);
+    this->localNode->addActiveProxyServer(new NetworkNode(pInfo));
+  }
+  else if( pInfo->isProxyServerActivePassive())
+  {
+    this->localNode->addPassiveProxyServer(new NetworkNode(pInfo));
+  }
   else if( pInfo->isMasterServer())
+  {
+    this->localNode->addMasterServer(pInfo);
+  }
+    this->localNode->addMasterServer(new NetworkNode(pInfo));
+  }
+  else
+    assert(false);
+}
 …
   if( pInfo->isClient())
     node->addClient(pInfo);
+    node->addClient(new NetworkNode(pInfo));
   else if( pInfo->isProxyServerActive())
     node->addActiveProxyServer(pInfo);
+    node->addActiveProxyServer(new NetworkNode(pInfo));
   else if( pInfo->isMasterServer())
+    node->addMasterServer(pInfo);
+    node->addMasterServer(new NetworkNode(pInfo));
+}
+/**
+ * removes a node from the network monitor
+ * @param pInfo the node to remove
+ */
+void NetworkMonitor::removeNode(PeerInfo* pInfo)
+{
+  this->removeNode(this->localNode, pInfo);
+}
+/**
+ * removes the network node
+ * @param node the network node where the PeerInfo node is connected to
+ * @param pInfo the PeerInfo to remove
+ */
+void NetworkMonitor::removeNode(NetworkNode* node, PeerInfo* pInfo)
+{
+  if( node == NULL || pInfo == NULL)
+    return;
+  if( pInfo->isClient())
+    node->removeClient(pInfo->userId);
+  else if( pInfo->isProxyServerActive())
+    node->removeActiveProxyServer(pInfo->userId);
+  else if( pInfo->isMasterServer())
+    node->removeMasterServer(pInfo->userId);
+}
 …
 /**
+ * @param userId of the searched node
+ * @returns the PeerInfo of the userId peer
+ */
+PeerInfo* NetworkMonitor::getPeerByUserId( int userId)
+{
+  NetworkNode* node = this->getNodeByUserId(userId);
+  if( node != NULL)
+    return node->getPeerInfo();
+  return NULL;
+}
+/**
+ * searches for a given NetworkNode
+ * @param userId of the searched node
+ * @returns the PeerInfo of the userId peer
+ */
+NetworkNode* NetworkMonitor::getNodeByUserId( int userId)
+{
+  std::list<NetworkNode*>::iterator it = this->nodeList.begin();
+  NetworkNode* node = NULL;
+  for(; it != this->nodeList.end(); it++)
+  {
+    node = (*it)->getNodeByUserId(userId);
+    if( node != NULL)
+      return node;
+  }
+  return NULL;
+}
+/**
  * this displays the network monitor gui
  */
 …
   if (this->box == NULL)
+  {
+    this->box = new OrxGui::GLGuiBox(OrxGui::Vertical);
+    {
+      NetworkStatsWidget* netStats = new NetworkStatsWidget(this);
+      this->box->pack(netStats);
+    }
+    this->box = new NetworkStatsWidget(this);
     this->box->showAll();
-    this->box->setAbsCoor2D(300, 40);
+  }
   else
 …
   for(; it != this->nodeList.end(); it++)
+  {
     (*it)->debug(0);
+    (*it)->debug(1);
+  }

trunk/src/lib/network/monitor/network_monitor.h

-                      r9494
+                      r9656
     /** adds to @param node a network node @param pInfo a new client */
     inline void addClient(NetworkNode* node, PeerInfo* pInfo) { node->addClient(pInfo); }
+    inline void addClient(NetworkNode* node, PeerInfo* pInfo) { node->addClient(new NetworkNode(pInfo)); }
     /** adds to @param node a network node @param pInfo a new proxy server */
     inline void addActiveProxyServer(NetworkNode* node, PeerInfo* pInfo) { node->addActiveProxyServer(pInfo); }
+    inline void addActiveProxyServer(NetworkNode* node, PeerInfo* pInfo) { node->addActiveProxyServer(new NetworkNode(pInfo)); }
     /** adds to @param node a network node @param pInfo a new proxy server */
     inline void addPassiveProxyServer(NetworkNode* node, PeerInfo* pInfo) { node->addPassiveProxyServer(pInfo); }
+    inline void addPassiveProxyServer(NetworkNode* node, PeerInfo* pInfo) { node->addPassiveProxyServer(new NetworkNode(pInfo)); }
     /** adds to @param node a network node @param pInfo a new master server*/
     inline void addMasterServer(NetworkNode* node, PeerInfo* pInfo) { node->addMasterServer(pInfo); }
+    inline void addMasterServer(NetworkNode* node, PeerInfo* pInfo) { node->addMasterServer(new NetworkNode(pInfo)); }
+    inline void removeClient(NetworkNode* node, PeerInfo* pInfo) { node->removeClient(pInfo); }
+    inline void removeActiveProxyServer(NetworkNode* node, PeerInfo* pInfo) { node->removeActiveProxyServer(pInfo); }
+    inline void removePassiveProxyServer(NetworkNode* node, PeerInfo* pInfo) { node->removePassiveProxyServer(pInfo); }
+    inline void removeMasterServer(NetworkNode* node, PeerInfo* pInfo) { node->removeMasterServer(pInfo); }
+    void removeNode(PeerInfo* pInfo);
+    void removeNode(NetworkNode* node, PeerInfo* pInfo);
+    inline void removeClient(NetworkNode* node, int userId) { node->removeClient(userId); }
+    inline void removeActiveProxyServer(NetworkNode* node, int userId) { node->removeActiveProxyServer(userId); }
+    inline void removePassiveProxyServer(NetworkNode* node, int userId) { node->removePassiveProxyServer(userId); }
+    inline void removeMasterServer(NetworkNode* node, int userId) { node->removeMasterServer(userId); }
     PeerInfo* getFirstChoiceProxy() const;
 …
     /** @returns the active proxy server list of the localnode */
     inline std::list<PeerInfo*> getActiveProxyServer() const { return this->localNode->getActiveProxyServer(); }
+    inline std::list<NetworkNode*> getActiveProxyServers() const { return this->localNode->getActiveProxyServers(); }
     /* slots admin and info interface */
 …
     inline const std::list<NetworkNode*>& getNodeList() const { return this->nodeList; };
+    PeerInfo* getPeerByUserId( int userId);
+    NetworkNode* getNodeByUserId( int userId);
+    /* forced reconnection interface */
+    inline void setForcedReconnection(IP address) { this->bForcedRecon = true; this->forcedReconnection = address;}
+    inline bool isForcedReconnection() const { return this->bForcedRecon; }
+    inline IP getForcedReconnectionIP() { this->bForcedRecon = false; return this->forcedReconnection; }
     void toggleGUI();
 …
     int                          playerNumber;                 //!< total number of players in the game
     int                          connectionNumber;             //!< total number of connections at this localhost
+    IP                           forcedReconnection;           //!< ip of a forced reconnection
+    bool                         bForcedRecon;                 //!< true if there is a forced recon
 };

trunk/src/lib/network/monitor/network_node.cc

-                      r9494
+                      r9656
 #include "debug.h"
 /**
  * constructor
 …
  * adds a client
  */
 void NetworkNode::addClient(PeerInfo* node)
+void NetworkNode::addClient(NetworkNode* node)
+{
   this->clientList.push_back(node);
 …
  * adds a proxy server
  */
 void NetworkNode::addActiveProxyServer(PeerInfo* node)
+void NetworkNode::addActiveProxyServer(NetworkNode* node)
+{
   this->activeProxyServerList.push_back(node);
 …
  * adds a proxy server
  */
 void NetworkNode::addPassiveProxyServer(PeerInfo* node)
+void NetworkNode::addPassiveProxyServer(NetworkNode* node)
+{
   this->passiveProxyServerList.push_back(node);
 …
  * adds a master server
  */
 void NetworkNode::addMasterServer(PeerInfo* node)
+void NetworkNode::addMasterServer(NetworkNode* node)
+{
   this->masterServerList.push_back(node);
 …
  * removes a client
  */
 void NetworkNode::removeClient(PeerInfo* node)
+{
   std::list<PeerInfo*>::iterator it = this->clientList.begin();
+void NetworkNode::removeClient(NetworkNode* node)
+{
+  std::list<NetworkNode*>::iterator it = this->clientList.begin();
   for(; it != this->clientList.end(); it++)
+  {
 …
  * removes a proxy server
  */
 void NetworkNode::removeActiveProxyServer(PeerInfo* node)
+{
   std::list<PeerInfo*>::iterator it = this->activeProxyServerList.begin();
+void NetworkNode::removeActiveProxyServer(NetworkNode* node)
+{
+  std::list<NetworkNode*>::iterator it = this->activeProxyServerList.begin();
   for(; it != this->activeProxyServerList.end(); it++)
+  {
 …
  * removes a proxy server
  */
 void NetworkNode::removePassiveProxyServer(PeerInfo* node)
+{
   std::list<PeerInfo*>::iterator it = this->passiveProxyServerList.begin();
+void NetworkNode::removePassiveProxyServer(NetworkNode* node)
+{
+  std::list<NetworkNode*>::iterator it = this->passiveProxyServerList.begin();
   for(; it != this->passiveProxyServerList.end(); it++)
+  {
 …
  * removes a master server
  */
 void NetworkNode::removeMasterServer(PeerInfo* node)
+{
   std::list<PeerInfo*>::iterator it = this->masterServerList.begin();
+void NetworkNode::removeMasterServer(NetworkNode* node)
+{
+  std::list<NetworkNode*>::iterator it = this->masterServerList.begin();
   for(; it != this->masterServerList.end(); it++)
+  {
 …
   PRINTF(2)("Could not remove client from the list, very strange...");
+}
+/**
+ * removes a client
+ */
+void NetworkNode::removeClient(int userId)
+{
+  std::list<NetworkNode*>::iterator it = this->clientList.begin();
+  for(; it != this->clientList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+    {
+      this->clientList.erase(it);
+      this->playerNumber--;
+      return;
+    }
+  }
+  PRINTF(2)("Could not remove client from the list, very strange...");
+}
+/**
+ * removes a proxy server
+ */
+void NetworkNode::removeActiveProxyServer(int userId)
+{
+  std::list<NetworkNode*>::iterator it = this->activeProxyServerList.begin();
+  for(; it != this->activeProxyServerList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+    {
+      this->activeProxyServerList.erase(it);
+      this->playerNumber--;
+      return;
+    }
+  }
+  PRINTF(2)("Could not remove proxy server from the list, very strange...");
+}
+/**
+ * removes a proxy server
+ */
+void NetworkNode::removePassiveProxyServer(int userId)
+{
+  std::list<NetworkNode*>::iterator it = this->passiveProxyServerList.begin();
+  for(; it != this->passiveProxyServerList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+    {
+      this->passiveProxyServerList.erase(it);
+      return;
+    }
+  }
+  PRINTF(2)("Could not remove proxy server from the list, very strange...");
+}
+/**
+ * removes a master server
+ */
+void NetworkNode::removeMasterServer(int userId)
+{
+  std::list<NetworkNode*>::iterator it = this->masterServerList.begin();
+  for(; it != this->masterServerList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+    {
+      this->masterServerList.erase(it);
+      this->playerNumber--;
+      return;
+    }
+  }
+  PRINTF(2)("Could not remove client from the list, very strange...");
+}
+/**
+ *  gets the peer info by user id
+ * @param userId  the user id of the node to look up
+ * @return the peer info of this node NULL if nothing found
+ */
+PeerInfo* NetworkNode::getPeerByUserId( int userId)
+{
+  // look through the master server lists
+  std::list<NetworkNode*>::const_iterator it = this->masterServerList.begin();
+  for( ;it != this->masterServerList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+      return (*it)->getPeerInfo();
+  }
+  // look through the active proxy server list
+  it = this->activeProxyServerList.begin();
+  for( ; it != this->activeProxyServerList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+      return (*it)->getPeerInfo();
+  }
+  // look through the passive server list
+  it = this->passiveProxyServerList.begin();
+  for( ; it != this->passiveProxyServerList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+      return (*it)->getPeerInfo();
+  }
+  // look through the client list
+  it = this->clientList.begin();
+  for( ; it != this->clientList.end(); it++)
+  {
+    if( (*it)->getPeerInfo()->userId == userId)
+      return (*it)->getPeerInfo();
+  }
+  return NULL;
+}
 …
 PeerInfo* NetworkNode::getClient(int index) const
+{
   if( this->clientList.size() < index)
+  if( (int)this->clientList.size() < index)
     return NULL;
   std::list<PeerInfo*>::const_iterator it = this->clientList.begin();
+  std::list<NetworkNode*>::const_iterator it = this->clientList.begin();
   for(int i = 0; it != this->clientList.end(); it++, i++)
+  {
   if( i == index)
     return (*it);
+    return (*it)->getPeerInfo();
+  }
 …
 PeerInfo* NetworkNode::getActiveProxyServer(int index) const
+{
   if( this->activeProxyServerList.size() < index)
+  if( (int)this->activeProxyServerList.size() < index)
     return NULL;
   std::list<PeerInfo*>::const_iterator it = this->activeProxyServerList.begin();
+  std::list<NetworkNode*>::const_iterator it = this->activeProxyServerList.begin();
   for(int i = 0; it != this->activeProxyServerList.end(); it++, i++)
+  {
     if( i == index)
       return (*it);
+      return (*it)->getPeerInfo();
+  }
 …
 PeerInfo* NetworkNode::getPassiveProxyServer(int index) const
+{
   if( this->passiveProxyServerList.size() < index)
+  if( (int)this->passiveProxyServerList.size() < index)
     return NULL;
   std::list<PeerInfo*>::const_iterator it = this->passiveProxyServerList.begin();
+  std::list<NetworkNode*>::const_iterator it = this->passiveProxyServerList.begin();
   for(int i = 0; it != this->passiveProxyServerList.end(); it++, i++)
+  {
     if( i == index)
       return (*it);
+      return (*it)->getPeerInfo();
+  }
 …
 PeerInfo* NetworkNode::getMasterServer(int index) const
+{
   if( this->masterServerList.size() < index)
+  if( (int)this->masterServerList.size() < index)
     return NULL;
   std::list<PeerInfo*>::const_iterator it = this->masterServerList.begin();
+  std::list<NetworkNode*>::const_iterator it = this->masterServerList.begin();
   for(int i = 0; it != this->masterServerList.end(); it++, i++)
+  {
     if( i == index)
+      return (*it);
+      return (*it)->getPeerInfo();
+  }
+  return NULL;
+}
+/**
+ * searches for a given NetworkNode
+ * @param userId of the searched node
+ * @returns the PeerInfo of the userId peer
+ */
+NetworkNode* NetworkNode::getNodeByUserId( int userId)
+{
+  if( this->peerInfo->userId == userId)
+    return this;
+  NetworkNode* node = NULL;
+  std::list<NetworkNode*>::const_iterator it = this->masterServerList.begin();
+  for(; it != this->masterServerList.end(); it++)
+  {
+    node = (*it)->getNodeByUserId(userId);
+    if( node != NULL)
+      return node;
+  }
+  it = this->activeProxyServerList.begin();
+  for(; it != this->activeProxyServerList.end(); it++)
+  {
+    node = (*it)->getNodeByUserId(userId);
+    if( node != NULL)
+      return node;
+  }
+  it = this->passiveProxyServerList.begin();
+  for(; it != this->passiveProxyServerList.end(); it++)
+  {
+    node = (*it)->getNodeByUserId(userId);
+    if( node != NULL)
+      return node;
+  }
+  it = this->clientList.begin();
+  for(; it != this->clientList.end(); it++)
+  {
+    node = (*it)->getNodeByUserId(userId);
+    if( node != NULL)
+      return node;
+  }
 …
 void NetworkNode::debug(int depth) const
+{
+  PRINT(0)(" = %s\n", this->peerInfo->getNodeTypeString().c_str());
+  PRINT(0)("    master servers: %i\n", this->masterServerList.size());
+  std::list<PeerInfo*>::const_iterator it = this->masterServerList.begin();
+  for(; it != this->masterServerList.end(); it++)
+  {
+    IP* ip = &(*it)->ip;
+    PRINT(0)("     - ms, id: %i (%s)\n", (*it)->userId, ip->ipString().c_str());
+  }
+  PRINT(0)("    proxy servers active: %i\n", this->activeProxyServerList.size());
+  it = this->activeProxyServerList.begin();
+  for(; it != this->activeProxyServerList.end(); it++)
+  {
+    IP* ip = &(*it)->ip;
+    PRINT(0)("     - ps-a, id: %i (%s)\n", (*it)->userId, ip->ipString().c_str());
+  }
+  PRINT(0)("    proxy servers passive: %i\n", this->passiveProxyServerList.size());
+  it = this->passiveProxyServerList.begin();
+  for(; it != this->passiveProxyServerList.end(); it++)
+  {
+    IP* ip = &(*it)->ip;
+    PRINT(0)("     - ps-p, id: %i (%s)\n", (*it)->userId, ip->ipString().c_str());
+  }
+  PRINT(0)("    clients: %i\n", this->clientList.size());
+  it = this->clientList.begin();
+  for(; it != this->clientList.end(); it++)
+  {
+    IP* ip = &(*it)->ip;
+    PRINT(0)("     - client, id: %i (%s)\n", (*it)->userId, ip->ipString().c_str());
+  }
+}
+  char indent[depth +1];
+  for( int i = 0; i < depth; i++) {     indent[i] = ' ';  }
+  indent[depth] = '\0';
+  PRINT(0)("%s + %s, with id %i and ip: %s\n", indent, this->peerInfo->getNodeTypeString().c_str(), this->peerInfo->userId, this->peerInfo->ip.ipString().c_str());
+  std::list<NetworkNode*>::const_iterator it;
+  if( !this->masterServerList.empty())
+  {
+    it = this->masterServerList.begin();
+    for(; it != this->masterServerList.end(); it++)
+    {
+      (*it)->debug(depth+1);
+    }
+  }
+  if( !this->activeProxyServerList.empty())
+  {
+    it = this->activeProxyServerList.begin();
+    for(; it != this->activeProxyServerList.end(); it++)
+    {
+      (*it)->debug(depth+1);
+    }
+  }
+  if( !this->passiveProxyServerList.empty())
+  {
+    it = this->passiveProxyServerList.begin();
+    for(; it != this->passiveProxyServerList.end(); it++)
+    {
+      (*it)->debug(depth+1);
+    }
+  }
+  if( !this->clientList.empty())
+  {
+    it = this->clientList.begin();
+    for(; it != this->clientList.end(); it++)
+    {
+      (*it)->debug(depth+1);
+    }
+  }
+}

trunk/src/lib/network/monitor/network_node.h

-                      r9494
+                      r9656
 #include <list>
 //!< a class representing a node in the network (this can be a MASTER_SERVER, PROXY_SERVER or a CLIENT
 class NetworkNode
 …
     void addClient(PeerInfo* node);
     void addActiveProxyServer(PeerInfo* node);
     void addPassiveProxyServer(PeerInfo* node);
     void addMasterServer(PeerInfo* node);
+    void addClient(NetworkNode* node);
+    void addActiveProxyServer(NetworkNode* node);
+    void addPassiveProxyServer(NetworkNode* node);
+    void addMasterServer(NetworkNode* node);
+    void removeClient(PeerInfo* node);
+    void removeActiveProxyServer(PeerInfo* node);
+    void removePassiveProxyServer(PeerInfo* node);
+    void removeMasterServer(PeerInfo* node);
+    void removeClient(NetworkNode* node);
+    void removeActiveProxyServer(NetworkNode* node);
+    void removePassiveProxyServer(NetworkNode* node);
+    void removeMasterServer(NetworkNode* node);
+    void removeClient(int userId);
+    void removeActiveProxyServer(int userId);
+    void removePassiveProxyServer(int userId);
+    void removeMasterServer(int userId);
     PeerInfo* getClient(int index) const;
 …
     /** @returns the master server list */
     inline std::list<PeerInfo*> getMasterServer() const { return this->masterServerList; }
+    inline std::list<NetworkNode*> getMasterServers() const { return this->masterServerList; }
     /** @returns the active proxy server list */
     inline std::list<PeerInfo*> getActiveProxyServer() const { return this->activeProxyServerList; }
+    inline std::list<NetworkNode*> getActiveProxyServers() const { return this->activeProxyServerList; }
     /** @returns the passive proxy server list */
     inline std::list<PeerInfo*> getPassiveProxyServer() const { return this->passiveProxyServerList; }
+    inline std::list<NetworkNode*> getPassiveProxyServers() const { return this->passiveProxyServerList; }
     /** @returns the client list */
     inline std::list<PeerInfo*> getClient() const { return this->clientList; }
+    inline std::list<NetworkNode*> getClients() const { return this->clientList; }
+    PeerInfo* getPeerByUserId( int userId);
     /** @returns the number of players */
 …
     /** @returns the peer info of this node */
     inline PeerInfo* getPeerInfo() const { return this->peerInfo; }
+    NetworkNode* getNodeByUserId( int userId);
     void debug(int depth) const;
 …
     /* network nodes directly connected to this node */
     std::list<PeerInfo*>         clientList;                   //!< list of all clients in the network
     std::list<PeerInfo*>         activeProxyServerList;        //!< list of all proxy servers in the network
     std::list<PeerInfo*>         passiveProxyServerList;       //!< list of all proxy servers in the network
     std::list<PeerInfo*>         masterServerList;             //!< list of all master servers in the network (should be 1!! :D)
+    std::list<NetworkNode*>         clientList;                   //!< list of all clients in the network
+    std::list<NetworkNode*>         activeProxyServerList;        //!< list of all proxy servers in the network
+    std::list<NetworkNode*>         passiveProxyServerList;       //!< list of all proxy servers in the network
+    std::list<NetworkNode*>         masterServerList;             //!< list of all master servers in the network (should be 1!! :D)
 };

trunk/src/lib/network/monitor/network_stats_widget.cc

-                      r9494
+                      r9656
 #include "network_stats_widget.h"
 #include "network_monitor.h"
+#include "peer_info.h"
 #include "multi_type.h"
 …
 #include "shell_command.h"
+// SHELL_COMMAND(gui, NetworkMonitor, toggleGUI)
+//  ->setAlias("ProxyGui");
+#include "loading/resource_manager.h"
+// this fcuk does not work!
+// SHELL_COMMAND(gui, NetworkStatsWidget, toggleGUI)
+// ->setAlias("ProxyGui");
 …
     : GLGuiBox(OrxGui::Horizontal)
+{
+  this->init();
   this->setName(name);
   this->setIP(ip);
+}
+HostWidget::HostWidget(const PeerInfo* peerInfo)
+    : GLGuiBox(OrxGui::Horizontal)
+{
+  this->init();
+  if (peerInfo == NULL)
+  {
+    this->setName("INVALID");
+    return;
+  }
+  this->setName(peerInfo->getNodeTypeString() + "ID: " + MultiType(peerInfo->userId).getString());
+  this->setIP(peerInfo->ip);
+}
+void HostWidget::init()
+{
+  if(_font == NULL)
+    _font = new Font(ResourceManager::getInstance()->getDataDir() + "/fonts/arial.ttf", 20);
+  //this->_name.setFont(*_font);
+  this->_name.setTextSize(15);
+  //this->_ip.setFont(*_font);
+  this->_ip.setTextSize(15);
   this->pack(&this->_name);
   this->pack(&this->_ip);
 …
+}
+Font* HostWidget::_font = NULL;
 …
 ProxyWidget::ProxyWidget(const std::string& proxyName, const IP& ip)
+NodeWidget::NodeWidget(const std::string& proxyName, const IP& ip)
     : _proxyWidget(proxyName, ip)
+{
   this->_clientNameWidth = 100.0f;
+  this->_nodeNameWidth = 100.0f;
   this->pack(&_proxyWidget);
+}
+void ProxyWidget::addClient(const std::string& name, const IP& ip)
+NodeWidget::NodeWidget(const NetworkNode* node)
+    : _proxyWidget(node->getPeerInfo())// "node", node->getPeerInfo()->ip)
+{
+  this->_nodeNameWidth = 100.0f;
+  this->pack(&_proxyWidget);
+  std::list<NetworkNode*> list = node->getMasterServers();
+  std::list<NetworkNode*>::const_iterator it;
+  for(it = list.begin(); it != list.end(); it++)
+    this->addNode(*it);
+  list = node->getActiveProxyServers();
+  for(it = list.begin(); it != list.end(); it++)
+    this->addNode(*it);
+  list = node->getPassiveProxyServers();
+  for(it = list.begin(); it != list.end(); it++)
+    this->addNode(*it);
+  list = node->getClients();
+  for(it = list.begin(); it != list.end(); it++)
+    this->addNode(*it);
+}
+void NodeWidget::addNode(const NetworkNode* node)
+{
+  this->_nodes.push_back(new NodeWidget(node));
+  this->pack(this->_nodes.back());
+  this->_nodes.back()->show();
+}
+void NodeWidget::addNode(const std::string& name, const IP& ip)
+{
   HostWidget* newClient = new HostWidget(name, ip);
   newClient->setNameWidth(this->_clientNameWidth);
+  newClient->setNameWidth(this->_nodeNameWidth);
   this->pack(newClient);
 …
+}
 bool ProxyWidget::removeClient(const IP& ip)
+{
   std::vector<HostWidget*>::iterator rmIt;
   for(rmIt = this->_clients.begin(); rmIt != this->_clients.end(); ++rmIt)
+  {
     if (*(*rmIt) == ip)
+    {
       delete (*rmIt);
       this->_clients.erase(rmIt);
       return true;
+    }
+  }
   return false;
+}
 bool ProxyWidget::removeClient(const std::string& name)
+{
   std::vector<HostWidget*>::iterator rmIt;
   for(rmIt = this->_clients.begin(); rmIt != this->_clients.end(); ++rmIt)
+  {
     if (*(*rmIt) == name)
+    {
       delete (*rmIt);
       this->_clients.erase(rmIt);
       return true;
+    }
+  }
   return false;
+}
 bool ProxyWidget::removeClient(const std::string& name, const IP& ip)
+{
   std::vector<HostWidget*>::iterator rmIt;
   for(rmIt = this->_clients.begin(); rmIt != this->_clients.end(); ++rmIt)
+  {
     if (*(*rmIt) == ip && *(*rmIt) == name)
+    {
       delete (*rmIt);
       this->_clients.erase(rmIt);
       return true;
+    }
+  }
   return false;
+}
 void ProxyWidget::setClientNameWidths(float width)
+{
   this->_clientNameWidth = width;
   for (unsigned int i = 0; i < this->_clients.size(); ++i)
     this->_clients[i]->setNameWidth(width);
+}
 void ProxyWidget::hiding()
+bool NodeWidget::removeNode(const IP& ip)
+{
+//   std::vector<HostWidget*>::iterator rmIt;
+//   for(rmIt = this->_nodes.begin(); rmIt != this->_nodes.end(); ++rmIt)
+//   {
+//     if (*(*rmIt) == ip)
+//     {
+//       delete (*rmIt);
+//       this->_nodes.erase(rmIt);
+//       return true;
+//     }
+//   }
+//   return false;
+}
+bool NodeWidget::removeNode(const std::string& name)
+{
+//   std::vector<HostWidget*>::iterator rmIt;
+//   for(rmIt = this->_nodes.begin(); rmIt != this->_nodes.end(); ++rmIt)
+//   {
+//     if (*(*rmIt) == name)
+//     {
+//       delete (*rmIt);
+//       this->_nodes.erase(rmIt);
+//       return true;
+//     }
+//   }
+//   return false;
+}
+bool NodeWidget::removeNode(const std::string& name, const IP& ip)
+{
+//   std::vector<HostWidget*>::iterator rmIt;
+//   for(rmIt = this->_nodes.begin(); rmIt != this->_nodes.end(); ++rmIt)
+//   {
+//     if (*(*rmIt) == ip && *(*rmIt) == name)
+//     {
+//       delete (*rmIt);
+//       this->_nodes.erase(rmIt);
+//       return true;
+//     }
+//   }
+//   return false;
+}
+void NodeWidget::setNodeNameWidths(float width)
+{
+/*  this->_nodeNameWidth = width;
+  for (unsigned int i = 0; i < this->_nodes.size(); ++i)
+    this->_nodes[i]->setNameWidth(width);*/
+}
+void NodeWidget::hiding()
+{
   this->_proxyWidget.hide();
   for (unsigned int i = 0; i < this->_clients.size(); ++i)
     this->_clients[i]->hide();
+}
 void ProxyWidget::showing()
+  for (unsigned int i = 0; i < this->_nodes.size(); ++i)
+    this->_nodes[i]->hide();
+}
+void NodeWidget::showing()
+{
   this->_proxyWidget.show();
   for (unsigned int i = 0; i < this->_clients.size(); ++i)
     this->_clients[i]->show();
+  for (unsigned int i = 0; i < this->_nodes.size(); ++i)
+    this->_nodes[i]->show();
+}
 …
  */
 NetworkStatsWidget::NetworkStatsWidget(const NetworkMonitor* monitor)
     : GLGuiBox(OrxGui::Vertical), _thisHost("myName", IP(127, 0, 0 , 1))
+    : OrxGui::GLGuiFixedpositionBox(OrxGui::Center, OrxGui::Vertical), _thisHost("myName", IP(127, 0, 0 , 1))
+{
   this->_monitor = monitor;
+  this->_passedTime = 0.0f;
   /*
 …
   this->_bar.setChangedValueColor(Color::black);
   */
+  this->_thisHostIs.setText(std::string("I am ") + _monitor->getLocalNode()->getPeerInfo()->getNodeTypeString());
+  this->pack(&this->_thisHostIs);
   this->pack(&this->_thisHost);
+  this->pack(&this->_serverBox);
   this->pack(&this->_upstreamText);
   this->pack(&this->_downstreamText);
+  this->pack(&this->_serverIP);
+  this->rebuild();
+}
 …
 NetworkStatsWidget::~NetworkStatsWidget ()
 {}
+void NetworkStatsWidget::addNode(const NetworkNode* node)
+{
+  this->_proxies.push_back(new NodeWidget(node));
+  this->_serverBox.pack(this->_proxies.back());
+  this->_proxies.back()->show();
+}
+NetworkStatsWidget* NetworkStatsWidget::_statsWidget = NULL;
+#include "class_list.h"
+void NetworkStatsWidget::toggleGUI()
+{
+  BaseObject* bo = NULL;
+  const std::list<BaseObject*>* ls = ClassList::getList(CL_NETWORK_MONITOR);
+  if (ls != NULL && !ls->empty())
+    bo = ls->front();
+  if (bo != NULL && NetworkStatsWidget::_statsWidget == NULL)
+  {
+    NetworkStatsWidget::_statsWidget = new NetworkStatsWidget(dynamic_cast<NetworkMonitor*> (bo));
+    NetworkStatsWidget::_statsWidget->showAll();
+  }
+  else
+  {
+    delete NetworkStatsWidget::_statsWidget;
+    NetworkStatsWidget::_statsWidget = NULL;
+  }
+}
 …
+void NetworkStatsWidget::addProxy(const std::string& name, const IP& proxy)
+{}
+void NetworkStatsWidget::clearProxies()
+{}
+void NetworkStatsWidget::rebuild()
+{
+  while (!this->_proxies.empty())
+  {
+    delete this->_proxies.back();
+    this->_proxies.pop_back();
+  }
+  const NetworkNode* node = this->_monitor->getLocalNode();
+  if (node == NULL)
+  {
+    printf("NO NODE\n");
+    return;
+  }
+  this->addNode(node);
+}
 void NetworkStatsWidget::tick(float dt)
+{
+  if ((_passedTime+= dt) > 1.0f)
+  {
+    this->_passedTime = 0.0f;
+    this->rebuild();
+  }
   assert (this->_monitor->getLocalNode() != NULL);
   assert(this->_monitor->getLocalNode()->getPeerInfo() != NULL);
 …
 void NetworkStatsWidget::resize()
+{
   GLGuiBox::resize();
+  GLGuiFixedpositionBox::resize();
+}

trunk/src/lib/network/monitor/network_stats_widget.h

-                      r9494
+                      r9656
  * @file network_stats_widget.h
  * @brief Definition of an EnergyWidget, that displays a bar and a Text
 */
+ */
 #ifndef _NETWORK_STATS_WIDGET_H
 #define _NETWORK_STATS_WIDGET_H
 #include "glgui_box.h"
+#include "glgui_fixedposition_box.h"
 #include "glgui_bar.h"
 #include "glgui_text.h"
+#include "glgui_pushbutton.h"
 #include "network/ip.h"
 class NetworkMonitor;
+class NetworkNode;
+class PeerInfo;
 class HostWidget : public OrxGui::GLGuiBox
 …
   public:
     HostWidget(const std::string& name, const IP& ip);
     ~HostWidget() {};
+    HostWidget(const PeerInfo* peerInfo);
     void setName(const std::string& name) { this->_name.setText(name); };
     void setIP(const IP& ip) { this->_ip.setText(ip.ipString()); this->_storedIP = ip; };
+    void setIP(const IP& ip) { this->_ip.setText(std::string("at ") + ip.ipString()); this->_storedIP = ip; };
     void setNameWidth(float width) { this->_name.setLineWidth(width); };
 …
   private:
+    void init();
+  private:
     OrxGui::GLGuiText _name;           //!< The Name of the Proxy server to be displayed.
     OrxGui::GLGuiText _ip;             //!< The IP of the proxy server.
     IP                _storedIP;       //!< The ip to compare.
+    static Font*      _font;
 };
 class ProxyWidget : public OrxGui::GLGuiBox
+class NodeWidget : public OrxGui::GLGuiBox
+{
   public:
+    ProxyWidget(const std::string& proxyName, const IP& ip);
+    NodeWidget(const std::string& proxyName, const IP& ip);
+    NodeWidget(const NetworkNode* node);
+    void addClient(const std::string& name, const IP& ip);
+    void addNode(const NetworkNode* node);
+    void addNode(const std::string& name, const IP& ip);
     bool removeClient(const IP& ip);
     bool removeClient(const std::string& name);
     bool removeClient(const std::string& name, const IP& ip);
+    bool removeNode(const IP& ip);
+    bool removeNode(const std::string& name);
+    bool removeNode(const std::string& name, const IP& ip);
     void setClientNameWidths(float width);
+    void setNodeNameWidths(float width);
 …
     HostWidget                _proxyWidget;
     std::vector<HostWidget*>  _clients;
     float                     _clientNameWidth;
+    std::vector<NodeWidget*>  _nodes;
+    float                     _nodeNameWidth;
 };
 …
 //! A class to display network Statistics.
 class NetworkStatsWidget : public OrxGui::GLGuiBox
+class NetworkStatsWidget : public OrxGui::GLGuiFixedpositionBox
+{
   public:
+    static void toggleGUI();
     NetworkStatsWidget(const NetworkMonitor* monitor);
     virtual ~NetworkStatsWidget();
 …
     void addProxy(const std::string& name, const IP& proxy);
+    void addNode(const NetworkNode* node);
+    void clearProxies();
+    void rebuild();
     //void rebuildConnectedHosts(std::vector<hosts> hosts);
 …
     const NetworkMonitor*  _monitor;
+    OrxGui::GLGuiText      _thisHostIs;
     HostWidget             _thisHost;
 …
     OrxGui::GLGuiText      _downstreamText;
     std::vector<HostWidget*>_connectedProxies;
+    OrxGui::GLGuiBox       _serverBox;
     OrxGui::GLGuiText       _serverIP;
+    std::vector<NodeWidget*> _proxies;
+    static NetworkStatsWidget*    _statsWidget;
+    float                   _passedTime;
     //OrxGui::GLGuiText       _valueText;
     //OrxGui::GLGuiBar        _bar;

trunk/src/lib/network/nettypes.h

-                      r9494
+                      r9656
   PERMISSION_MASTER_SERVER = 1,
   PERMISSION_PROXY_SERVER  = 2,
+  PERMISSION_OWNER         = 4,
+  PERMISSION_ALL           = 8
+  PERMISSION_SERVER        = 4,
+  PERMISSION_OWNER         = 8,
+  PERMISSION_ALL           = 16
 };

trunk/src/lib/network/network_game_manager.cc

-                      r9494
+                      r9656
   this->gameState = 0;
   registerVar( new SynchronizeableInt( &gameState, &gameState, "gameState" ) );
+  registerVar( new SynchronizeableInt( &gameState, &gameState, "gameState", PERMISSION_MASTER_SERVER ) );
+}
 …
 bool NetworkGameManager::signalNewPlayer( int userId )
+{
   assert( SharedNetworkData::getInstance()->isMasterServer() ||  SharedNetworkData::getInstance()->isProxyServerActive());
+  assert( SharedNetworkData::getInstance()->isMasterServer());
   assert( State::getGameRules() );
   assert( State::getGameRules()->isA( CL_NETWORK_GAME_RULES ) );
 …
   NetworkGameRules & rules = *(dynamic_cast<NetworkGameRules*>(State::getGameRules()));
   int team = rules.getTeamForNewUser();
   ClassID playableClassId = rules.getPlayableClassId( userId, team );
   std::string playableModel = rules.getPlayableModelFileName( userId, team, playableClassId );
   std::string playableTexture = rules.getPlayableModelFileName( userId, team, playableClassId );
   float       playableScale = rules.getPlayableScale( userId, team, playableClassId );
+  int          team = rules.getTeamForNewUser();
+  ClassID      playableClassId = rules.getPlayableClassId( userId, team );
+  std::string  playableModel = rules.getPlayableModelFileName( userId, team, playableClassId );
+  std::string  playableTexture = rules.getPlayableModelFileName( userId, team, playableClassId );
+  float        playableScale = rules.getPlayableScale( userId, team, playableClassId );
   BaseObject * bo = Factory::fabricate( playableClassId );
 …
   playable.loadMD2Texture( playableTexture );
+  playable.setTeam(team);
   playable.loadModel( playableModel, 100.0f );
   playable.setOwner( userId );
 …
 /**
  * handler for remove synchronizeable messages
  * @param messageId
+ * @param messageType
  * @param data
  * @param dataLength
 …
  * @return true on successfull handling else handler will be called again
  */
 bool NetworkGameManager::delSynchronizeableHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+bool NetworkGameManager::delSynchronizeableHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
+{
 …
   if ( SharedNetworkData::getInstance()->isMasterServer() ||
        SharedNetworkData::getInstance()->isProxyServerActive() && SharedNetworkData::getInstance()->isUserClient(userId))
+  {
     PRINTF(0)("Recieved DeleteSynchronizeable message from client %d!\n", userId);
+       SharedNetworkData::getInstance()->isProxyServerActive() && SharedNetworkData::getInstance()->isUserClient(senderId))
+  {
+    PRINTF(0)("Recieved DeleteSynchronizeable message from client %d!\n", senderId);
     return true;
+  }
 …
   if ( len != dataLength )
+  {
     PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, userId);
+    PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, senderId);
     return true;
+  }
 …
   assert( Converter::intToByteArray( uniqueId, buf, INTSIZE ) == INTSIZE );
   MessageManager::getInstance()->sendMessage( MSGID_DELETESYNCHRONIZEABLE, buf, INTSIZE, RT_ALL_BUT_ME, 0, MP_HIGHBANDWIDTH );
+  MessageManager::getInstance()->sendMessage( MSGID_DELETESYNCHRONIZEABLE, buf, INTSIZE, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
+}
 …
 /**
  * handler for MSGID_PREFEREDTEAM message
  * @param messageId
+ * @param messageType
  * @param data
  * @param dataLength
 …
  * @return
  */
 bool NetworkGameManager::preferedTeamHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+{
   assert( SharedNetworkData::getInstance()->isMasterServer() ||  SharedNetworkData::getInstance()->isProxyServerActive());
+bool NetworkGameManager::preferedTeamHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
+{
+  assert( SharedNetworkData::getInstance()->isMasterServer() );
   int teamId = 0;
 …
   if ( len != dataLength )
+  {
     PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, userId);
+    PRINTF(2)("Recieved DeleteSynchronizeable message with incorrect size (%d) from client %d!\n", dataLength, senderId);
     return true;
+  }
+  NetworkGameManager::getInstance()->setPreferedTeam( userId, teamId );
+  return true;
+}
+  PRINTF(0)("Client %i wishes to play in team %i\n", senderId, teamId);
+  NetworkGameManager::getInstance()->setPreferedTeam( senderId, teamId );
+  return true;
+}
+/**
+ * this actualy sets the new prefered team id
+ * @param userId: the user that changes team
+ * @param teamId: the new team id for the user
+ */
 void NetworkGameManager::setPreferedTeam( int userId, int teamId )
+{
 …
+}
 /**
  * set prefered team for this host
 …
 void NetworkGameManager::prefereTeam( int teamId )
+{
   if ( SharedNetworkData::getInstance()->isMasterServer() /*|| SharedNetworkData::getInstance()->isProxyServerActive()*/)
     setPreferedTeam( SharedNetworkData::getInstance()->getHostID(), teamId );
+  if ( SharedNetworkData::getInstance()->isMasterServer() )
+    this->setPreferedTeam( SharedNetworkData::getInstance()->getHostID(), teamId );
   else
+  {
 …
     assert( Converter::intToByteArray( teamId, buf, INTSIZE) == INTSIZE );
+    MessageManager::getInstance()->sendMessage( MSGID_PREFEREDTEAM, buf, INTSIZE, RT_USER, 0, MP_HIGHBANDWIDTH );
+    // send this message to the master server
+    MessageManager::getInstance()->sendMessage( MSGID_PREFEREDTEAM, buf, INTSIZE, RT_USER, NET_ID_MASTER_SERVER, MP_HIGHBANDWIDTH );
+  }
+}
 …
 bool NetworkGameManager::chatMessageHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+{
   PRINTF(0)("NetworkGameManager::chatMessageHandler %d %d\n", userId, SharedNetworkData::getInstance()->getHostID() );
   if ( (SharedNetworkData::getInstance()->isMasterServer() /*|| SharedNetworkData::getInstance()->isProxyServerActive()*/) && userId !=  SharedNetworkData::getInstance()->getHostID() )
+  {
     MessageManager::getInstance()->sendMessage( messageId, data, dataLength, RT_ALL_BUT_ME, 0, MP_HIGHBANDWIDTH );
+bool NetworkGameManager::chatMessageHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
+{
+  PRINTF(0)("NetworkGameManager::chatMessageHandler %d %d\n", senderId, SharedNetworkData::getInstance()->getHostID() );
+  if ( (SharedNetworkData::getInstance()->isMasterServer() /*|| SharedNetworkData::getInstance()->isProxyServerActive()*/) && senderId !=  SharedNetworkData::getInstance()->getHostID() )
+  {
+    MessageManager::getInstance()->sendMessage( messageType, data, dataLength, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
+  }
 …
   if ( dataLength < 3*INTSIZE )
+  {
     PRINTF(2)("got too small chatmessage from client %d\n", userId);
+    PRINTF(2)("got too small chatmessage from client %d\n", senderId);
     return true;
+  }
   int messageType = 0;
   Converter::byteArrayToInt( data, &messageType );
+  int chatType = 0;
+  Converter::byteArrayToInt( data, &chatType);
   int senderUserId = 0;
   Converter::byteArrayToInt( data+INTSIZE, &senderUserId );
 …
   Converter::byteArrayToString( data+2*INTSIZE, message, dataLength-2*INTSIZE );
   rules.handleChatMessage( senderUserId, message, messageType );
+  rules.handleChatMessage( senderUserId, message, chatType);
   return true;
 …
   if ( SharedNetworkData::getInstance()->isMasterServer() /*|| SharedNetworkData::getInstance()->isProxyServerActive()*/)
     MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_ME, 0, MP_HIGHBANDWIDTH );
+    MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
   else
     MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_BUT_ME, 0, MP_HIGHBANDWIDTH );
+    MessageManager::getInstance()->sendMessage( MSGID_CHATMESSAGE, buf, message.length()+3*INTSIZE, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );

trunk/src/lib/network/network_game_manager.h

-                      r9406
+                      r9656
 class PNode;
-typedef enum NetworkGameManagerProtocol {
-  NET_CREATE_ENTITY = 0,
-  NET_REMOVE_ENTITY,
-  NET_CREATE_ENTITY_LIST,
-  NET_REMOVE_ENTITY_LIST,
-  NET_REQUEST_CREATE,
-  NET_REQUEST_REMOVE,
-  NET_YOU_ARE_ENTITY,
-  NET_REQUEST_ENTITY_LIST,
-  NET_NUMBER
-};
 struct clientBuffer
 …
     NetworkGameManager();
     static bool delSynchronizeableHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
     static bool preferedTeamHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
     static bool chatMessageHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
+    static bool delSynchronizeableHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  );
+    static bool preferedTeamHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  );
+    static bool chatMessageHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  );
     void setPreferedTeam( int userId, int teamId );

trunk/src/lib/network/network_manager.cc

-                      r9494
+                      r9656
 #include "network_log.h"
 #include "network_game_manager.h"
+#include "proxy/proxy_control.h"
 …
 SHELL_COMMAND(debug, NetworkManager, debug);
+SHELL_COMMAND(redirTest, NetworkManager, setRedirectionTest);
 …
   // create the network stream
   this->networkStream = new NetworkStream(NET_MASTER_SERVER);
   this->networkStream->createServer( port, port + 1);
+  this->networkStream->createServer( port, port + 1, port + 2);
   // start the network game manager
   this->networkStream->createNetworkGameManager();
+  // init the proxy control center
+  ProxyControl::getInstance();
   PRINTF(0)("Created Network Master Server\n");
 …
   // then start the server
+  this->networkStream->createServer( port, port +1);
+  this->networkStream->createServer( port, port + 1, port + 2);
   // and to the other proxy servers also, this would be very nice if its works
+  // start the network game manager
+  //this->networkStream->createNetworkGameManager();
+  /* put it here....*/
+  // init the proxy control center
+  ProxyControl::getInstance();
   PRINTF(0)("Created Network Proxy Server\n");
 …
   this->networkStream->connectToMasterServer( name, port);
   // and start the handshake
   this->networkStream->startHandshake();
+  // create the proxy control
+  ProxyControl::getInstance();
   PRINTF(0)("Created Network Client\n");
   return 1;
+}
+/**
+ * reconnects this client to another server
+ * @param address new server address
+ */
+void NetworkManager::reconnectToServer(IP address)
+{
+  PRINTF(0)("Rec. reconnection command\n");
+  this->networkStream->reconnectToServer(address);
+}
 …
   PRINT(0)("===========================================\n");
+}
+void NetworkManager::setRedirectionTest()
+{
+  this->networkStream->setRedirectionTest();
+}

trunk/src/lib/network/network_manager.h

-                      r9494
+                      r9656
     int createProxyServer( unsigned int port);
+    void reconnectToServer(IP address);
     void connectSynchronizeable(Synchronizeable& sync);
     void synchronize(float dtS);
     void debug();
+    void setRedirectionTest();

trunk/src/lib/network/network_stream.cc

-                      r9494
+                      r9656
 ### File Specific:
    main-programmer: Christoph Renner rennerc@ee.ethz.ch
    co-programmer:   Patrick Boenzli  boenzlip@orxonox.ethz.ch
+   co-programmer:   Patrick Boenzli  patrick@orxonox.ethz.ch
      June 2006: finishing work on the network stream for pps presentation (rennerc@ee.ethz.ch)
      July 2006: some code rearangement and integration of the proxy server mechanism (boenzlip@ee.ethz.ch)
+     July 2006: some code rearangement and integration of the proxy server mechanism (patrick@orxonox.ethz.ch)
 */
 …
 #define DEBUG_MODULE_NETWORK
+#include "proxy/proxy_control.h"
 #include "base_object.h"
 …
       // init the shared network data
       SharedNetworkData::getInstance()->setHostID(NET_ID_MASTER_SERVER);
+      this->pInfo->userId = NET_ID_MASTER_SERVER;
+      this->pInfo->nodeType = NET_MASTER_SERVER;
       break;
     case NET_PROXY_SERVER_ACTIVE:
       // init the shared network data
       SharedNetworkData::getInstance()->setHostID(NET_ID_PROXY_SERVER_01);
+      this->pInfo->nodeType = NET_PROXY_SERVER_ACTIVE;
       break;
     case NET_PROXY_SERVER_PASSIVE:
       // init the shared network data
       SharedNetworkData::getInstance()->setHostID(NET_ID_PROXY_SERVER_01);
+      this->pInfo->nodeType = NET_PROXY_SERVER_PASSIVE;
       break;
     case NET_CLIENT:
       SharedNetworkData::getInstance()->setHostID(NET_ID_UNASSIGNED);
+      this->pInfo->nodeType = NET_CLIENT;
       break;
+  }
 …
   // get the local ip address
+  IPaddress ip;
+  SDLNet_ResolveHost( &ip, NULL, 0);
+  IP ip("localhost", 0);
   this->pInfo->ip = ip;
+}
 …
   this->setClassID(CL_NETWORK_STREAM, "NetworkStream");
   this->clientSocket = NULL;
+  this->clientSoftSocket = NULL;
   this->proxySocket = NULL;
   this->networkGameManager = NULL;
 …
   this->pInfo = new PeerInfo();
   this->pInfo->userId = 0;
+  this->pInfo->userId = NET_UID_UNASSIGNED;
   this->pInfo->lastAckedState = 0;
   this->pInfo->lastRecvedState = 0;
+  this->pInfo->bLocal = true;
   this->bRedirect = false;
   this->currentState = 0;
+  this->redirectionUID = NET_ID_MASTER_SERVER;
   remainingBytesToWriteToDict = Preferences::getInstance()->getInt( "compression", "writedict", 0 );
 …
   if ( this->clientSocket )
+  {
+    clientSocket->close();
+    delete clientSocket;
+    clientSocket = NULL;
+    this->clientSocket->close();
+    delete this->clientSocket;
+    this->clientSocket = NULL;
+  }
+  if ( this->clientSoftSocket )
+  {
+    this->clientSoftSocket->close();
+    delete this->clientSoftSocket;
+    this->clientSoftSocket = NULL;
+  }
   if ( this->proxySocket)
 …
   this->peers[node].connectionMonitor = new ConnectionMonitor( NET_ID_MASTER_SERVER );
   this->peers[node].ip = this->peers[node].socket->getRemoteAddress();
+  this->peers[node].bLocal = true;
+}
 …
   this->peers[proxyId].connectionMonitor = new ConnectionMonitor( proxyId );
   this->peers[proxyId].ip = this->peers[proxyId].socket->getRemoteAddress();
+  this->peers[proxyId].bLocal = true;
+}
 …
  * @param port: interface port for all clients
  */
 void NetworkStream::createServer(int clientPort, int proxyPort)
+void NetworkStream::createServer(int clientPort, int proxyPort, int clientSoftPort)
+{
   PRINTF(0)(" Creating new Server: listening for clients on port %i and for proxies on port %i", clientPort, proxyPort);
   this->clientSocket= new UdpServerSocket(clientPort);
+  this->clientSoftSocket= new UdpServerSocket(clientSoftPort);
   this->proxySocket = new UdpServerSocket(proxyPort);
+}
 …
   Handshake* hs = new Handshake(this->pInfo->nodeType);
   // fake the unique id
+  hs->setUniqueID( NET_UID_HANDSHAKE );
+  assert( peers[userId].handshake == NULL );
+  peers[userId].handshake = hs;
+  hs->setUniqueID( userId);
+  assert( this->peers[userId].handshake == NULL );
+  this->peers[userId].handshake = hs;
+  this->peers[userId].bLocal = true;
   // set the preferred nick name
 …
   // create the network monitor after all the init work and before there is any connection handlings
   if( this->networkMonitor == NULL)
+  {
     this->networkMonitor = new NetworkMonitor(this);
+    SharedNetworkData::getInstance()->setNetworkMonitor( this->networkMonitor);
+  }
 …
     if ( this->clientSocket )
       this->clientSocket->update();
+    if ( this->clientSoftSocket)
+      this->clientSoftSocket->update();
     if( this->proxySocket)
       this->proxySocket->update();
 …
     if ( this->clientSocket )
       this->clientSocket->update();
+    if ( this->clientSoftSocket)
+      this->clientSoftSocket->update();
     if( this->proxySocket)
       this->proxySocket->update();
 …
     if( this->bRedirect)
+    {
       this->handleReconnect( NET_ID_MASTER_SERVER);
+      this->handleReconnect( this->redirectionUID);
+    }
+  }
 …
   this->handleDownstream( tick );
   this->handleUpstream( tick );
+  // process the local data of the message manager
+  MessageManager::getInstance()->processData();
+  if( this->bSoftRedirect)
+    this->softReconnectToServer(0, IP("localhost", 10001));
+}
 …
     if ( tempNetworkSocket )
+    {
+      // determine the network node id
+      if ( freeSocketSlots.size() > 0 )
+      // get a userId
+//       if ( freeSocketSlots.size() > 0 )
+//       {
+//         // this should never be called
+//         userId = freeSocketSlots.back();
+//         freeSocketSlots.pop_back();
+//       }
+//       else
+      {
+        userId = freeSocketSlots.back();
+        freeSocketSlots.pop_back();
+      }
+      else
+      {
+        userId = 1;
+        // each server (proxy and master) have an address space for new network nodes of 1000 nodes
+        // the first NET_ID_PROXY_MAX are always reserved for proxy servers
+        userId = SharedNetworkData::getInstance()->getHostID() * 1000 + NET_ID_PROXY_MAX + 1;
         for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
           if ( it->first >= userId )
             userId = it->first + 1;
+        // make sure that this server only uses an address space of 1000
+        assert( userId < (SharedNetworkData::getInstance()->getHostID() + 1) * 1000);
+      }
       // this creates a new entry in the peers list
 …
+  }
+  if( this->clientSoftSocket != NULL)
+  {
+    tempNetworkSocket = this->clientSoftSocket->getNewSocket();
+    // we got new NET_CLIENT connecting
+    if ( tempNetworkSocket )
+    {
+      // this creates a new entry in the peers list
+      peers[userId].socket = tempNetworkSocket;
+      peers[userId].nodeType = NET_CLIENT;
+      // handle the newly connected client
+      this->handleSoftConnect(userId);
+      PRINTF(0)("New Client softly connected: %d :D\n", userId);
+    }
+  }
   if( this->proxySocket != NULL)
 …
+    {
       // determine the network node id
       if ( freeSocketSlots.size() > 0 )
+      {
         userId = freeSocketSlots.back();
         freeSocketSlots.pop_back();
+      }
       else
+//       if ( freeSocketSlots.size() > 0 )
+//       {
+//         userId = freeSocketSlots.back();
+//         freeSocketSlots.pop_back();
+//       }
+//       else
+      {
         userId = 1;
+        for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+          if ( it->first >= userId )
+            userId = it->first + 1;
+        // find an empty slot within the range
+        for( int i = 0; i < NET_ID_PROXY_MAX; i++)
+        {
+          if( this->peers.find( i) == this->peers.end())
+          {
+            userId = i;
+            break;
+          }
+        }
+//         for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+//           if ( it->first >= userId )
+//             userId = it->first + 1;
+      }
 …
+    }
+  }
 …
       PRINTF(0)("Client is gone: %d (%s)\n", it->second.userId, reason.c_str());
       this->handleDisconnect( it->second.userId);
+      if( SharedNetworkData::getInstance()->isProxyServerActive())
+        ProxyControl::getInstance()->signalLeaveClient(it->second.userId);
       it++;
 …
     it++;
+  }
+}
 …
+{
   // create new handshake and init its variables
+  peers[userId].handshake = new Handshake(this->pInfo->nodeType, userId, this->networkGameManager->getUniqueID(), MessageManager::getInstance()->getUniqueID());
+  peers[userId].handshake->setUniqueID(userId);
+  peers[userId].connectionMonitor = new ConnectionMonitor( userId );
+  peers[userId].userId = userId;
+  this->peers[userId].handshake = new Handshake(this->pInfo->nodeType, userId, this->networkGameManager->getUniqueID(), MessageManager::getInstance()->getUniqueID());
+  this->peers[userId].handshake->setUniqueID(userId);
+  this->peers[userId].connectionMonitor = new ConnectionMonitor( userId );
+  this->peers[userId].userId = userId;
+  this->peers[userId].bLocal = true;
   PRINTF(0)("num sync: %d\n", synchronizeables.size());
 …
   if( pi != NULL)
+  {
     peers[userId].handshake->setProxy1Address( pi->ip);
+    this->peers[userId].handshake->setProxy1Address( pi->ip);
+  }
   pi = this->networkMonitor->getSecondChoiceProxy();
   if( pi != NULL)
     peers[userId].handshake->setProxy2Address( pi->ip);
+    this->peers[userId].handshake->setProxy2Address( pi->ip);
   // check if the connecting client should reconnect to a proxy server
   if( SharedNetworkData::getInstance()->isMasterServer())
+    peers[userId].handshake->setRedirect(/*this->networkMonitor->isReconnectNextClient()*/false);
+  {
+    if( this->networkMonitor->isReconnectNextClient())
+    {
+      this->peers[userId].handshake->setRedirect(true);
+      PRINTF(0)("forwarding client to proxy server because this server is saturated\n");
+    }
+  }
   // the connecting node of course is a client
+  peers[userId].ip = peers[userId].socket->getRemoteAddress();
+}
+  this->peers[userId].ip = this->peers[userId].socket->getRemoteAddress();
+}
+/**
+ * this handles new soft connections
+ * @param userId: the id of the new user node
+ *
+ * soft connections are connections from clients that are already in the network and don't need a new handshake etc.
+ * the state of all entitites owned by userId are not deleted and stay
+ * soft connections can not be redirected therefore they are negotiated between the to parties
+ */
+void NetworkStream::handleSoftConnect( int userId)
+{
+  // create new handshake and init its variables
+  this->peers[userId].handshake = NULL;
+  this->peers[userId].handshake->setUniqueID(userId);
+  this->peers[userId].connectionMonitor = new ConnectionMonitor( userId );
+  this->peers[userId].userId = userId;
+  this->peers[userId].bLocal = true;
+  PRINTF(0)("num sync: %d\n", synchronizeables.size());
+  // the connecting node of course is a client
+  this->peers[userId].ip = this->peers[userId].socket->getRemoteAddress();
+}
 …
     PRINT(0)(" Host ist Client with ID: %i\n", this->pInfo->userId);
+  }
+  PRINT(0)(" Current number of connections is: %i\n", this->peers.size());
+  for ( PeerList::iterator it = peers.begin(); it != peers.end(); it++ )
+  {
+    PRINT(0)("  peers[%i] with uniqueId %i and address: %s\n", it->first, it->second.userId, it->second.ip.ipString().c_str());
+  }
+  PRINT(0)("\n\n");
   PRINT(0)(" Got %i connected Synchronizeables, showing active Syncs:\n", this->synchronizeables.size());
 …
             // - client       <==> master server
             // - proxy server <==> master server
+            if(  SharedNetworkData::getInstance()->isClient() || SharedNetworkData::getInstance()->isProxyServerActive() && it->second.isMasterServer())
+            if(  SharedNetworkData::getInstance()->isClient() ||
+                 SharedNetworkData::getInstance()->isProxyServerActive() &&
+                 SharedNetworkData::getInstance()->isUserMasterServer(it->second.userId))
+            {
               PRINTF(0)("Handshake: i am in client role\n");
+              PRINTF(4)("Handshake: i am in client role\n");
               SharedNetworkData::getInstance()->setHostID( it->second.handshake->getHostId() );
               this->pInfo->userId = SharedNetworkData::getInstance()->getHostID();
-#warning the ip address is not set here because it results in a segfault when connecting to a proxy server => trace this later
 //               it->second.ip = it->second.socket->getRemoteAddress();
               // it->second.nodeType = it->second.handshake->getRemoteNodeType();
+              it->second.nodeType = it->second.handshake->getRemoteNodeType();
               // it->second.ip = it->second.socket->getRemoteAddress();
               // add the new server to the nodes list (it can be a NET_MASTER_SERVER or NET_PROXY_SERVER)
 …
               else if ( SharedNetworkData::getInstance()->isProxyServerActive() && it->second.isClient() )
+              {
                 PRINTF(0)("Handshake: i am in server role\n");
+                PRINTF(4)("Handshake: Proxy in server role: connecting %i\n", it->second.userId);
                 it->second.ip = it->second.socket->getRemoteAddress();
 …
                 this->networkMonitor->addNode(&it->second);
+                this->handleNewClient( it->second.userId );
+                // work with the ProxyControl to init the new client
+                ProxyControl::getInstance()->signalNewClient( it->second.userId);
                 if ( PlayerStats::getStats( it->second.userId ) && it->second.handshake->getPreferedNickName() != "" )
 …
 /**
  * this functions handles a reconnect event received from the a NET_MASTER_SERVER or NET_PROXY_SERVER
+ * @param userId
  */
 void NetworkStream::handleReconnect(int userId)
+{
   this->bRedirect = false;
+#warning this peer will be created if it does not yet exist: dangerous
   PeerInfo* pInfo = &this->peers[userId];
+  IP proxyIP;
+  if( this->networkMonitor->isForcedReconnection())
+    proxyIP = this->networkMonitor->getForcedReconnectionIP();
+  else
+    proxyIP = pInfo->handshake->getProxy1Address();
   PRINTF(0)("===============================================\n");
   PRINTF(0)("Client is redirected to the other proxy servers\n");
   PRINTF(0)("  user id: %i\n", userId);
   PRINTF(0)("  connecting to: %s\n", this->networkMonitor->getFirstChoiceProxy()->ip.ipString().c_str());
+  PRINTF(0)("  connecting to: %s\n", proxyIP.ipString().c_str());
   PRINTF(0)("===============================================\n");
 …
   pInfo->lastRecvedState = 0;
-  // temp save the ip address here
-  IP proxyIP = pInfo->handshake->getProxy1Address();
   // disconnect from the current server and reconnect to proxy server
   this->handleDisconnect( userId);
   this->connectToProxyServer(NET_ID_PROXY_SERVER_01, proxyIP.ipString(), 9999);
+//   this->connectToMasterServer(proxyIP.ipString(), 9999);
   #warning the ports are not yet integrated correctly in the ip class
 …
+/**
+ * reconnects to another server, with full handshake
+ * @param address of the new server
+ */
+void NetworkStream::reconnectToServer(IP address)
+{
+  ///TODO make a redirection struct and push it to the network monitor
+  this->networkMonitor->setForcedReconnection(address);
+  // reconnect (depending on how we are connected at the moment)
+  if ( peers.find( NET_ID_MASTER_SERVER) != peers.end() )
+    this->redirectionUID = NET_ID_MASTER_SERVER;
+  else if( peers.find( NET_ID_PROXY_SERVER_01) != peers.end() )
+    this->redirectionUID = NET_ID_PROXY_SERVER_01;
+  this->bRedirect = true;
+}
+/**
+ * softly reconnecting to another server
+ * @param serverUserId the id of the client
+ * @param address  of the new server
+ */
+void NetworkStream::softReconnectToServer(int serverUserId, IP address)
+{
+//   this->networkMonitor->setForcedReconnection(address);
+//   this->handleReconnect( NET_ID_MASTER_SERVER);
+  // create the new udp socket and open the connection to the soft connection port
+  NetworkSocket* newSocket = new UdpSocket(address.ipString(), 10001);
+  // delete the synchronization state of this client for all syncs
+  for ( SynchronizeableList::iterator it2 = synchronizeables.begin(); it2 != synchronizeables.end(); it2++ )  {
+    (*it2)->cleanUpUser( serverUserId );
+  }
+  // temp save the old socket
+  NetworkSocket* oldSocket = this->peers[serverUserId].socket;
+  // now integrate the new socket
+  this->peers[serverUserId].socket = newSocket;
+  this->bSoftRedirect = false;
+  return;
+  // now remove the old socket
+  oldSocket->disconnectServer();
+  delete oldSocket;
+  // replace the old connection monitor
+  if ( this->peers[serverUserId].connectionMonitor )
+    delete this->peers[serverUserId].connectionMonitor;
+  this->peers[serverUserId].connectionMonitor = new ConnectionMonitor(serverUserId);
+  // remove old node from the network monitor
+  this->networkMonitor->removeNode(&this->peers[serverUserId]);
+}
+/**
+ * prepares a soft connection for a client to connect to
+ * @param userId that will connect to this server
+ */
+void NetworkStream::prepareSoftConnection(int userId)
+{
+  PRINTF(0)("prepare soft connection for userId %i\n");
+}
 /**
  * handles the disconnect event
 …
 void NetworkStream::handleDisconnect( int userId )
+{
   peers[userId].socket->disconnectServer();
   delete peers[userId].socket;
   peers[userId].socket = NULL;
   if ( peers[userId].handshake )
     delete peers[userId].handshake;
   peers[userId].handshake = NULL;
   if ( peers[userId].connectionMonitor )
     delete peers[userId].connectionMonitor;
   peers[userId].connectionMonitor = NULL;
+  this->peers[userId].socket->disconnectServer();
+  delete this->peers[userId].socket;
+  this->peers[userId].socket = NULL;
+  if ( this->peers[userId].handshake )
+    delete this->peers[userId].handshake;
+  this->peers[userId].handshake = NULL;
+  if ( this->peers[userId].connectionMonitor )
+    delete this->peers[userId].connectionMonitor;
+  this->peers[userId].connectionMonitor = NULL;
+  // delete the synchronization state of this client for all syncs
   for ( SynchronizeableList::iterator it2 = synchronizeables.begin(); it2 != synchronizeables.end(); it2++ )  {
     (*it2)->cleanUpUser( userId );
 …
   this->freeSocketSlots.push_back( userId );
   peers.erase( userId);
+}
+  this->networkMonitor->removeNode(&this->peers[userId]);
+  this->peers.erase( userId);
+}
 …
       assert( offset + INTSIZE <= UDP_PACKET_SIZE );
       // server fakes uniqueid == 0 for handshake
+      // server fakes uniqueid == 0 for handshake synchronizeable
       if ( ( SharedNetworkData::getInstance()->isMasterServer() ||
              SharedNetworkData::getInstance()->isProxyServerActive() &&  peer->second.isClient() ) &&
              sync.getUniqueID() <= SharedNetworkData::getInstance()->getMaxPlayer() + 1) // plus one to handle one client more than the max to redirect it
+             ( sync.getUniqueID() >= 1000 || sync.getUniqueID() <= SharedNetworkData::getInstance()->getMaxPlayer() + 1 + NET_ID_PROXY_MAX))
         n = Converter::intToByteArray( 0, buf + offset, UDP_PACKET_SIZE - offset );
       else
 …
       while ( offset + 2 * INTSIZE < length )
+      {
+        // read the unique id of the sync
         assert( offset > 0 );
         assert( Converter::byteArrayToInt( buf + offset, &uniqueId ) == INTSIZE );
         offset += INTSIZE;
+        // read the data length
         assert( Converter::byteArrayToInt( buf + offset, &syncDataLength ) == INTSIZE );
         offset += INTSIZE;
 …
         for ( SynchronizeableList::iterator it = synchronizeables.begin(); it != synchronizeables.end(); it++ )
+        {
+          // client thinks his handshake has id 0!!!!!
+          if ( (*it)->getUniqueID() == uniqueId || ( uniqueId == 0 && (*it)->getUniqueID() == peer->second.userId ) )
+          // client thinks his handshake has a special id: hostId * 1000 (host id of this server)
+          if ( (*it)->getUniqueID() == uniqueId ||                                          // so this client exists already go to sync work
+                 ( uniqueId == 0  && (*it)->getUniqueID() == peer->second.userId ) )        // so this is a Handshake!
+          {
             sync = *it;

trunk/src/lib/network/network_stream.h

-                      r9494
+                      r9656
     void init();
+    /* network interface controls */
     void connectToMasterServer(std::string host, int port);
     void connectToProxyServer(int proxyId, std::string host, int port);
     void createServer(int clientPort, int proxyPort);
+    void createServer(int clientPort, int proxyPort, int clientSoftPort);
     void createNetworkGameManager();
     void startHandshake(int userId = NET_ID_MASTER_SERVER);
+    void reconnectToServer(IP address);
+    void softReconnectToServer(int serverUserId, IP address);
+    void prepareSoftConnection(int userId);
     /* synchronizeable interface */
 …
     inline PeerInfo* getPeerInfo() { return this->pInfo; }
     inline PeerList getPeerInfoList() { return this->peers; }
+    inline void setRedirectionTest() { this->bSoftRedirect = true; }
     /* data processing*/
 …
     void handleConnect( int userId);
+    void handleSoftConnect( int userId);
     void handleReconnect( int userId );
     void handleDisconnect( int userId );
+    void handleSoftDisconnect( int userId);
     void writeToNewDict( byte * data, int length, bool upstream );
 …
     NetworkMonitor*            networkMonitor;              //!< the network monitor
     NetworkGameManager*        networkGameManager;          //!< reference to the network game manager
+    ServerSocket*              clientSocket;                //!< the listening socket of the server
+    ServerSocket*              clientSocket;                //!< the listening socket for clients of the server
+    ServerSocket*              clientSoftSocket;            //!< the listening socket for soft connections to the server
     ServerSocket*              proxySocket;                 //!< socket for proxy connections
 …
     bool                       bRedirect;                   //!< true if the master server sent a redirect command
+    int                        redirectionUID;              //!< uid of the redir host
+    bool                       bSoftRedirect;               //!< tsting
 };
 #endif /* _NETWORK_STREAM */

trunk/src/lib/network/peer_info.cc

-                      r9494
+                      r9656
 void PeerInfo::clear()
+{
   this->userId = 0;
   this->nodeType = NET_CLIENT;
+  this->userId = NET_ID_UNASSIGNED;
+  this->nodeType = NET_UNASSIGNED;
   this->socket = NULL;
   this->handshake = NULL;
 …
   this->lastRecvedState = 0;
   this->connectionMonitor = NULL;
+  this->bLocal = false;
   this->ip = IP(0,0);
 …
 const std::string PeerInfo::nodeNames[] =
+{
+  "maser server",
+  "master server",
   "proxy server active",
   "proxy server passive",

trunk/src/lib/network/peer_info.h

-                      r9494
+                      r9656
     static const std::string& nodeTypeToString(unsigned int type);
+    inline bool isLocal() { return this->bLocal; }
 …
     int                 lastRecvedState;         //!< last received state
+    bool                bLocal;                  //!< true if this node is localy connected to this node
     static const std::string nodeNames[];

trunk/src/lib/network/player_stats.cc

-                      r9494
+                      r9656
   init();
   this->userId = userId;
+  this->assignedUserId = userId;
+}
 …
   this->setClassID( CL_PLAYER_STATS, "PlayerStats" );
   this->userId = 0;
+  this->assignedUserId = 0;
   this->teamId = TEAM_NOTEAM;
   this->preferedTeamId = TEAM_NOTEAM;
 …
   this->oldNickName = "Player";
   userId_handle = registerVarId( new SynchronizeableInt( &userId, &userId, "userId" ) );
   teamId_handle = registerVarId( new SynchronizeableInt( &teamId, &teamId, "teamId" ) );
   preferedTeamId_handle = registerVarId( new SynchronizeableInt( &preferedTeamId, &preferedTeamId, "preferedUserId" ) );
   score_handle = registerVarId( new SynchronizeableInt( &score, &score, "score" ) );
   playableClassId_handle = registerVarId( new SynchronizeableInt( &playableClassId, &playableClassId, "playableClassId") );
   playableUniqueId_handle = registerVarId( new SynchronizeableInt( &playableUniqueId, &playableUniqueId, "playableUniqueId" ) );
   modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName" ) );
   nickName_handler = registerVarId( new SynchronizeableString( &nickName, &nickName, "nickName" ) );
+  userId_handle = registerVarId( new SynchronizeableInt( &assignedUserId, &assignedUserId, "userId", PERMISSION_MASTER_SERVER ) );
+  teamId_handle = registerVarId( new SynchronizeableInt( &teamId, &teamId, "teamId", PERMISSION_MASTER_SERVER ) );
+  preferedTeamId_handle = registerVarId( new SynchronizeableInt( &preferedTeamId, &preferedTeamId, "preferedUserId", PERMISSION_MASTER_SERVER ) );
+  score_handle = registerVarId( new SynchronizeableInt( &score, &score, "score", PERMISSION_MASTER_SERVER ) );
+  playableClassId_handle = registerVarId( new SynchronizeableInt( &playableClassId, &playableClassId, "playableClassId", PERMISSION_MASTER_SERVER) );
+  playableUniqueId_handle = registerVarId( new SynchronizeableInt( &playableUniqueId, &playableUniqueId, "playableUniqueId", PERMISSION_MASTER_SERVER ) );
+  modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName", PERMISSION_MASTER_SERVER ) );
+  nickName_handler = registerVarId( new SynchronizeableString( &nickName, &nickName, "nickName", PERMISSION_MASTER_SERVER ) );
   MessageManager::getInstance()->registerMessageHandler( MSGID_CHANGENICKNAME, changeNickHandler, NULL );
   PRINTF(0)("PlayerStats created\n");
+  PRINTF(5)("PlayerStats created\n");
+}
 …
  */
 PlayerStats::~PlayerStats()
+{
+}
+ /**
+ * override this function to be notified on change
+ * of your registred variables.
+ * @param id id's which have changed
+  */
+{}
+/**
+* override this function to be notified on change
+* of your registred variables.
+* @param id id's which have changed
+ */
 void PlayerStats::varChangeHandler( std::list< int > & id )
+{
 …
     this->setPlayableUniqueId( this->playableUniqueId );
     PRINTF(0)("uniqueID changed %d %d %d\n", userId, SharedNetworkData::getInstance()->getHostID(), getUniqueID());
+    PRINTF(4)("uniqueID changed %d %d %d\n", assignedUserId, SharedNetworkData::getInstance()->getHostID(), getUniqueID());
+  }
 …
+  {
     PRINTF(0)("user %s is now known as %s\n", oldNickName.c_str(), nickName.c_str());
+    oldNickName = nickName;
+  }
+}
+    this->oldNickName = nickName;
+  }
+  if ( std::find( id.begin(), id.end(), preferedTeamId_handle) != id.end() )
+  {
+    PRINTF(0)("user %s has changed team to %i\n", nickName.c_str(), this->teamId);
+  }
+}
 /**
 …
+  }
+  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
+  {
+    if ( dynamic_cast<PlayerStats*>(*it)->getUserId() == userId )
+  for ( std::list<BaseObject*>::const_iterator it = list->
+        begin();
+        it != list->end();
+        it++ )
+  {
+    if ( dynamic_cast<PlayerStats*>(*it)->getAssignedUserId() == userId )
+    {
       return dynamic_cast<PlayerStats*>(*it);
 …
   this->playable = NULL;
+  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
+  {
+    if ( dynamic_cast<Playable*>(*it)->getUniqueID() == uniqueId )
+  for ( std::list<BaseObject*>::const_iterator it = list->
+        begin();
+        it != list->end();
+        it++ )
+  {
+    if ( dynamic_cast<Playable*>(*it)->
+         getUniqueID() == uniqueId )
+    {
       this->playable = dynamic_cast<Playable*>(*it);
 …
+  }
+  if ( this->playable && userId == SharedNetworkData::getInstance()->getHostID() )
+  if ( this->playable && this->assignedUserId == SharedNetworkData::getInstance()
+       ->getHostID() )
+  {
     State::getPlayer()->setPlayable( this->playable );
+    // also set the team id
+  }
 …
     assert( Converter::stringToByteArray( nick, data, nick.length()+INTSIZE) == nick.length()+INTSIZE );
     MessageManager::getInstance()->sendMessage( MSGID_CHANGENICKNAME, data, nick.length()+INTSIZE, RT_SERVER, 0, MP_HIGHBANDWIDTH );
+    MessageManager::getInstance()->sendMessage( MSGID_CHANGENICKNAME, data, nick.length()+INTSIZE, RT_SERVER, NET_MASTER_SERVER, MP_HIGHBANDWIDTH );
     return;
+  }
+}
+bool PlayerStats::changeNickHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+/**
+ * handler for the nick name
+ * @param messageType type of the message
+ * @param data  data of the message
+ * @param dataLength length of the data
+ * @param someData some additional data
+ * @param senderId userId of the sender
+ * @param destinationId userId of the rec
+ * @return true if handled correctly
+ */
+bool PlayerStats::changeNickHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
+{
   std::string newNick;
 …
   if ( res != dataLength )
+  {
     PRINTF(2)("invalid message size from user %d\n", userId);
+    PRINTF(2)("invalid message size from user %d\n", senderId);
     newNick = "invalid";
+  }
   if ( PlayerStats::getStats( userId ) )
     PlayerStats::getStats( userId )->setNickName( newNick );
+  if ( PlayerStats::getStats( senderId) )
+    PlayerStats::getStats( senderId )->setNickName( newNick );
   return true;
+}
+/**
+ * sets the nick name from the shell
+ * @param newNick new prefered nick name
+ */
 void PlayerStats::shellNick( const std::string& newNick )
+{
 …
+/**
+ * removes and delets all player stats
+ */
 void PlayerStats::deleteAllPlayerStats( )
+{
 …
+/**
+ * @return the score list of this player stat
+ */
 ScoreList PlayerStats::getScoreList( )
+{
 …
+  }
+  for ( std::list<BaseObject*>::const_iterator it = list->begin(); it != list->end(); it++ )
+  for ( std::list<BaseObject*>::const_iterator it = list->
+        begin();
+        it != list->end();
+        it++ )
+  {
     PlayerStats & stats = *dynamic_cast<PlayerStats*>(*it);

trunk/src/lib/network/player_stats.h

-                      r9110
+                      r9656
 enum
+{
   TEAM_NOTEAM = -3,
   TEAM_RANDOM = -2,
   TEAM_SPECTATOR = -1
+  TEAM_NOTEAM       = -3,
+  TEAM_RANDOM       = -2,
+  TEAM_SPECTATOR    = -1
 };
 struct PlayerScore
 …
   int score;
 };
 typedef std::list<PlayerScore> TeamScoreList;
 typedef std::map<int,TeamScoreList> ScoreList;
 //! A class for storing player information
 class PlayerStats : public Synchronizeable
+class PlayerStats : public Synchronizeable
+{
 …
     PlayerStats( int userId );
     virtual ~PlayerStats();
     virtual void varChangeHandler( std::list<int> & id );
     static PlayerStats * getStats( int userId );
+    inline int getUserId(){ return userId; }
+    inline int getAssignedUserId(){ return this->assignedUserId; }
     inline int getTeamId(){ return teamId; }
     inline void setTeamId( int teamId ){ this->teamId = teamId; }
     inline int getPreferedTeamId(){ return preferedTeamId; }
     inline void setPreferedTeamId( int preferedTeamId ){ this->preferedTeamId = preferedTeamId; }
+    inline void setPreferedTeamId( int preferedTeamId ) { this->preferedTeamId = preferedTeamId; }
     inline int getScore(){ return score; }
     inline void setScore( int score ){ this->score = score; }
     inline int getPlayableClassId(){ return playableClassId; }
     void setPlayableClassId( int classId ){ this->playableClassId = classId; };
     inline int getPlayableUniqueId(){ return playableUniqueId; }
     void setPlayableUniqueId( int uniqueId );
     inline std::string getModelFileName(){ return modelFileName; }
     inline void setModelFileName( std::string filename ){ modelFileName = filename; }
     Playable * getPlayable();
     inline std::string getNickName(){ return this->nickName; }
     void setNickName( std::string nick );
     static bool changeNickHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId );
+    static bool changeNickHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  );
     void shellNick( const std::string&  newNick );
     static void deleteAllPlayerStats();
     static ScoreList getScoreList();
   private:
+    int userId;                //!< userId
+    int teamId;                //!< teamId
+    int preferedTeamId;        //!< preferedTeamId
+    void init();
-    std::string nickName;      //!< players nickname
-    std::string oldNickName;   //!< nickname player had before
+    int score;                 //!< users score points
+    int playableClassId;       //!< players playable class id
+    int playableUniqueId;      //!< playable's uniqueId
+    std::string modelFileName; //!< model filename
+  private:
+    // handles for SynchronizeableVars
+    int              userId_handle;
+    int              teamId_handle;
+    int              preferedTeamId_handle;
+    int              score_handle;
+    int              playableClassId_handle;
+    int              playableUniqueId_handle;
+    int              modelFileName_handle;
+    int              nickName_handler;
+    Playable * playable;       //!< pointer to players playable
+    int              assignedUserId;            //!< userId
+    int              teamId;                    //!< teamId
+    int              preferedTeamId;            //!< preferedTeamId
+    // handles for SynchronizeableVars
+    int userId_handle;
+    int teamId_handle;
+    int preferedTeamId_handle;
+    int score_handle;
+    int playableClassId_handle;
+    int playableUniqueId_handle;
+    int modelFileName_handle;
+    int nickName_handler;
+    void init();
+    std::string      nickName;                  //!< players nickname
+    std::string      oldNickName;               //!< nickname player had before
+    int              score;                     //!< users score points
+    int              playableClassId;           //!< players playable class id
+    int              playableUniqueId;          //!< playable's uniqueId
+    std::string      modelFileName;             //!< model filename
+    Playable *       playable;                  //!< pointer to players playable
 };

trunk/src/lib/network/proxy/network_settings.cc

-                      r9494
+                      r9656
   // setUniqueID( maxCon+2 ) because we need one id for every handshake
   // and one for handshake to reject client maxCon+1
+  SharedNetworkData::getInstance()->setNewUniqueID( this->maxPlayer + 2);
+  // NEW: at most there will be
+  SharedNetworkData::getInstance()->setNewUniqueID( this->maxPlayer + NET_ID_PROXY_MAX + 2);
+}

trunk/src/lib/network/server_socket.h

-                      r7954
+                      r9656
 /*!
  * @file server_socket.h
  *  waits for incoming connections
+ * waits for incoming connections and handles them.
+ *
  */

trunk/src/lib/network/shared_network_data.h

-                      r9494
+                      r9656
 class Synchronizeable;
+class NetworkMonitor;
 …
     inline void setDefaultSyncStream(NetworkStream* defaultSyncStream) { this->defaultSyncStream = defaultSyncStream; }
+    /** @returns the network monitor reference */
+    inline NetworkMonitor* getNetworkMonitor() { return this->networkMonitor; }
+    /** @param networkMonitor sets the NetworkMonitor reference */
+    inline void setNetworkMonitor( NetworkMonitor* networkMonitor) { this->networkMonitor = networkMonitor; }
   private:
 …
     int                             hostID;                  //!< The Host-ID of the Manager
     NetworkStream*                  defaultSyncStream;       //!< default synchronize NetworkStream
+    NetworkMonitor*                 networkMonitor;          //!< reference to the NetworkMonitor
     static SharedNetworkData*       singletonRef;            //!< Pointer to the only instance of this Class

trunk/src/lib/network/synchronizeable.cc

-                      r9494
+                      r9656
   /* make sure loadClassId is first synced var because this is read by networkStream */
   assert( syncVarList.size() == 0 );
   mLeafClassId = this->registerVarId( new SynchronizeableInt( (int*)&this->getLeafClassID(), (int*)&this->getLeafClassID(), "leafClassId" ) );
   this->registerVar( new SynchronizeableInt( &this->owner, &this->owner, "owner" ) );
   this->registerVar( new SynchronizeableString( &this->objectName, &this->objectName, "objectName" ) );
+  mLeafClassId = this->registerVarId( new SynchronizeableInt( (int*)&this->getLeafClassID(), (int*)&this->getLeafClassID(), "leafClassId", PERMISSION_MASTER_SERVER) );
+  this->registerVar( new SynchronizeableInt( &this->owner, &this->owner, "owner", PERMISSION_MASTER_SERVER ) );
+  this->registerVar( new SynchronizeableString( &this->objectName, &this->objectName, "objectName", PERMISSION_MASTER_SERVER ) );
+}
 …
 int Synchronizeable::getStateDiff( int userId, byte* data, int maxLength, int stateId, int fromStateId, int priorityTH )
+{
   //make sure this user has his history
   if ( sentStates.size() <= userId )
+  // make sure this user has his history or resize for new clients
+  if ( (int)sentStates.size() <= userId )
     sentStates.resize( userId+1 );
 …
   int neededSize = 0;
+  // calculate the needed space for network packet by summing up
   for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
 …
   int n;
-  bool hasPermission = false;
   bool sizeChanged = false;
 …
   for ( SyncVarList::iterator it = syncVarList.begin(); it != syncVarList.end(); it++ )
+  {
+    // DATA PERMISSIONS
+    // check if this synchronizeable has the permissions to write the data
+    // first check MASTER_SERVER permissions
+    if( SharedNetworkData::getInstance()->isMasterServer() && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
+      hasPermission = true;
+    // now check PROXY_SERVER permissions
+    else if( SharedNetworkData::getInstance()->isProxyServerActive() && (*it)->checkPermission( PERMISSION_PROXY_SERVER ))
+      hasPermission = true;
+    // now check OWNER permissions
+    else if( this->owner == SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // now check ALL permissions
+    else if( (*it)->checkPermission( PERMISSION_ALL ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if i am master server and i am able to overwrite the client stuff
+#warning this could probably override also clients that are connected to another proxy: the master server overwrites it
+    else if( SharedNetworkData::getInstance()->isMasterServer() && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if i am proxy server and i am able to overwrite the client stuff
+    else if( SharedNetworkData::getInstance()->isProxyServerActive() && this->networkStream->isUserClient(userId)
+             && this->owner != userId && (*it)->checkPermission( PERMISSION_OWNER ) )
+      hasPermission = true;
+    ////////////////////////////////
+    // Data SENDING Permissions
+    ////////////////////////////////
+    bool hasPermission = false;
+    bool b1, b2, b3, b4, b5, b6, b7, b8, b9;
+    b1 = b2 = b3 = b4 = b5 = b6 = b7 = b8 = b9 = false;
+    // Permission   OWNER accept if:
+    // I am the owner
+    if(       (*it)->checkPermission( PERMISSION_OWNER ) && this->owner == SharedNetworkData::getInstance()->getHostID()) {
+      hasPermission = true; b1 = true; }
+    // reciever != owner && owner is local
+    else if(  (*it)->checkPermission( PERMISSION_OWNER ) && userId != this->owner &&
+                (SharedNetworkData::getInstance()->isUserLocal(this->owner) || this->owner == SharedNetworkData::getInstance()->getHostID())) {
+      hasPermission = true; b2 = true; }
+    // Permission   MASTER_SERVER accept if:
+    // im MASTER_SERVER
+    else if( (*it)->checkPermission( PERMISSION_MASTER_SERVER ) && SharedNetworkData::getInstance()->isMasterServer()) {
+      hasPermission = true; b3 = true; }
+    // im PROXY_SERVER && reciever == CLIENT
+    else if( (*it)->checkPermission( PERMISSION_MASTER_SERVER ) && SharedNetworkData::getInstance()->isProxyServerActive() &&
+               SharedNetworkData::getInstance()->isUserClient( userId)) {
+      hasPermission = true;  b4 = true; }
+    // Pemission    SERVER accept if:
+    // i am server && reciever == CLIENT
+    else if( (*it)->checkPermission( PERMISSION_SERVER ) && !SharedNetworkData::getInstance()->isClient() &&
+               SharedNetworkData::getInstance()->isUserClient( userId)) {
+      hasPermission = true; b5 = true; }
+    // i am SERVER && reciever == SERVER && reciever != owner && ( owner is local || i am owner)
+    else if( (*it)->checkPermission( PERMISSION_SERVER ) && !SharedNetworkData::getInstance()->isClient() &&
+               userId != this->owner &&
+               ( SharedNetworkData::getInstance()->isUserLocal( this->owner) || this->owner ==  SharedNetworkData::getInstance()->getHostID())) {
+      hasPermission = true; b6 = true; }
+    // Permission   ALL accept if:
+    else if( (*it)->checkPermission( PERMISSION_ALL )) {
+      hasPermission = true; b7 = true; }
+    // or else refuse sending data
     else
       hasPermission = false;
     if ( sizeIter == stateFrom->sizeList.end() || *sizeIter != (*it)->getSize() )
       sizeChanged = true;
 …
       n = (*it)->writeToBuf( stateTo->data+i, stateTo->dataLength - i );
       //NETPRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
+      //PRINTF(0)("getvar %s %d\n", (*it)->getName().c_str(), n);
+//       PRINTF(0)("sending %s %d\n", (*it)->getName().c_str(), n);
+//       if( this->isA(CL_PLAYABLE))
+//       {
+//         PRINTF(0)("ms: %i, ps: %i, c: %i, sender: %i, reciever: %i, owner: %i, perm: (ow %i, ms %i, s %i, a %i)\n",
+//         SharedNetworkData::getInstance()->isMasterServer(), SharedNetworkData::getInstance()->isProxyServerActive(), SharedNetworkData::getInstance()->isClient(),
+//         SharedNetworkData::getInstance()->getHostID(), userId, this->owner,
+//         (*it)->checkPermission( PERMISSION_OWNER ), (*it)->checkPermission( PERMISSION_MASTER_SERVER ),
+//         (*it)->checkPermission( PERMISSION_SERVER ), (*it)->checkPermission( PERMISSION_ALL ));
+//         PRINTF(0)("hasPermission: %i, sizeChanged: %i, eval: %i, %i, %i, %i, %i, %i, %i\n", hasPermission, sizeChanged, b1, b2, b3, b4, b5, b6, b7);
+//         PRINTF(0)("sending %s %s %d\n", this->getClassCName(), (*it)->getName().c_str(), n);
+//       }
       stateTo->sizeList.push_back( n );
       // this is only for very hardcore debug sessions
 …
 /**
  * sets a new state out of a diff created on another host
+ * sets a new state out of a diff created on another host (recieving data)
  * @param userId hostId of user who send me that diff
  * @param data pointer to diff
 …
+{
   //make sure this user has his history
   if ( recvStates.size() <= userId )
+  if ( (int)recvStates.size() <= userId )
     recvStates.resize( userId+1 );
 …
   int n = 0;
   std::list<int> changes;
-  bool hasPermission = false;
   // extract the new state for every client
 …
     // check if this synchronizeable has the permissions to write the data
+    // first check MASTER_SERVER permissions
+    if(  this->networkStream->isUserMasterServer( userId ) && (*it)->checkPermission( PERMISSION_MASTER_SERVER ))
+      hasPermission = true;
+    // now check PROXY_SERVER permissions
+    else if( this->networkStream->isUserProxyServerActive( userId )  && (*it)->checkPermission( PERMISSION_MASTER_SERVER )
+             && SharedNetworkData::getInstance()->isClient())
+      hasPermission = true;
+    // now check OWNER permissions
+    else if( this->owner == userId && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // now check ALL permissions
+    else if( (*it)->checkPermission( PERMISSION_ALL ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if im sending to a master server that does not own this sync
+    else if( this->networkStream->isUserMasterServer( userId ) && this->owner != SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    // SPECIAL: get write permissions if im sending to a proxy server that does not own this sync
+    else if( this->networkStream->isUserProxyServerActive( userId ) && SharedNetworkData::getInstance()->isClient()
+              && this->owner != SharedNetworkData::getInstance()->getHostID() && (*it)->checkPermission( PERMISSION_OWNER ))
+      hasPermission = true;
+    bool hasPermission = false;
+    bool b1, b2, b3, b4, b5, b6, b7, b8, b9;
+    b1 = b2 = b3 = b4 = b5 = b6 = b7 = b8 = b9 = false;
+    ////////////////////////////////
+    // Data RECIEVING Permissions
+    ////////////////////////////////
+    // i should never ever receive a state update from a synchronizeable, that belongs to me! If it does somethings wrong with the send rules
+//     assert(   !((*it)->checkPermission( PERMISSION_OWNER ) && this->owner == SharedNetworkData::getInstance()->getHostID()));
+    // Permission   OWNER accept if:
+    // sender == owner
+    if(      (*it)->checkPermission( PERMISSION_OWNER ) && this->owner == userId) {
+      hasPermission = true; b1 = true; }
+    // sender == MASTER_SERVER
+    else if( (*it)->checkPermission( PERMISSION_OWNER ) && SharedNetworkData::getInstance()->isUserMasterServer( userId)
+               && this->owner != SharedNetworkData::getInstance()->getHostID()) {
+      hasPermission = true; b2 = true; }
+    // sender == PROXY_SERVER
+      else if( (*it)->checkPermission( PERMISSION_OWNER ) && SharedNetworkData::getInstance()->isUserProxyServerActive( userId) &&
+                 this->owner != SharedNetworkData::getInstance()->getHostID()) {
+        hasPermission = true; b3 = true; }
+    // Permission   MASTER_SERVER accept if:
+    // sender == MASTER_SERVER
+    else if( (*it)->checkPermission( PERMISSION_MASTER_SERVER) && SharedNetworkData::getInstance()->isUserMasterServer( userId)) {
+      hasPermission = true; b4 = true; }
+    // sender == PROXY_SERVER && im not MASTER_SERVER && im not PROXY_SERVER
+    else if( (*it)->checkPermission( PERMISSION_MASTER_SERVER) && SharedNetworkData::getInstance()->isClient() &&
+               SharedNetworkData::getInstance()->isUserProxyServerActive( userId)) {
+      hasPermission = true; b5 = true; }
+    // Permission   SERVER accept if:
+    // sender == SERVER
+    else if( (*it)->checkPermission( PERMISSION_SERVER ) && !SharedNetworkData::getInstance()->isUserClient( userId) /*&&
+               SharedNetworkData::getInstance()->isClient()*/) {
+      hasPermission = true; b6 = true; }
+    // Pemission    ALL accept if:
+    else if(  (*it)->checkPermission( PERMISSION_ALL )) {
+      hasPermission = true; b8 = true; }
+   // no rights to over-write local data
     else
       hasPermission = false;
 …
       i += n;
       //NETPRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
       //PRINTF(0)("%s::setvar %s %d\n", getClassCName(), (*it)->getName().c_str(), n);
+//       PRINTF(0)("recieving: %s %d\n",  (*it)->getName().c_str(), n);
       //(*it)->debug();
+//       if( this->isA(CL_PLAYABLE))
+//       {
+//         PRINTF(0)("ms: %i, ps: %i, c: %i, sender: %i, reciever: %i, owner: %i, perm: (ow %i, ms %i, s %i, a %i)\n",
+//         SharedNetworkData::getInstance()->isMasterServer(), SharedNetworkData::getInstance()->isProxyServerActive(), SharedNetworkData::getInstance()->isClient(),
+//         userId, SharedNetworkData::getInstance()->getHostID(), this->owner,
+//         (*it)->checkPermission( PERMISSION_OWNER ), (*it)->checkPermission( PERMISSION_MASTER_SERVER ),
+//         (*it)->checkPermission( PERMISSION_SERVER ), (*it)->checkPermission( PERMISSION_ALL ));
+//         PRINTF(0)("hasPermission: %i, eval: %i, %i, %i, %i, %i, %i, %i, %i\n", hasPermission, b1, b2, b3, b4, b5, b6, b7, b8);
+//         PRINTF(0)("rec %s %s %d\n", this->getClassCName(), (*it)->getName().c_str(), n);
+//       }
       if ( (*it)->getHasChanged() )
+      {
 …
 void Synchronizeable::cleanUpUser( int userId )
+{
   if ( recvStates.size() > userId )
+  if ( (int)recvStates.size() > userId )
+  {
     for ( std::list<StateHistoryEntry*>::iterator it = recvStates[userId].begin(); it != recvStates[userId].end(); it++ )
 …
+  }
   if ( sentStates.size() > userId )
+  if ( (int)sentStates.size() > userId )
+  {
 …
+{
    //make sure this user has his history
   if ( recvStates.size() <= userId )
+  if ( (int)recvStates.size() <= userId )
     recvStates.resize( userId+1 );
 …
+{
    //make sure this user has his history
   if ( sentStates.size() <= userId )
+  if ( (int)sentStates.size() <= userId )
     sentStates.resize( userId+1 );

trunk/src/lib/network/synchronizeable_var/synchronizeable_bool.h

r9406	r9656
12	12
13	13	public:
14		SynchronizeableBool( bool * ptrIn, bool * ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	14	SynchronizeableBool( bool * ptrIn, bool * ptrOut, std::string name, int permission, int priority = 0 );
15	15	virtual ~SynchronizeableBool();
16	16

trunk/src/lib/network/synchronizeable_var/synchronizeable_float.h

r9406	r9656
13	13
14	14	public:
15		SynchronizeableFloat( float * ptrIn, float * ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	15	SynchronizeableFloat( float * ptrIn, float * ptrOut, std::string name, int permission, int priority = 0 );
16	16	virtual ~SynchronizeableFloat();
17	17

trunk/src/lib/network/synchronizeable_var/synchronizeable_int.h

r9406	r9656
13	13
14	14	public:
15		SynchronizeableInt( int * ptrIn, int * ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	15	SynchronizeableInt( int * ptrIn, int * ptrOut, std::string name, int permission, int priority = 0 );
16	16	virtual ~SynchronizeableInt();
17	17

trunk/src/lib/network/synchronizeable_var/synchronizeable_ip.h

r9406	r9656
15	15
16	16	public:
17		SynchronizeableIP( IP ptrIn, IP ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	17	SynchronizeableIP( IP ptrIn, IP ptrOut, std::string name, int permission, int priority = 0 );
18	18	virtual ~SynchronizeableIP();
19	19

trunk/src/lib/network/synchronizeable_var/synchronizeable_quaternion.h

r9406	r9656
14	14
15	15	public:
16		SynchronizeableQuaternion( Quaternion * ptrIn, Quaternion * ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	16	SynchronizeableQuaternion( Quaternion * ptrIn, Quaternion * ptrOut, std::string name, int permission, int priority = 0 );
17	17	virtual ~SynchronizeableQuaternion();
18	18

trunk/src/lib/network/synchronizeable_var/synchronizeable_string.h

r9406	r9656
14	14
15	15	public:
16		SynchronizeableString( std::string * ptrIn, std::string * ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	16	SynchronizeableString( std::string * ptrIn, std::string * ptrOut, std::string name, int permission, int priority = 0 );
17	17	virtual ~SynchronizeableString();
18	18

trunk/src/lib/network/synchronizeable_var/synchronizeable_uint.h

r9406	r9656
13	13
14	14	public:
15		SynchronizeableUInt( unsigned int * ptrIn, unsigned int * ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	15	SynchronizeableUInt( unsigned int * ptrIn, unsigned int * ptrOut, std::string name, int permission, int priority = 0 );
16	16	virtual ~SynchronizeableUInt();
17	17

trunk/src/lib/network/synchronizeable_var/synchronizeable_var.h

r9494	r9656
15	15
16	16	public:
17		SynchronizeableVar( void * ptrIn, void * ptrOut, std::string name, int length, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	17	SynchronizeableVar( void * ptrIn, void * ptrOut, std::string name, int length, int permission, int priority = 0 );
18	18	virtual ~SynchronizeableVar();
19	19

trunk/src/lib/network/synchronizeable_var/synchronizeable_vector.h

r9406	r9656
14	14
15	15	public:
16		SynchronizeableVector( Vector * ptrIn, Vector * ptrOut, std::string name, int permission ~~= PERMISSION_MASTER_SERVER~~, int priority = 0 );
	16	SynchronizeableVector( Vector * ptrIn, Vector * ptrOut, std::string name, int permission, int priority = 0 );
17	17	virtual ~SynchronizeableVector();
18	18

trunk/src/lib/network/udp_socket.h

-                      r9406
+                      r9656
   private:
+    void init();
+    bool writeRawPacket( byte * data, int length );
+    bool checkUdpCmd( byte udpCmd );
+    bool checkRandomByte( byte rndByte );
+    byte generateNewRandomByte();
+  private:
     UdpServerSocket * serverSocket;   //!< will get packets here
     int               userId;         //!< user id used by serverSocket
 …
     byte              randomByte;     //!< contains random bytes & 0xFC
-    bool writeRawPacket( byte * data, int length );
-    bool checkUdpCmd( byte udpCmd );
-    bool checkRandomByte( byte rndByte );
-    byte generateNewRandomByte();
-    void init();
 };

trunk/src/lib/particles/particle_system.cc

-                      r9406
+                      r9656
 /**
  *  standard deconstructor
 */
+ * @brief standard deconstructor
+ */
 ParticleSystem::~ParticleSystem()
+{
 …
 /**
  * loads Parameters from a TiXmlElement
+ * @brief loads Parameters from a TiXmlElement
  * @param root the XML-element to load from.
  */
 …
 /**
+ * @brief sets a key in the color-animation on a per-particle basis
+ * @param lifeCycleTime: the time (partilceLifeTime/particleAge) [0-1]
+ * @param color the Color.
+ */
+void ParticleSystem::setColor(float lifeCycleTime, const Color& color)
+{
+  this->setColor(lifeCycleTime, color.r(), color.g(), color.b(), color.a());
+}
+/**
  * @brief adds an Emitter to this System.
  * @param emitter the Emitter to add.
 …
            this->maxCount,
            ((this->maxCount!=0)?100*this->count/this->maxCount:0));
+  if (this->deadList)
+  PRINT(0)("  Coloring sceme: r:"), this->colorAnim[0].debug();
+  PRINT(0)("  Coloring sceme: g:"), this->colorAnim[1].debug();
+  PRINT(0)("  Coloring sceme: b:"), this->colorAnim[2].debug();
+  PRINT(0)("  Coloring sceme: a:"), this->colorAnim[3].debug();
+  if (likely(this->deadList != NULL))
+  {
     PRINT(0)("  - ParticleDeadList is used: ");

trunk/src/lib/particles/particle_system.h

-                      r7300
+                      r9656
 #include "vector.h"
 #include <list>
+#include "color.h"
 #include "quick_animation.h"
 …
   void setMass(float lifeCycleTime, float mass, float randMass = 0.0);
   void setColor(float lifeCycleTime, float red, float green, float blue, float alpha);
+  void setColor(float lifeCycleTime, const Color& color);
   /** @returns the lifespan of the particles */

trunk/src/lib/particles/quick_animation.cc

r9406	r9656
287	287
288	288	for (unsigned int i = 0; i < this->keyFrames.size(); i++)
289		printf("(%~~f, %~~f)->", this->keyFrames[i].position, this->keyFrames[i].value);
	289	printf("(%0.2f, %0.2f)->", this->keyFrames[i].position, this->keyFrames[i].value);
290	290	printf("\n");
291	291	}

trunk/src/lib/util/color.h

r8986	r9656
48	48	inline const Color& operator-=(const Color& c) { r()-=c.r(); g()-=c.g(); b()-=c.b(); a()-=c.a(); return *this; };
49	49	inline Color operator-(const Color& c) const { return Color(r()-c.r(), g()-c.g(), b()-c.b(), a()-c.a()); };
	50	inline const Color& operator=(float v) { r()=v, g()=v, b()=v, a()=v; return this; };
50	51	inline Color operator(float v) const { return Color(r()v, g()v, b()v, a()*v); };
51	52

trunk/src/story_entities/menu/game_menu.cc

r9406	r9656
76	76	if( this->dataTank)
77	77	delete this->dataTank;
78		~~delete OrxGui::GLGuiHandler::get~~Instance( );
	78	OrxGui::GLGuiHandler::deleteInstance( );
79	79	}
80	80

trunk/src/story_entities/multi_player_world.cc

r9406	r9656
63	63	if( this->dataTank)
64	64	delete this->dataTank;
65		~~delete OrxGui::GLGuiHandler::get~~Instance( );
	65	OrxGui::GLGuiHandler::deleteInstance( );
66	66	}
67	67

trunk/src/subprojects/network/network_unit_test.cc

-                      r9494
+                      r9656
     server1 = server.getNewSocket();
+  }
   assert( server1->isOk() );
 …
   printf("%d bytes send from server2\n", n);
   SDL_Delay(10);
   server.update();
 …
   printf("data: '%s'\n", buf);
   //22222222222222222222222222222222222222222
   n = client1->writePacket((byte*)str1, strlen(str1)+1);
 …
   printf("%d bytes send from server2\n", n);
   SDL_Delay(10);
   server.update();
 …
   delete client2;
   delete server1;
   delete server2;
+  delete server2;
   return 0;
+}
 …
+}
 bool testCB( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+bool testCB( MessageType messageType, byte * data, int dataLength, void * someData, int userId )
+{
   printf("GOT MESSAGE: %s\n", data);
 …
   NetworkManager* netMan = NetworkManager::getInstance();
   netMan->initialize();
   netMan->createMasterServer(/**ss, */ 9999);
   SimpleSync* ss = new SimpleSync("Server");
   ss->setSynchronized( true );
   NetworkLog::getInstance()->listen( 8888 );
   //MessageManager::getInstance()->initUser( 1 );
   MessageManager::getInstance()->registerMessageHandler( TESTMESSAGEID, testCB, NULL );
   SDL_Delay(20);
   for(;;)
+  {
     MessageManager::getInstance()->sendMessage( TESTMESSAGEID, (byte*)"server to client", 18, RT_ALL_BUT_ME, 0, MP_HIGHBANDWIDTH );
+    MessageManager::getInstance()->sendMessage( TESTMESSAGEID, (byte*)"server to client", 18, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
     netMan->synchronize( 100 );
     SDL_Delay(100);
 …
   State::setOnline(true);
   NetworkManager* netMan = NetworkManager::getInstance();
   netMan->initialize();
   std::string host;
   if ( argc > 2 )
     host = argv[2];
   else
     host = "localhost";
   netMan->createClient(host, 9999);
 //  SimpleSync* ss = new SimpleSync("SimpleSync");
 //  ss->setSynchronized( true );
 //  netMan->connectSynchronizeable( *ss );
   NetworkLog::getInstance()->listen( 7777 );
   SimpleSync * ss = NULL;
   //MessageManager::getInstance()->initUser( 0 );
   MessageManager::getInstance()->registerMessageHandler( TESTMESSAGEID, testCB, NULL );
   for(;;)
+  {
     netMan->synchronize( 100 );
     MessageManager::getInstance()->sendMessage( TESTMESSAGEID, (byte*)"client to server", 18, RT_ALL_BUT_ME, 0, MP_HIGHBANDWIDTH );
+    MessageManager::getInstance()->sendMessage( TESTMESSAGEID, (byte*)"client to server", 18, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
     ss = dynamic_cast<SimpleSync*>(ClassList::getObject( "Server", CL_SIMPLE_SYNC ) );
     SDL_Delay(100);

trunk/src/util/multiplayer_team_deathmatch.cc

-                      r9494
+                      r9656
   if ( currentGameState == GAMESTATE_PRE_GAME || currentGameState == GAMESTATE_GAME )
+  {
+    if ( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )
+         && box == NULL
+         &&  (PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() == TEAM_NOTEAM
+         || bShowTeamChange )
+    if ( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() ) &&
+         box == NULL &&
+         (PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() == TEAM_NOTEAM || bShowTeamChange )
+       )
 …
+  }
+  if ( box != NULL
+       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )
+       && PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() != TEAM_NOTEAM
+       && !bShowTeamChange
+//   if( PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() ) )
+//   {
+//     PRINTF(0)("prefered team id: %i, noteam: %i\n", PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId(), TEAM_NOTEAM);
+//   }
+  // check if the menu should be removed and the game state should be entered
+  if ( box != NULL &&
+       PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() ) &&
+       PlayerStats::getStats( SharedNetworkData::getInstance()->getHostID() )->getPreferedTeamId() != TEAM_NOTEAM &&
+       !bShowTeamChange
+     )
+  {
 …
   assert( false );
+}
 std::string MultiplayerTeamDeathmatch::getPlayableModelFileName( int userId, int team, ClassID classId )
 …
+}
+/**
+ *  this handles team changes but only on the master server
+ */
 void MultiplayerTeamDeathmatch::handleTeamChanges( )
+{
 …
       if ( stats.getPreferedTeamId() == TEAM_SPECTATOR || ( stats.getPreferedTeamId() >= 0 && stats.getPreferedTeamId() < numTeams ) )
+      {
         teamChange( stats.getUserId() );
+        teamChange( stats.getAssignedUserId() );
+      }
+    }
 …
+      {
         stats.setPreferedTeamId( getRandomTeam() );
         teamChange( stats.getUserId() );
+        teamChange( stats.getAssignedUserId() );
+      }
+    }
 …
+}
+/**
+ * changes the team
+ * @param userId the user changing team (userId)
+ */
 void MultiplayerTeamDeathmatch::teamChange( int userId )
+{
 …
   ClassID playableClassId = getPlayableClassId( userId, stats.getPreferedTeamId() );
   std::string playableModel = getPlayableModelFileName( userId, stats.getPreferedTeamId(), playableClassId );
   std::string playableTexture = getPlayableModelTextureFileName( userId, stats.getPreferedTeamId(), playableClassId );
   float       playableScale = getPlayableScale( userId, stats.getPreferedTeamId(), playableClassId );
+  ClassID       playableClassId  = getPlayableClassId( userId, stats.getPreferedTeamId() );
+  std::string   playableModel    = getPlayableModelFileName( userId, stats.getPreferedTeamId(), playableClassId );
+  std::string   playableTexture  = getPlayableModelTextureFileName( userId, stats.getPreferedTeamId(), playableClassId );
+  float         playableScale    = getPlayableScale( userId, stats.getPreferedTeamId(), playableClassId );
   BaseObject * bo = Factory::fabricate( playableClassId );
 …
   playable.setSynchronized( true );
-  stats.setTeamId( stats.getPreferedTeamId() );
   stats.setPlayableClassId( playableClassId );
   stats.setPlayableUniqueId( playable.getUniqueID() );
   stats.setModelFileName( playableModel );
+  stats.setTeamId( stats.getPreferedTeamId() );
+  playable.setTeam(stats.getPreferedTeamId());
   this->respawnPlayable( &playable, stats.getPreferedTeamId(), 0.0f );
 …
   if ( oldPlayable )
+  {
-    //if ( userId == SharedNetworkData::getInstance()->getHostID() )
-    //  State::getPlayer()->setPlayable( NULL );
     delete oldPlayable;
+  }
+}
 void MultiplayerTeamDeathmatch::onButtonExit( )
 …
+}
+  /**
+   * function that processes events from the handler
+   * @param event: the event
+   * @todo replace SDLK_o with something from KeyMapper
+   */
+/**
+ * function that processes events from the handler
+ * @param event: the event
+ * @todo replace SDLK_o with something from KeyMapper
+ */
 void MultiplayerTeamDeathmatch::process( const Event & event )
+{
 …
     if ( this->statsBox && !this->bLocalPlayerDead && event.bPressed )
+    {
       PRINTF(0)("hide stats\n");
+      PRINTF(5)("hide stats\n");
       this->hideStats();
+    }
     else if ( !this->statsBox && event.bPressed )
+    {
       PRINTF(0)("show stats\n");
+      PRINTF(5)("show stats\n");
       this->showStats();
+    }
 …
   PlayerStats & killerStats = *PlayerStats::getStats( killerUserId );
   if ( killerStats.getPlayable() != killer || victimStats.getPlayable() != victim )
+  {
     PRINTF(0)("killerStats.getPlayable() != killer || victimStats.getPlayable() != victim\n");
+  if ( killerStats.getPlayable() == NULL || victimStats.getPlayable() == NULL)
+  {
+    PRINTF(0)("killerStats.getPlayable() != NULL || victimStats.getPlayable() != NULL\n");
     PRINTF(0)("%x %x %x %x\n", killerStats.getPlayable(), killer, victimStats.getPlayable(), victim );
     PRINTF(0)("%d %d %d %d\n", killerStats.getPlayable()->getUniqueID(), killer->getUniqueID(), victimStats.getPlayable()->getUniqueID(), victim->getUniqueID() );
 …
+/**
+ * respawns a playable in the world via spawning points
+ * @param playable the playable to respawn
+ * @param teamId the teamId to use
+ * @param delay time delay for delayed spawning
+ */
 void MultiplayerTeamDeathmatch::respawnPlayable( Playable * playable, int teamId, float delay )
+{

trunk/src/util/object_manager.cc

-                      r9406
+                      r9656
   if (omList != OM_INIT || omList == OM_SIZE)
+  {
     PRINT(0)(" +ObjectManager-LIST: '%s'==size='%d'==---\n", ObjectManager::OMListToString((OM_LIST)omList), this->objectLists[omList].size());
+    PRINT(0)(" +ObjectManager-LIST: '%s'==size='%d'==---\n", ObjectManager::OMListToString((OM_LIST)omList).c_str(), this->objectLists[omList].size());
   //  if (level >= 1)
+    {
 …
  * @returns the String transformed from omList.
  */
 const char* ObjectManager::OMListToString(OM_LIST omList)
+const std::string& ObjectManager::OMListToString(OM_LIST omList)
+{
   if (omList == OM_INIT || omList == OM_SIZE)
     return "===invalid===";
+    return ObjectManager::objectManagerListNames[OM_NULL];
   printf("%d\n", omList);
 …
+    }
+  }
   return OM_DEFAULT_LIST;
+}
 const char* ObjectManager::objectManagerListNames[] = {
+  return OM_NULL;
+}
+const std::string ObjectManager::objectManagerListNames[] = {
     "null",
     "dead",

trunk/src/util/object_manager.h

-                      r8068
+                      r9656
   static OM_LIST StringToOMList(const std::string& listName);
   static const char* OMListToString(OM_LIST omList);
+  static const std::string& OMListToString(OM_LIST omList);
 …
   EntityList                              objectLists[OM_SIZE];     //!< The ObjectLists.
   static const char*                      objectManagerListNames[]; //!< Names of all the lists
+  static const std::string                objectManagerListNames[]; //!< Names of all the lists
   EntityList                              reflectionList;           //!< A list of all reflected objects in the world

trunk/src/world_entities/WorldEntities.am

-                      r9235
+                      r9656
                 world_entities/npcs/ground_turret.cc \
                 world_entities/npcs/space_turret.cc \
+                world_entities/npcs/network_turret.cc \
                 world_entities/npcs/generic_npc.cc \
                 world_entities/npcs/door.cc \
 …
                 npcs/ground_turret.h \
                 npcs/space_turret.h \
+                npcs/network_turret.h \
                 npcs/door.cc \
                 npcs/repair_station.h \

trunk/src/world_entities/bsp_entity.cc

r9406	r9656
54	54	this->bspManager = NULL;
55	55
56		this->name_handle = registerVarId( new SynchronizeableString( &this->name, &this->name_write, "name" ) );
	56	this->name_handle = registerVarId( new SynchronizeableString( &this->name, &this->name_write, "name", PERMISSION_MASTER_SERVER ) );
57	57
58	58	this->setSynchronized( true );

trunk/src/world_entities/environments/model_entity.cc

r9406	r9656
36	36	this->speed = NULL;
37	37	this->momentum = NULL;
	38
	39	this->setSynchronized(true);
38	40
39	41	if (root != NULL)

trunk/src/world_entities/environments/water.cc

-                      r9406
+                      r9656
   // To test the Wave equation
   //this->wave(5.0,4.0, 1, 10);
   height_handle = registerVarId( new SynchronizeableFloat( &height, &height, "height" ) );
   resX_handle = registerVarId( new SynchronizeableUInt( &resX, &resX, "resX" ) );
   resY_handle = registerVarId( new SynchronizeableUInt( &resY, &resY, "resY" ) );
   sizeX_handle = registerVarId( new SynchronizeableFloat( &sizeX, &sizeX, "sizeX" ) );
   sizeY_handle = registerVarId( new SynchronizeableFloat( &sizeY, &sizeY, "sizeY" ) );
+  height_handle = registerVarId( new SynchronizeableFloat( &height, &height, "height", PERMISSION_MASTER_SERVER ) );
+  resX_handle = registerVarId( new SynchronizeableUInt( &resX, &resX, "resX", PERMISSION_MASTER_SERVER ) );
+  resY_handle = registerVarId( new SynchronizeableUInt( &resY, &resY, "resY", PERMISSION_MASTER_SERVER ) );
+  sizeX_handle = registerVarId( new SynchronizeableFloat( &sizeX, &sizeX, "sizeX", PERMISSION_MASTER_SERVER ) );
+  sizeY_handle = registerVarId( new SynchronizeableFloat( &sizeY, &sizeY, "sizeY", PERMISSION_MASTER_SERVER ) );
+}
 …
     this->rebuildGrid();
+  }
   WorldEntity::varChangeHandler( id );
+}

trunk/src/world_entities/npcs/ground_turret.cc

-                      r9406
+                      r9656
  */
 GroundTurret::GroundTurret(const TiXmlElement* root)
   : NPC(root)
+    : NPC(root)
+{
   this->init();
 …
 GroundTurret::~GroundTurret ()
+{
+}
 …
 /**
  * loads a GroundTurret from a XML-element
+ * @brief loads a GroundTurret from a XML-element
  * @param root the XML-element to load from
  * @todo make the class Loadable
 …
   // all the clases this Entity is directly derived from must be called in this way, to load all settings.
   NPC::loadParams(root);
   /**
 …
 void GroundTurret::tick(float dt)
+{
+  if(this->getHealth() > 0.0f && State::getPlayer() &&
+     State::getPlayer()->getPlayable() &&
+     State::getPlayer()->getPlayable()->distance(this) < 120) // HACK
+  if(this->getHealth() > 0.0f
+    ) // HACK <--- YOU ARE THE MOTHERFUCKER
+  {
   if (likely(this->left != NULL))
+  {
 //    this->left->tickW(dt);
     this->left->requestAction(WA_SHOOT);
+  }
   if (likely(this->right != NULL))
+  {
 //    this->right->tickW(dt);
     this->right->requestAction(WA_SHOOT);
+  }
+    if (likely(this->left != NULL))
+    {
+      //    this->left->tickW(dt);
+      this->left->requestAction(WA_SHOOT);
+    }
+    if (likely(this->right != NULL))
+    {
+      //    this->right->tickW(dt);
+      this->right->requestAction(WA_SHOOT);
+    }
+  }
+}
 …
 void GroundTurret::postSpawn ()
+{
+}
 …
 void GroundTurret::leftWorld ()
+{
+}

trunk/src/world_entities/npcs/ground_turret.h

-                      r9235
+                      r9656
+{
  public:
+public:
   GroundTurret(const TiXmlElement* root = NULL);
   virtual ~GroundTurret();
-  void init();
   virtual void loadParams(const TiXmlElement* root);
 …
   virtual void tick(float time);
+ private:
+   PNode  weaponHolder[2];
+   Weapon *left, *right;
+private:
+  void init();
+private:
+  PNode  weaponHolder[2];
+  Weapon *left, *right;
 };

trunk/src/world_entities/npcs/space_turret.cc

-                      r9235
+                      r9656
   this->weaponHolder[0].setParent(this);
   this->weaponHolder[1].setParent(this);
+  this->wLeftHandle = registerVarId( new SynchronizeableString( &this->wLeft, &this->wLeft, "weapon-left", PERMISSION_MASTER_SERVER ) );
+  this->wRightHandle = registerVarId( new SynchronizeableString( &this->wRight, &this->wRight, "weapon-right", PERMISSION_MASTER_SERVER ) );
+}
 …
   if (this->left)
+  {
+    this->wLeft = element->Value();
     this->left->setParent(this);
     this->left->toList(this->getOMListNumber());
 …
   if (this->right)
+  {
+    this->wRight = element->Value();
     this->right->setParent(this);
     this->right->toList(this->getOMListNumber());
 …
+  }
+}
+/**
+ * sets the left weapon called from net sync
+ * @param wLeft the left weapon string
+ */
+void SpaceTurret::setWeaponLeft(const std::string& wLeft)
+{
+}
+/**
+ * sets the left weapon called from net sync
+ * @param wRught the right weapon string
+ */
+void SpaceTurret::setWeaponRight(const std::string& wRight)
+{}
 /**
 …
+}
+/**
+ * handler for changes on registred vars
+ * @param id id's which changed
+ */
+void SpaceTurret::varChangeHandler( std::list< int > & id )
+{
+  if ( std::find( id.begin(), id.end(), this->wLeftHandle ) != id.end())
+  {
+    this->setWeaponLeft(this->wLeft);
+  }
+  if ( std::find( id.begin(), id.end(), this->wRightHandle ) != id.end() )
+  {
+    this->setWeaponRight(this->wRight);
+  }
+  WorldEntity::varChangeHandler( id );
+}

trunk/src/world_entities/npcs/space_turret.h

-                      r9235
+                      r9656
 #include "npcs/npc.h"
+#include <string>
+#include <list>
 class Weapon;
 …
   virtual void loadParams(const TiXmlElement* root);
+  virtual void varChangeHandler( std::list< int > & id );
+  void setWeaponLeft(const std::string& wLeft);
+  void setWeaponRight(const std::string& wRight);
   virtual void postSpawn ();
 …
   PNode  weaponHolder[2];
   Weapon *left, *right;
+  std::string wLeft;
+  std::string wRight;
+  int wLeftHandle;
+  int wRightHandle;
 };

trunk/src/world_entities/playable.cc

-                      r9406
+                      r9656
+  registerVar( new SynchronizeableInt( &score, &score, "score" ) );
+  this->teamChangeHandler = registerVarId( new SynchronizeableInt( &this->teamId, &this->teamId, "team-id", PERMISSION_MASTER_SERVER ) );
+  registerVar( new SynchronizeableInt( &score, &score, "score", PERMISSION_MASTER_SERVER ) );
   registerVar( new SynchronizeableBool( &bFire, &bFire, "bFire", PERMISSION_OWNER));
+}
 …
 bool Playable::addWeapon(Weapon* weapon, int configID, int slotID)
+{
+  weapon->setOwner(this->getOwner());
   if(this->weaponMan.addWeapon(weapon, configID, slotID))
+  {
 …
   return false;
+}
+/**
+ * @brief sets the TeamID and all the properties needed to be visible on the Playable
+ * @param teamID: the new TeamID of the Entity
+ */
+void Playable::setTeam(int teamID)
+{
+  /// Derive this function to make it look different with differen groups.
+  PRINTF(4)("No special team specific function implemented for %s::%s in Team %d\n", this->getClassCName(), this->getCName(), teamID);
+}
 /**
 …
   "FirstPerson"
 };
+/**
+ * handler for changes on registred vars
+ * @param id id's which changed
+ */
+void Playable::varChangeHandler( std::list< int > & id )
+{
+  if ( std::find( id.begin(), id.end(), this->teamChangeHandler) != id.end() )
+  {
+    this->setTeam(this->teamId);
+  }
+  WorldEntity::varChangeHandler(id);
+}

trunk/src/world_entities/playable.h

-                      r9406
+                      r9656
 #include "event.h"
 #include <vector>
+#include <list>
 #include "world_entities/weapons/weapon_manager.h"
 …
   virtual void loadParams(const TiXmlElement* root);
+  void varChangeHandler( std::list< int > & id );
   // Weapon and Pickups
 …
   inline const std::vector<int>& getEventList() { return this->events; };
   // Camera and Playmode
   void attachCamera();
 …
   void setPlayDirection(float angle, float dirX, float dirY, float dirZ, float speed = 0.0f);
+  // Networking interface
   inline void setScore( int score ) { this->score = score; }
   inline int  getScore() { return this->score; }
+  inline void setTeamId( int teamId) { this->teamId = teamId;}
+  inline int getTeamId() const { return this->teamId; }
+  virtual void setTeam(int teamID);
   void setEnterRadius(float radius) { this->enterRadius = radius; };
 …
   virtual void tick(float dt);
+  inline bool beFire() const { return this->bFire; }
+  inline void fire(bool bF) { this->bFire = bF;}
   // Transformations:
   static Playable::Playmode stringToPlaymode(const std::string& playmode);
   static const std::string& playmodeToString(Playable::Playmode playmode);
   static const std::string playmodeNames[];
-  inline bool beFire(){ return this->bFire; }
-  inline void fire(bool bF){ this->bFire = bF;}
 protected:
 …
   int                   score;              //!< players score
+  int                   teamChangeHandler;  //!< handler id for team changes network sync
+  int                   teamId;             //!< id of the current team
   bool                  bDead;
 …
   float                 enterRadius;        //!< How far one can be away from the Playable to enter it.
   WorldEntity* collider;
+  WorldEntity*          collider;
 };

trunk/src/world_entities/power_ups/param_power_up.cc

-                      r9406
+                      r9656
   if( root != NULL)
     this->loadParams(root);
   registerVar( new SynchronizeableInt( (int*)&type, (int*)&type, "type" ) );
   registerVar( new SynchronizeableFloat( &value, &value, "value" ) );
   registerVar( new SynchronizeableFloat( &max_value, &max_value, "max_value" ) );
   registerVar( new SynchronizeableFloat( &min_value, &min_value, "min_value" ) );
+  registerVar( new SynchronizeableInt( (int*)&type, (int*)&type, "type", PERMISSION_MASTER_SERVER ) );
+  registerVar( new SynchronizeableFloat( &value, &value, "value", PERMISSION_MASTER_SERVER ) );
+  registerVar( new SynchronizeableFloat( &max_value, &max_value, "max_value", PERMISSION_MASTER_SERVER ) );
+  registerVar( new SynchronizeableFloat( &min_value, &min_value, "min_value", PERMISSION_MASTER_SERVER ) );
+}

trunk/src/world_entities/projectiles/guided_missile.h

r9235	r9656
13	13	class ParticleEmitter;
14	14	class FastFactory;
15		~~class Aim;~~
16	15
17	16	class GuidedMissile : public Projectile

trunk/src/world_entities/projectiles/laser.cc

r9406	r9656
88	88	}
89	89
90		this->setDamage(0);
	90	this->setDamage(20);
91	91	this->setHealth(0);
92	92	}

trunk/src/world_entities/projectiles/projectile.cc

r9406	r9656
45	45	this->explosionBuffer = NULL;
46	46	this->engineBuffer = NULL;
	47
	48	//this->addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
47	49	}
48	50

trunk/src/world_entities/script_trigger.cc

r9406	r9656
49	49	*/
50	50	ScriptTrigger::ScriptTrigger(const TiXmlElement* root)
51		{ ~~PRINT(1)("testerror\n");~~
	51	{
52	52	this->setClassID(CL_SCRIPT_TRIGGER, "ScriptTrigger");
53	53	this->toList(OM_COMMON);

trunk/src/world_entities/skybox.cc

r9406	r9656
96	96	{
97	97	this->rebuild();
98
99		textureName_handle = registerVarId( new SynchronizeableString( &textureName, &textureName, "textureName") );
100		size_handle = registerVarId( new SynchronizeableFloat( &size, &size, "size" ) );
	98
	99	textureName_handle = registerVarId( new SynchronizeableString( &textureName, &textureName, "textureName", PERMISSION_MASTER_SERVER) );
	100	size_handle = registerVarId( new SynchronizeableFloat( &size, &size, "size", PERMISSION_MASTER_SERVER ) );
101	101	}
102	102
…	…
297	297	{
298	298	bool somethinChanged = false;
299
	299
300	300	if ( std::find( id.begin(), id.end(), textureName_handle ) != id.end() )
301	301	{
…	…
303	303	setTexture( textureName );
304	304	}
305
	305
306	306	if ( std::find( id.begin(), id.end(), size_handle ) != id.end() )
307	307	{
308	308	somethinChanged = true;
309	309	}
310
	310
311	311	rebuild();
312
	312
313	313	WorldEntity::varChangeHandler( id );
314	314	}

trunk/src/world_entities/space_ships/hover.cc

r9235	r9656
330	330	this->shiftCoor (this->velocity * dt);
331	331
332		// limit the maximum rotation speed.
	332	// limit the maximum rotation speed.
333	333	if (this->rotation != 0.0f)
334	334	{

trunk/src/world_entities/space_ships/space_ship.cc

r9494	r9656
234	234	this->burstSystem->setColor(1.0, .8,.8,.8,.0);
235	235
236		registerVar( new SynchronizeableVector( &velocity, &velocity, "velocity" ) );
	236	registerVar( new SynchronizeableVector( &velocity, &velocity, "velocity", PERMISSION_MASTER_SERVER ) );
237	237	registerVar( new SynchronizeableQuaternion( &mouseDir, &mouseDir, "mousedir", PERMISSION_OWNER ) );
238	238

trunk/src/world_entities/space_ships/turbine_hover.cc

-                      r9494
+                      r9656
   this->loadModel("models/ships/hoverglider_mainbody.obj");
+}
 …
   registerVar( new SynchronizeableFloat( &cameraLook, &cameraLook, "cameraLook", PERMISSION_OWNER ) );
   registerVar( new SynchronizeableFloat( &rotation, &rotation, "rotation", PERMISSION_OWNER ) );
+  if( State::isOnline())
+    toList( OM_PLAYERS );
+}
 …
+{
   Playable::loadParams(root);
+}
+void TurbineHover::setBoostColor(const Color& color)
+{
+  this->burstSystem->setColor(0.0, color);
+  this->burstSystem->setColor(0.2, color * 0.6);
+  this->burstSystem->setColor(0.5, color * .3 + Color(0.5, 0.5, 0.8, 0.3));
+  this->burstSystem->setColor(1.0, 0.8, 0.8, 0.8, 0.0);
+  printf(":::::::::::::::::::::::\n");
+  this->burstSystem->debug();
+}
 …
+}
+void TurbineHover::setTeam(int teamID)
+{
+  printf("::::::::::::::::: TEAM ::: %d\n", teamID);
+  if (teamID == 0)
+  {
+    this->setBoostColor(Color::blue);
+  }
+  else if (teamID == 1)
+  {
+    this->setBoostColor(Color::red);
+  }
+  ///HACK this is very much hard coded.set the owner of the weapons
+  this->getWeaponManager().getWeapon(0)->setOwner(this->getOwner());
+  this->getWeaponManager().getWeapon(1)->setOwner(this->getOwner());
+  //choose collision list
+  if( State::isOnline())
+  {
+    if( teamID == 0)
+      toList( OM_GROUP_00 );
+    else if(teamID == 1)
+      toList( OM_GROUP_01);
+  }
+  // set the local team id, very important
+  this->setTeamId(teamID);
+}
 …
+  }
+}
+/**
+ *  respawning function called by the GameRules
+ */
+void TurbineHover::respawn( )
+{
+  Playable::respawn();
+}

trunk/src/world_entities/space_ships/turbine_hover.h

-                      r8490
+                      r9656
 #include "playable.h"
+#include "color.h"
 // Forward Declaration
 …
     virtual ~TurbineHover();
+    void setBoostColor(const Color& color);
     virtual void loadParams(const TiXmlElement* root);
     virtual void setPlayDirection(const Quaternion& rot, float speed = 0.0f);
 …
     virtual void leave();
+    virtual void setTeam(int teamID);
     virtual void postSpawn();
     virtual void leftWorld();
+    virtual void respawn();
     virtual void collidesWith(WorldEntity* entity, const Vector& location);

trunk/src/world_entities/spawning_point.cc

-                      r9494
+                      r9656
 void SpawningPoint::sendRespawnMessage( int uniqueId )
+{
+#warning this byte array is not being deleted according to valginrd
+  byte * buf = new byte[2*INTSIZE];
+  byte buf[2*INTSIZE];
   assert( Converter::intToByteArray( this->getUniqueID(), buf, INTSIZE ) == INTSIZE );
   assert( Converter::intToByteArray( uniqueId, buf + INTSIZE, INTSIZE ) == INTSIZE );
+  MessageManager::getInstance()->sendMessage( MSGID_RESPAWN, buf, 2*INTSIZE, RT_ALL_BUT_ME, 0, MP_HIGHBANDWIDTH );
+}
+bool SpawningPoint::respawnMessageHandler( MessageId messageId, byte * data, int dataLength, void * someData, int userId )
+  MessageManager::getInstance()->sendMessage( MSGID_RESPAWN, buf, 2*INTSIZE, RT_ALL_BUT_ME, NET_UNASSIGNED, MP_HIGHBANDWIDTH );
+}
+/**
+ * message handler for respawn message
+ */
+bool SpawningPoint::respawnMessageHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId  )
+{
   if ( SharedNetworkData::getInstance()->isMasterServer() /*|| SharedNetworkData::getInstance()->isProxyServerActive()*/)

trunk/src/world_entities/spawning_point.h

r9494	r9656
70	70
71	71	void sendRespawnMessage( int uniqueId );
72		static bool respawnMessageHandler( Message~~Id messageId, byte * data, int dataLength, void * someData, int userId~~ );
	72	static bool respawnMessageHandler( MessageType messageType, byte * data, int dataLength, void * someData, int senderId, int destinationId );
73	73
74	74

trunk/src/world_entities/weapons/aim.cc

-                      r9406
+                      r9656
 Aim::~Aim ()
+{
-  if (this->material)
-    delete this->material;
 /*  if (this->text != NULL)
     delete this->text;*/
 …
   this->setBindNode(this);
-  this->material = new Material;
   this->source = NULL;
   this->range = 10000;
+  this->range = 1000;
   this->angle = M_PI_4;
   this->group = OM_GROUP_01;
+  this->targetGroup = OM_GROUP_01;
   this->anim = new tAnimation<Aim>(this, &Aim::setSize);
   this->anim->setInfinity(ANIM_INF_CONSTANT);
 …
   LoadParam(root, "rotation-speed", this, Aim, setRotationSpeed)
       .describe("the Speed with which the Aim should rotate");
+  LoadParam(root, "target-group", this, Aim, setTargetGroupS);
+}
 …
+{
   ObjectManager::EntityList::iterator entity;
   for (entity = State::getObjectManager()->getObjectList(group).begin();
        entity != State::getObjectManager()->getObjectList(group).end();
+  //printf("%d\n", this->targetGroup);
+  for (entity = State::getObjectManager()->getObjectList(this->targetGroup).begin();
+       entity != State::getObjectManager()->getObjectList(this->targetGroup).end();
        entity ++)
+  {
     diffVec = ( (*entity)->getAbsCoor() - this->source->getAbsCoor() );
     if ( diffVec.len() < range &&  acos( (this->source->getAbsDirX()).dot(diffVec)/(diffVec.len() * (this->source->getAbsDirX()).len() ) )  < angle)
+    if ( diffVec.len() < range )//&&  acos( (this->source->getAbsDirX()).dot(diffVec)/(diffVec.len() * (this->source->getAbsDirX()).len() ) )  < angle)
+    {
       //if (this->getParent() != (*entity))
+      {
+        printf("found target::: %d %s::%s\n", (*entity)->getOMListNumber(), (*entity)->getClassCName(), (*entity)->getCName());
         this->anim->replay();
         this->setParentSoft(*entity, 5);
 …
    //if no target found:
    this->setParent(PNode::getNullParent());
+}
+}
+void Aim::setTargetGroupS(const std::string& groupName)
+{
+  OM_LIST id = ObjectManager::StringToOMList(groupName);
+  if (id != OM_NULL)
+    this->setTargetGroup(id);
+  else
+    PRINTF(2)("List %s not found for targetting\n", groupName.c_str());
+}
 /**
 …
 void Aim::setTexture(const std::string& textureFile)
+{
   this->material->setDiffuseMap(textureFile);
+  this->material.setDiffuseMap(textureFile);
+}
 …
 //only look for target if the aim hasn`t locked a target yet or if the actual target is out of range
    if(this->getParent() == PNode::getNullParent() ||
       diffVec.len() > range  ||
      ( acos( (this->source->getAbsDirX()).dot(diffVec)/(diffVec.len() * (this->source->getAbsDirX()).len() ) ) > angle))
+      diffVec.len() > range )// ||
+     //( acos( (this->source->getAbsDirX()).dot(diffVec)/(diffVec.len() * (this->source->getAbsDirX()).len() ) ) > angle))
+    {
      this->setParentSoft(PNode::getNullParent(),5);
 …
   glRotatef(this->getAbsDir2D(), 0,0,1);
   this->material->select();
+  this->material.select();
   glBegin(GL_TRIANGLE_STRIP);
   glTexCoord2f(0, 0);

trunk/src/world_entities/weapons/aim.h

-                      r7221
+                      r9656
 #include "object_manager.h"
+#include "material.h"
 // FORWARD DECLARATION
 class Model;
 class Text;
-class Material;
 class TiXmlElement;
 template<class T> class tAnimation;
 …
  * Also the Aim is a Element2D, as it draws a cross onto the Target.
  */
+class Aim : public PNode, public Element2D {
+class Aim : public PNode, public Element2D
+{
  public:
+public:
   Aim(PNode* source, const TiXmlElement* root = NULL);
   virtual ~Aim();
-  void init();
   virtual void loadParams(const TiXmlElement* root);
 …
   inline void selectTarget(PNode* target) { this->setParent(target); };
   inline PNode* getTarget(PNode* target) { return this->getParent(); };
+  inline PNode* getTarget(PNode* target) const { return this->getParent(); };
   void searchTarget();
+  void setRange(float range){this->range = range;};
+  void setAngle(float angle){this->angle = angle;};
+  void setGroup(OM_LIST group){this->group = group;};
+  void setRange(float range) {this->range = range;};
+  void setAngle(float angle) {this->angle = angle;};
+  void setTargetGroup(OM_LIST group) { this->targetGroup = group; };
+  void setTargetGroupS(const std::string& grounName);
   void setSize(float size);
 …
   virtual void draw() const;
+ private:
+   Material*        material;             //!< a material for the Aim.
+   float            rotationSpeed;        //!< Speed of the Rotation.
+   tAnimation<Aim>* anim;
+private:
+  void init();
-   float            range;                //!<
-   float            angle;                //!<
-   Vector           diffVec;
-   OM_LIST          group;
+   PNode*           source;               //!< Where this Shot has come from.
+private:
+  Material         material;             //!< a material for the Aim.
+  float            rotationSpeed;        //!< Speed of the Rotation.
+  tAnimation<Aim>* anim;
+   Text*            text;                 //!< A Text to display onto this Node. (distance to Target)
+  float            range;                //!<
+  float            angle;                //!<
+  Vector           diffVec;
+  OM_LIST          targetGroup;
+  PNode*           source;               //!< Where this Shot has come from.
+  //   Text             text;                 //!< A Text to display onto this Node. (distance to Target)
 };

trunk/src/world_entities/weapons/aiming_turret.cc

-                      r9406
+                      r9656
 */
 AimingTurret::AimingTurret ()
   : Weapon()
+    : Weapon(), target(this)
+{
   this->init();
 …
 AimingTurret::AimingTurret(const TiXmlElement* root)
+    : target(this)
+{
   this->init();
 …
+{
   // model will be deleted from WorldEntity-destructor
 //  delete this->target;
+  //  delete this->target;
+}
 …
   //this->getProjectileFactory()->prepare(100);
   this->target = new Aim(this);
   this->target->setVisibility(false);
   this->target->setRange(400);
   this->target->setAngle(M_PI_2);
+  this->target.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT | PNODE_PROHIBIT_CHILD_DELETE);
+  this->target.setVisibility(false);
+  this->target.setRange(400);
+  this->target.setAngle(M_PI_2);
   this->setActionSound(WA_SHOOT, "sound/explosions/explosion_3.wav");
 …
 void AimingTurret::activate()
+{
   this->target->setVisibility(true);
+  this->target.setVisibility(true);
+}
 void AimingTurret::deactivate()
+{
   this->target->setVisibility(false);
+  this->target.setVisibility(false);
+}
 …
     return;
   Quaternion quat;
   Vector direction = this->target->getAbsCoor() - this->getAbsCoor();
+  Vector direction = this->target.getAbsCoor() - this->getAbsCoor();
   direction.normalize();
   if (likely (this->getParent() != NULL))
+    quat = Quaternion(direction, this->getParent()->getAbsDir().apply(Vector(0,1,0))) * Quaternion ( -M_PI_2, Vector(0,1,0)) ;
+    //quat = Quaternion(direction, this->getParent()->getAbsDirY()) * Quaternion ( -M_PI_2, Vector(0,1,0)) ;
+    quat = Quaternion ( M_PI_2, this->getParent()->getAbsDirY()) * Quaternion::lookAt(this->getAbsCoor(), this->target.getAbsCoor(), this->getParent()->getAbsDirY());
   else
+    quat = Quaternion(direction, Vector(0,1,0)) * Quaternion ( -M_PI_2, Vector(0,1,0)) ;
+    //quat = Quaternion(direction, Vector(0,1,0)) * Quaternion ( -M_PI_2, Vector(0,1,0)) ;
+    quat = Quaternion ( M_PI_2, Vector(0,1,0)) * Quaternion::lookAt(this->getAbsCoor(), this->target.getAbsCoor(), Vector(0,1,0));
   this->setAbsDirSoft(quat, 5);
   this->target->tick(dt);
+  this->target.tick(dt);
+}
 …
     return;
   pj->setVelocity(/*this->getVelocity()+*/(this->getAbsDir().apply(Vector(1,0,0))*250.0 + VECTOR_RAND(13)
             /*target->getAbsCoor() - this->getAbsCoor()*/)*.5);//this->getVelocity());
+  pj->setVelocity(/*this->getVelocity()+*/(this->getAbsDirX()*250.0 + VECTOR_RAND(4)
+                                          /*target.getAbsCoor() - this->getAbsCoor()*/)*.5);//this->getVelocity());
   pj->setParent(PNode::getNullParent());

trunk/src/world_entities/weapons/aiming_turret.h

-                      r8777
+                      r9656
 #include "weapon.h"
+#include "aim.h"
 /* FORWARD DECLARATION */
-class Aim;
 class AimingTurret : public Weapon
+  {
   public:
     AimingTurret ();
     AimingTurret(const TiXmlElement* root);
     virtual ~AimingTurret ();
+{
+public:
+  AimingTurret ();
+  AimingTurret(const TiXmlElement* root);
+  virtual ~AimingTurret ();
+    void init();
+    virtual void loadParams(const TiXmlElement* root);
+  virtual void loadParams(const TiXmlElement* root);
+    virtual void activate();
+    virtual void deactivate();
+  void setTargetGroup(OM_LIST targetGroup) { this->target.setTargetGroup(targetGroup); };
+    virtual void tick(float dt);
+    virtual void fire();
+  virtual void activate();
+  virtual void deactivate();
+  virtual void tick(float dt);
+  virtual void fire();
     virtual void draw() const;
+  virtual void draw() const;
+  private:
+    Aim*          target;
+  };
+private:
+  void init();
+private:
+  Aim           target;
+};
 #endif /* _AIMING_TURRET_H */

trunk/src/world_entities/weapons/laser_cannon.cc

-                      r9235
+                      r9656
     return;
+  // make this to let the onKill(...) fuction get the stuff
+  pj->setOwner(this->getOwner());
   pj->setParent(PNode::getNullParent());

trunk/src/world_entities/weapons/targeting_turret.cc

-                      r9406
+                      r9656
 #include "targeting_turret.h"
+#include "weapon_manager.h"
+#include "aim.h"
+#include "world_entities/projectiles/projectile.h"
+#include "projectiles/projectile.h"
 #include "model.h"
 …
 #include "animation3d.h"
+#include "util/loading/load_param.h"
 #include "util/loading/factory.h"
 …
-/**
- *  standard constructor
-   creates a new weapon
-*/
-TargetingTurret::TargetingTurret ()
-  : Weapon()
+{
-  this->init();
+}
 TargetingTurret::TargetingTurret(const TiXmlElement* root)
+  : target(this)
+{
   this->init();
 …
   //this->getProjectileFactory()->prepare(100);
   this->target = new Aim(this);
   this->target->setVisibility(false);
   this->target->setRange(1000);
   this->target->setAngle(M_PI_4);
   this->lockedTarget = this->target;
+  this->target.setVisibility(false);
+  this->target.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT | PNODE_PROHIBIT_CHILD_DELETE);
+  this->target.setRange(1000);
+  this->target.setAngle(M_PI_4);
+  this->lockedTarget = &this->target;
   this->lockedTime = 0;
 …
   Weapon::loadParams(root);
+  LoadParam(root, "target-group", &target, Aim, setTargetGroupS);
+}
 …
 void TargetingTurret::deactivate()
+{
   this->target->setVisibility(false);
+  this->target.setVisibility(false);
+}
 …
     return;
+  this->target.tick(dt);
   if( lockedTime >= neededLockTime )
+   {
     lockedTarget = this->target->getParent();
+    lockedTarget = this->target.getParent();
     lockedTime = 0;
+   }
-  this->target->tick(dt);
   if(this->target->getParent() == PNode::getNullParent())
+  if(this->target.getParent() == PNode::getNullParent())
    lockedTime = 0;
   else
 …
   pj->setAbsDir(this->getAbsDir());
   pj->activate();
+}

trunk/src/world_entities/weapons/targeting_turret.h

-                      r8777
+                      r9656
 #include "weapon.h"
+/* FORWARD DECLARATION */
+class Aim;
+#include "aim.h"
 class TargetingTurret : public Weapon
+  {
+  public:
+    TargetingTurret ();
+    TargetingTurret(const TiXmlElement* root);
+    virtual ~TargetingTurret ();
+{
+public:
+  TargetingTurret(const TiXmlElement* root = NULL);
+  virtual ~TargetingTurret ();
+    void init();
+    virtual void loadParams(const TiXmlElement* root);
+  virtual void loadParams(const TiXmlElement* root);
     virtual void activate();
     virtual void deactivate();
+  virtual void activate();
+  virtual void deactivate();
     virtual void tick(float dt);
     virtual void fire();
+  virtual void tick(float dt);
+  virtual void fire();
     virtual void draw() const;
+  virtual void draw() const;
+  private:
+    Aim*           target;
+    PNode*         lockedTarget;
+    float          lockedTime;
+    float          neededLockTime;
+  };
+  void setTargetGroup(OM_LIST targetGroup) { this->target.setTargetGroup(targetGroup); };
+  const PNode* getLockedTarget() const { return lockedTarget; };
+private:
+  void init();
+private:
+  Aim            target;
+  PNode*         lockedTarget;
+  float          lockedTime;
+  float          neededLockTime;
+};
 #endif /* _TARGETING_TURRET_H */

trunk/src/world_entities/weapons/test_gun.cc

-                      r9002
+                      r9656
   if (pj == NULL)
     return;
+  // set the owner
+  pj->setOwner(this->getOwner());
   pj->setParent(PNode::getNullParent());

trunk/src/world_entities/world_entity.cc

-                      r9494
+                      r9656
 #include "util/loading/resource_manager.h"
 #include "util/loading/load_param.h"
-#include "vector.h"
 #include "obb_tree.h"
 …
   this->toList(OM_NULL);
   registerVar( new SynchronizeableString( &this->md2TextureFileName, &this->md2TextureFileName, "md2TextureFileName" ) );
   modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName" ) );
   scaling_handle = registerVarId( new SynchronizeableFloat( &scaling, &scaling, "scaling" ) );
   list_handle = registerVarId( new SynchronizeableInt( (int*)&objectListNumber, &list_write, "list" ) );
   health_handle = registerVarId( new SynchronizeableFloat( &this->health, &this->health_write, "health" ) );
   healthMax_handle = registerVarId( new SynchronizeableFloat( &this->healthMax, &this->healthMax_write, "maxHealth" ) );
+  registerVar( new SynchronizeableString( &this->md2TextureFileName, &this->md2TextureFileName, "md2TextureFileName", PERMISSION_MASTER_SERVER ) );
+  modelFileName_handle = registerVarId( new SynchronizeableString( &modelFileName, &modelFileName, "modelFileName", PERMISSION_MASTER_SERVER ) );
+  scaling_handle = registerVarId( new SynchronizeableFloat( &scaling, &scaling, "scaling", PERMISSION_MASTER_SERVER ) );
+  list_handle = registerVarId( new SynchronizeableInt( (int*)&objectListNumber, &list_write, "list", PERMISSION_MASTER_SERVER ) );
+  health_handle = registerVarId( new SynchronizeableFloat( &this->health, &this->health_write, "health", PERMISSION_MASTER_SERVER ) );
+  healthMax_handle = registerVarId( new SynchronizeableFloat( &this->healthMax, &this->healthMax_write, "maxHealth", PERMISSION_MASTER_SERVER ) );
+}
 …
   .describe("The Health the WorldEntity has at this moment")
   .defaultValues(1.0f);
+  LoadParam(root, "list", this, WorldEntity, toListS);
+}
 …
+}
+void WorldEntity::toListS(const std::string& listName)
+{
+  OM_LIST id = ObjectManager::StringToOMList(listName);
+  if (id != OM_NULL)
+    this->toList(id);
+  else
+    PRINTF(2)("List %s not found\n", listName.c_str());
+}
 void WorldEntity::toReflectionList()
+{
 …
   PRINT(0)("WorldEntity %s::%s  (DEBUG)\n", this->getClassCName(), this->getCName());
   this->debugNode();
   PRINT(0)("List: %s ; ModelCount %d - ", ObjectManager::OMListToString(this->objectListNumber) , this->models.size());
+  PRINT(0)("List: %s ; ModelCount %d - ", ObjectManager::OMListToString(this->objectListNumber).c_str(), this->models.size());
   for (unsigned int i = 0; i < this->models.size(); i++)
+  {

trunk/src/world_entities/world_entity.h

r9298	r9656
115	115	/* --- Object Manager Block --- */
116	116	void toList(OM_LIST list);
	117	void toListS(const std::string& listName);
117	118
118	119	void toReflectionList();

Context Navigation

Changeset 9656 in orxonox.OLD

Legend:

Download in other formats: