source: orxonox.OLD/branches/presentation/src/util/hud.cc @ 10768

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

   Copyright (C) 2004 orx

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

   ### File Specific:
   main-programmer: Benjamin Grauer
   co-programmer: Benjamin Knecht
*/

//#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_

#include "hud.h"

#include "state.h"
#include "debug.h"

#include "world_entities/weapons/weapon_manager.h"
#include "glgui.h"
#include "glgui_widget.h"
#include "glgui_box.h"
#include "glgui_bar.h"
#include "elements/glgui_energywidgetvertical.h"

#include "glgui_inputline.h"
#include "specials/glgui_notifier.h"
#include "elements/glgui_radar.h"
#include "world_entities/space_ships/space_ship.h"

#include "tools/camera.h"
#include "multi_type.h"




/// HACK
#include "player.h"
#include "playable.h"

ObjectListDefinition(Hud);
/**
 * standard constructor
 * @todo this constructor is not jet implemented - do it
*/
Hud::Hud ()
{
  this->registerObject(this, Hud::_objectList);

  //this->setSize2D(
  this->playmode = Full3D;
  this->weaponManager = NULL;
  this->weaponManagerSecondary = NULL;
  this->energyWidget = NULL;
  this->shieldWidget = NULL;
  this->healthWidget = NULL;
  this->leftRect = NULL;
  this->rightRect = NULL;
  this->resX = 1;
  this->resY = 1;
  this->leftHit = NULL;
  this->rightHit = NULL;
  this->ifinit = true;
  this->hidden = false;
  
  this->barSocket = NULL;
  this->_radar = NULL;
  this->inputLine = NULL;
  this->notifier = NULL;
  this->topRect = NULL;
  this->bottomRect = NULL;
  this->middleRect = NULL;

  this->init();

  
}


/**
 * standard deconstructor
*/
Hud::~Hud ()
{
  if (this->inputLine) delete this->inputLine;
  if (this->notifier) delete this->notifier;
  if (this->leftHit) delete this->leftHit;
  if (this->rightHit) delete this->rightHit;

  if (this->_radar) delete this->_radar;
  if (this->barSocket) delete this->barSocket;
  if (this->rightRect) delete this->rightRect;
  if (this->leftRect) delete this->leftRect;
  if (this->topRect) delete this->topRect;
  if (this->bottomRect) delete this->bottomRect;
  if (this->middleRect) delete this->middleRect;
  

  //if (this->shipValuesBox != NULL)
    //delete this->shipValuesBox;

  // delete what has to be deleted here
}

void Hud::init()
{
        this->overlayPercentage = 40;
        this->overlayActive = false;
        this->rightRect = new OrxGui::GLGuiImage();
        this->leftRect = new OrxGui::GLGuiImage();
        this->topRect = new OrxGui::GLGuiImage();
        this->bottomRect = new OrxGui::GLGuiImage();
        this->middleRect = new OrxGui::GLGuiImage();

        this->inputLine = new OrxGui::GLGuiInputLine();
        this->inputLine->setParent2D(this);
        this->notifier = new OrxGui::GLGuiNotifier();
        this->notifier->setParent2D(this);
        notifier->setAbsCoor2D(100,100);
        

        
        this->_radar = new OrxGui::GLGuiRadar();
        this->radarCenterNode = NULL;
        
        this->subscribeEvent(ES_ALL, EV_VIDEO_RESIZE);
        this->subscribeEvent(ES_ALL, SDLK_TAB);
  
        if (this->playmode == FirstPerson)
        {
                /*this->topHit = new OrxGui::GLGuiImage();
                this->topHit->loadImageFromFile("textures/gui/gui_hitbar.png");
                this->topHit->setParent2D(this->middleRect);
                this->topHit->setAbsDir2D(-1.5708);
                
                this->bottomHit = new OrxGui::GLGuiImage();
                this->bottomHit->loadImageFromFile("textures/gui/gui_hitbar.png");
                this->bottomHit->setParent2D(this->middleRect);
                this->bottomHit->setAbsDir2D(1.5708);*/

                this->barSocket = new OrxGui::GLGuiImage();
                this->barSocket->loadImageFromFile("textures/gui/gui_barSocket.png");
                this->barSocket->setParent2D(this->bottomRect);
                
                this->leftHit = new OrxGui::GLGuiImage();
                this->leftHit->loadImageFromFile("textures/gui/gui_hitbarl.png");
                this->leftHit->setParent2D(this->middleRect);
                
                
                this->rightHit = new OrxGui::GLGuiImage();
                this->rightHit->loadImageFromFile("textures/gui/gui_hitbar.png");
                this->rightHit->setParent2D(this->middleRect);
                
                this->healthText = new OrxGui::GLGuiText();
                this->healthText->setParent2D(this->barSocket);
                
                this->shieldText = new OrxGui::GLGuiText();
                this->shieldText->setParent2D(this->barSocket);
                
                
                this->leftRect->setParent2D(this);
                this->rightRect->setParent2D(this);
        }

  //this->shipValuesBox = NULL;
}


void Hud::loadParams(const TiXmlElement* root)
{
  Element2D::loadParams(root);
}

void Hud::notifyUser(const std::string& message)
{
  this->notifier->pushNotifyMessage(message);
}

void Hud::setBackGround()
{}

void Hud::setEnergyWidget(OrxGui::GLGuiWidget* widget)
{
  //if (this->shipValuesBox == NULL)
    //this->createShipValuesBox();

  // decopple old widget
  if (this->energyWidget != NULL)
  {
    this->energyWidget->hide();
  }

  this->energyWidget = widget;
  if (this->energyWidget != NULL)
  {
    //this->energyWidget->shiftDir2D(270);
    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->energyWidget)->setDisplayedName("Electronics");
    //this->shipValuesBox->pack(this->energyWidget);
    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->energyWidget)->setStandardSettings();
    this->energyWidget->setParent2D(this->leftRect);
    dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->energyWidget)->setDisplayedImage("textures/gui/gui_electronics_icon.png");
    if (!this->hidden)
        this->energyWidget->show();
    else
        this->energyWidget->hide();
    /*    this->energyWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
        this->energyWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
  }

  this->updateResolution();  
}

void Hud::setShieldWidget(OrxGui::GLGuiWidget* widget)
{
        if( this->playmode == FirstPerson )
        {
                this->shieldWidget = new OrxGui::GLGuiBar();
                dynamic_cast<OrxGui::GLGuiBar*> (this->shieldWidget)->setMaximum(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (widget)->getBarWidget()->maximum());
                dynamic_cast<OrxGui::GLGuiBar*> (this->shieldWidget)->setValue(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (widget)->getBarWidget()->value());
                this->shieldWidget->setBackgroundTexture(Texture());
                this->shieldWidget->setBackgroundColor(Color(0,0,0,0));
                this->shieldWidget->setForegroundTexture("textures/gui/gui_element_background_faded.png");
                this->shieldWidget->setForegroundColor(Color(1,1,0,0.5));
                dynamic_cast<OrxGui::GLGuiBar*>(this->shieldWidget)->setChangedValueColor(Color(1,0,0,0.2));
                this->shieldWidget->setWidgetSize(150,40);
                this->shieldWidget->setRelDir2D(180);
                this->shieldWidget->setParent2D(this->barSocket);
                
                this->shieldText->setTextSize(50);
                this->shieldText->setChangedTextColor(Color::white);
                this->shieldText->setForegroundColor(Color(1,1,0,1));
                this->shieldText->setBackgroundTexture(Texture());
                this->shieldText->setBackgroundColor(Color(0,0,0,0));
                MultiType val(dynamic_cast<OrxGui::GLGuiBar*>(this->shieldWidget)->value());
                val.setType(MT_INT);
                this->shieldText->setText(val.getString());
        }
        else
        {
        /*
        if (this->shipValuesBox == NULL)
        this->createShipValuesBox();
        */
        
        // decopple old widget
        if (this->shieldWidget != NULL)
        {
        this->shieldWidget->hide();
        }
        
        this->shieldWidget = widget;
        if (this->shieldWidget != NULL)
        {
        //this->shieldWidget->shiftDir2D(270);
        //this->shipValuesBox->pack(this->shieldWidget);
        //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->shieldWidget)->setStandardSettings();
        this->shieldWidget->setParent2D(this->leftRect);
        dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->shieldWidget)->setDisplayedImage("textures/gui/gui_shield_icon.png");
        if (!this->hidden)
                this->shieldWidget->show();
        else
                this->shieldWidget->hide();
        /*    this->shieldWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
                this->shieldWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
        }
        else
        printf("schild im hud nicht uebergeben!!!!!!!!!!!!!!!!!!!!!!!!!");
  }

  this->updateResolution();
}

void Hud::setHealthWidget(OrxGui::GLGuiWidget* widget)
{
        if( this->playmode == FirstPerson )
        {
                this->healthWidget = new OrxGui::GLGuiBar();
                dynamic_cast<OrxGui::GLGuiBar*> (this->healthWidget)->setMaximum(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (widget)->getBarWidget()->maximum());
                dynamic_cast<OrxGui::GLGuiBar*> (this->healthWidget)->setValue(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (widget)->getBarWidget()->value());
                this->healthWidget->setBackgroundTexture(Texture());
                this->healthWidget->setBackgroundColor(Color(0,0,0,0));
                this->healthWidget->setForegroundTexture("textures/gui/gui_element_background_faded.png");
                this->healthWidget->setForegroundColor(Color::red);
                dynamic_cast<OrxGui::GLGuiBar*>(this->healthWidget)->setChangedValueColor(Color(1,0,0,0.2));
                this->healthWidget->setWidgetSize(150,20);
                this->healthWidget->setRelDir2D(180);
                this->healthWidget->setParent2D(this->barSocket);

                this->healthText->setTextSize(80);
                this->healthText->setChangedTextColor(Color::white);
                this->healthText->setForegroundColor(Color::red);
                this->healthText->setBackgroundTexture(Texture());
                this->healthText->setBackgroundColor(Color(0,0,0,0));
                MultiType val(dynamic_cast<OrxGui::GLGuiBar*>(this->healthWidget)->value());
                val.setType(MT_INT);
                this->healthText->setText(val.getString());
        }
        else
        {
          /*
          if (this->shipValuesBox == NULL)
            this->createShipValuesBox();
          */
        
        // decopple old widget
          if (this->healthWidget != NULL)
          {
            this->healthWidget->hide();
          }
        
          this->healthWidget = widget;
          if (this->healthWidget != NULL)
          {
            //this->healthWidget->shiftDir2D(270);
            //this->shipValuesBox->pack(this->healthWidget);
            //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->healthWidget)->setStandardSettings();
            this->healthWidget->setParent2D(this->leftRect);
            dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->healthWidget)->setDisplayedImage("textures/gui/gui_health_icon.png");
            if(!this->hidden)
                this->healthWidget->show();
            else
                this->healthWidget->hide();
            /*    this->healthWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
                this->healthWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
          }
        }

  this->updateResolution();
}


void Hud::setImplantWidget(OrxGui::GLGuiWidget* widget)
{
  //if (this->shipValuesBox == NULL)
    //this->createShipValuesBox();

  // decopple old widget
  if (this->implantWidget != NULL)
  {
    this->implantWidget->hide();
  }

  this->implantWidget = widget;
  if (this->implantWidget != NULL)
  {
    //this->energyWidget->shiftDir2D(270);
    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->energyWidget)->setDisplayedName("Electronics");
    //this->shipValuesBox->pack(this->energyWidget);
    //dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->energyWidget)->setStandardSettings();
    this->implantWidget->setParent2D(this->leftRect);
    dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (this->implantWidget)->setDisplayedImage("textures/gui/gui_electronics_icon.png");
    if (!this->hidden)
        this->implantWidget->show();
    else
        this->implantWidget->hide();
    /*    this->energyWidget->frontMaterial().setDiffuseMap("hud_energy_bar.png");
        this->energyWidget->frontMaterial().setBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);*/
  }

  this->updateResolution();
}

void Hud::setWeaponManager(WeaponManager* weaponMan, WeaponManager* weaponManSec)
{
  //clearWeaponManager();

  //Hide all widgets
  if (this->weaponManager != NULL)
  {
    for (unsigned int i = 0; i < this->weaponManager->getSlotCount(); i++)
    {
      Weapon* weapon = this->weaponManager->getWeapon(i);
      if (weapon != NULL)
      {
        weapon->getEnergyWidget()->hide();
        //this->weaponsWidgetsPrim.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
      }
    }
  }

  if (this->weaponManagerSecondary != NULL)
  {
    for (unsigned int i = 0; i < this->weaponManagerSecondary->getSlotCount(); i++)
    {
      Weapon* weapon = this->weaponManagerSecondary->getWeapon(i);
      if (weapon != NULL)
      {
        weapon->getEnergyWidget()->hide();
        //this->weaponsWidgetsSec.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
      }
    }
  }

  this->weaponManager = weaponMan;
  this->weaponManagerSecondary = weaponManSec; 

  this->updateWeaponManager();
  //  this->updateResolution();
}

/*
void Hud::clearWeaponManager()
{
  //Hide all widgets
  if (this->weaponManager != NULL)
  {
    for (unsigned int i = 0; i < this->weaponManager->getSlotCount(); i++)
    {
      Weapon* weapon = this->weaponManager->getWeapon(i);
      if (weapon != NULL)
      {
        weapon->getEnergyWidget()->hide();
        //this->weaponsWidgetsPrim.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
      }
    }
  }

  if (this->weaponManagerSecondary != NULL)
  {
    for (unsigned int i = 0; i < this->weaponManagerSecondary->getSlotCount(); i++)
    {
      Weapon* weapon = this->weaponManagerSecondary->getWeapon(i);
      if (weapon != NULL)
      {
        weapon->getEnergyWidget()->hide();
        //this->weaponsWidgetsSec.remove(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
      }
    }
  }

  //this->weaponsWidgetsPrim.clear();
  //this->weaponsWidgetsSec.clear();
}
*/

void Hud::setMode(Hud::Playmode playmode)
{
        this->playmode = playmode;
        this->init();
}

void Hud::updateWeaponManager()
{
  // hide all the Widgets
  
  std::list<OrxGui::GLGuiEnergyWidgetVertical*>::iterator weaponWidget;
  for (weaponWidget = this->weaponsWidgetsPrim.begin(); weaponWidget != this->weaponsWidgetsPrim.end(); weaponWidget++)
  {
    (*weaponWidget)->hide();
  }
  this->weaponsWidgetsPrim.clear();

  for (weaponWidget = this->weaponsWidgetsSec.begin(); weaponWidget != this->weaponsWidgetsSec.end(); weaponWidget++)
  {
    (*weaponWidget)->hide();
  }
  this->weaponsWidgetsSec.clear();
  

  // add all that we need again.

  if (this->weaponManager != NULL)
    for (unsigned int i = 0; i < this->weaponManager->getSlotCount(); i++)
    {
      Weapon* weapon = this->weaponManager->getWeapon(i);
      if (weapon != NULL)
      {
        //PRINTF(0)("WEAPON %s::%s in Slots\n", weapon->getClassCName(), weapon->getName());
        if (this->playmode != FirstPerson)
                weapon->getEnergyWidget()->setParent2D(this->rightRect);
        else
                weapon->getEnergyWidget()->setParent2D(this->bottomRect);
        if (!this->hidden)
                weapon->getEnergyWidget()->show();
        else
                weapon->getEnergyWidget()->hide();
        weapon->getEnergyWidget()->setBackgroundColor(Color(.8,.2,.11, 0.1));
        weapon->getEnergyWidget()->setFrontColor(Color( .2,.5,.7,.6));
        weapon->getEnergyWidget()->setWidgetSize(120,30);
        //weapon->getEnergyWidget()->frontMaterial().setTransparency(.6);
        this->weaponsWidgetsPrim.push_back(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
      }
    }

  if (this->weaponManagerSecondary != NULL)
    for (unsigned int i = 0; i < this->weaponManagerSecondary->getSlotCount(); i++)
    {
      Weapon* weapon = this->weaponManagerSecondary->getWeapon(i);
      if (weapon != NULL)
      {
        //PRINTF(0)("WEAPON %s::%s in Slots\n", weapon->getClassCName(), weapon->getName());
        weapon->getEnergyWidget()->setParent2D(this->rightRect);
                if (!this->hidden)
                weapon->getEnergyWidget()->show();
        else
                weapon->getEnergyWidget()->hide();
        weapon->getEnergyWidget()->setBackgroundColor(Color(.8,.2,.11, 0.1));
        weapon->getEnergyWidget()->setFrontColor(Color( .2,.5,.7,.6));
        weapon->getEnergyWidget()->setWidgetSize(150,50);
        //weapon->getEnergyWidget()->frontMaterial().setTransparency(.6);
        this->weaponsWidgetsSec.push_back(dynamic_cast<OrxGui::GLGuiEnergyWidgetVertical*> (weapon->getEnergyWidget()));
      }
    }

  this->updateResolution();

}

void Hud::addWeaponWidget(OrxGui::GLGuiWidget* widget)
{}

void Hud::removeWeaponWidget(OrxGui::GLGuiWidget* widget)
{}

void Hud::getHit()
{
        this->leftHit->show();
        this->rightHit->show();
        hitBarCount = 0.33;
}

void Hud::tick(float dt)
{

  if (this->playmode == FirstPerson && this->leftHit != NULL)
  {
        if (this->ifinit)
        {
                this->leftHit->shiftDir2D(3.1416);
                this->ifinit = false;
        }
        if (this->leftHit->isVisible())
        {
                hitBarCount -= dt;
        }
        if (hitBarCount <= 0)
        {
                hitBarCount = 0;
                this->leftHit->hide();
                this->rightHit->hide();
        }
  }
  //Crosshair* crosshair = dynamic_cast<Crosshair*>(this->weaponManager->getFixedTarget());
  if ((State::getCamera())->getName() == "GameWorldCamera")
  {
        this->hidden = false;
        if(this->weaponManager)
                this->weaponManager->showCrosshair();
  }
  else
  {
        this->hidden = true;
        if(this->weaponManager)
                this->weaponManager->hideCrosshair();
  }
  this->updateResolution();
}

void Hud::updateResolution()
{
  this->resX = State::getResX();
  this->resY = State::getResY();

  this->setSize2D(this->resX, this->resY);
  if( this->playmode != FirstPerson )
  {
          this->notifier->setAbsCoor2D(0.7 * this->resX, 0.3 * this->resY);
          this->notifier->setWidgetSize(0.25 * this->resX, 0.6 * this->resY);
  }

  int overlayWidth = 0;
  if (overlayPercentage >= 20)
    overlayWidth = this->resX * (overlayPercentage)/(200);
  else
    overlayWidth = this->resX / 10; // fixed warning!
  //if (overlayWidth < 100)
    //overlayWidth = 100;

  this->rightRect->hide();
  this->leftRect->hide();
  
  if( this->playmode != FirstPerson )
  {
          
          this->leftRect->setWidgetSize(float(overlayWidth), float(this->resY));
          this->leftRect->setAbsCoor2D(0,0);
          this->leftRect->setBackgroundTexture(Texture());
          this->leftRect->setBackgroundColor(Color(0,0,0.7,0.2));
          this->leftRect->setForegroundTexture(Texture());
          this->leftRect->setForegroundColor(Color(0,0,0,0));
          
          this->rightRect->setWidgetSize(float(overlayWidth), float(this->resY));
          this->rightRect->setAbsCoor2D(this->resX - overlayWidth,0);
          this->rightRect->setBackgroundTexture(Texture());
          this->rightRect->setBackgroundColor(Color(0,0,0.7,0.2));
          this->rightRect->setForegroundTexture(Texture());
          this->rightRect->setForegroundColor(Color(0,0,0,0));
  }
  else
  {
        this->bottomRect->setParent2D(this);
        this->bottomRect->setWidgetSize(float(this->resX), float(overlayWidth));
        this->bottomRect->setAbsCoor2D(0, this->resY - overlayWidth);
        //this->bottomRect->show();
        
        this->topRect->setParent2D(this);
        this->topRect->setWidgetSize(float(this->resX), float(overlayWidth));
        this->topRect->setAbsCoor2D(0, 0);
        //this->topRect->show();
        
        this->middleRect->setParent2D(this);
        this->middleRect->setWidgetSize(float(this->resY)/2, float(this->resY)/2);
        this->middleRect->setAbsCoor2D(float(this->resX)/4, float(this->resY)/4/*float(this->resX/2), float(this->resY/2)*/);
        //this->middleRect->show();
        
        /*this->bottomHit->setRelCoor2D(0, this->resY/4);
        this->bottomHit->setWidgetSize(this->resX/8, this->resX/3);
        this->bottomHit->show();
        this->topHit->setRelCoor2D(0, -this->resY/4);
        this->topHit->setWidgetSize(this->resX/8, this->resX/3);
        this->topHit->show();*/
        this->leftHit->setRelCoor2D(0, 0);
        this->leftHit->setWidgetSize(this->resX/9, this->resX/3);
        //this->leftHit->hide();
        this->rightHit->setRelCoor2D(this->resX/3, 0);
        this->rightHit->setWidgetSize(this->resX/9, this->resX/3);
        //this->rightHit->hide();

        this->barSocket->setWidgetSize(overlayWidth, overlayWidth);
        this->barSocket->setRelCoor2D(this->resX - overlayWidth, 0);
        if (!this->hidden)
                this->barSocket->show();
        else
                this->barSocket->hide();

        //this->middleRect->show();
        
        
  }

  if (this->overlayActive && !this->hidden)
  {
    this->rightRect->show();
    this->leftRect->show();
  }


  if (State::getPlayer() && State::getPlayer()->getPlayable() && State::getObjectManager())
  {
    PRINTF(4)("UPDATING RADAR\n");
    if( this->playmode != FirstPerson )
        this->_radar->setParent2D(this->leftRect);
    else
        this->_radar->setParent2D(this->topRect);
    if (radarCenterNode == NULL)
      this->_radar->setCenterNode(State::getPlayer()->getPlayable());
    else
      this->_radar->setCenterNode(this->radarCenterNode);

    //this->_radar->addEntityList(&State::getObjectManager()->getEntityList((OM_LIST)(State::getPlayer()->getPlayable()->getOMListNumber()+1)), Color(.4, .4, 1.0));
    this->_radar->addEntityList(&State::getObjectManager()->getEntityList(OM_GROUP_00), Color(1, 0, 0));
    this->_radar->addEntityList(&State::getObjectManager()->getEntityList(OM_GROUP_01), Color(0, 0, 1));
    this->_radar->setAbsCoor2D(0, 0.01 * this->resY);
    this->_radar->setWidgetSize(overlayWidth, overlayWidth);
    this->_radar->setRange(300);
    if (!this->hidden)
        this->_radar->show();
    else
        this->_radar->hide();
    
    int statWidgetsNumber = 0;
    float expectedHealthSizeX = 0;
    float expectedHealthSizeY = 0;
    float newSizeY = 0; float newSizeX = 0;
    float moduloWidth = 0;

        if( this->playmode != FirstPerson )
        {
            if (this->healthWidget != NULL)
            {
              expectedHealthSizeX = 150;
              expectedHealthSizeY = 50;
              statWidgetsNumber++;
            }

            if (this->shieldWidget != NULL)
              statWidgetsNumber++;
            
            if (this->energyWidget != NULL)
              statWidgetsNumber++;
        
            if ((expectedHealthSizeY * statWidgetsNumber) > overlayWidth)
            {
              newSizeY = overlayWidth / float(statWidgetsNumber);
              newSizeX = expectedHealthSizeX;
              PRINTF(0)("Statwidgets resized\n");
            }
            else
            {
              newSizeY = expectedHealthSizeY;
              newSizeX = expectedHealthSizeX;
              moduloWidth = int(overlayWidth) % int(expectedHealthSizeY * statWidgetsNumber);
            }
        
            float posY = overlayWidth + newSizeX;
        
            if (this->healthWidget != NULL)
            {
              this->healthWidget->setSize2D(newSizeX, newSizeY);
              this->healthWidget->setRelCoor2D((statWidgetsNumber - 1) * newSizeY + 3 * moduloWidth / (statWidgetsNumber + 1),posY);
            }
            if (this->shieldWidget != NULL)
            {
              this->shieldWidget->setSize2D(newSizeX, newSizeY);
              this->shieldWidget->setRelCoor2D((statWidgetsNumber - 2) * newSizeY + 2 *moduloWidth / (statWidgetsNumber + 1),posY);
            }
            if (this->energyWidget != NULL)
            {
              this->energyWidget->setSize2D(newSizeX, newSizeY);
              this->energyWidget->setRelCoor2D(moduloWidth / (statWidgetsNumber + 1),posY);
            }
        }
        else
        {
                this->barSocket->setParent2D(this->bottomRect);
                this->barSocket->setWidgetSize( float(overlayWidth), float(overlayWidth));
                this->barSocket->setRelCoor2D(this->resX - float(overlayWidth),0);
                if (!this->hidden)
                        this->barSocket->show();
                else
                        this->barSocket->hide();
                if (this->shieldWidget)
                {
                        this->shieldWidget->setRelCoor2D(40,overlayWidth/2+10);
                        if (!this->hidden)
                                this->shieldWidget->show();
                        else
                                this->shieldWidget->hide();
                        this->shieldText->setRelCoor2D(overlayWidth/2-30,overlayWidth/2-60);
                        if (!this->hidden)
                                this->shieldText->show();
                        else
                                this->shieldText->hide();
                }
                this->healthWidget->setRelCoor2D(40,overlayWidth/2);
                if (!this->hidden)
                        this->healthWidget->show();
                else
                        this->healthWidget->hide();
                this->healthText->setRelCoor2D(overlayWidth/2-50,overlayWidth/2-20);
                if (!this->hidden)
                        this->healthText->show();
                else
                        this->healthText->hide();

        }
        

    /*
    if (this->healthWidget != NULL)
      this->healthWidget->setRelCoor2D(100,0.2*this->resY + this->healthWidget->getSizeX2D());
    if (this->shieldWidget != NULL)
      this->shieldWidget->setRelCoor2D(60,0.2*this->resY + this->healthWidget->getSizeX2D());
    if (this->energyWidget != NULL)
      this->energyWidget->setRelCoor2D(20,0.2*this->resY + this->healthWidget->getSizeX2D());
    */
    //this->shieldWidget->setRelCoor2D(0.1*this->resX + this->healthWidget->getSizeX2D(),0);
    //this->energyWidget->setRelCoor2D(0.1*this->resX + this->healthWidget->getSizeX2D() + this->shieldWidget->getSizeX2D(),0);
  }

  /*
  if (this->shipValuesBox != NULL)
  {
    this->shipValuesBox->setAbsCoor2D(0.2 * this->resX, 0.4 * this->resY);
    this->shipValuesBox->setWidgetSize(.4 * this->resX, 0.1 * this->resY);
  }
  else
    createShipValuesBox();
  */
 if (this->playmode != FirstPerson )
 {
  std::list<OrxGui::GLGuiEnergyWidgetVertical*>::iterator weaponWidget;
  Vector2D pos = Vector2D(overlayWidth, 0.4*this->resY);
  float largestWidgetSizeX = 0;
  //PRINTF(0)("Cur Pos: %f,%f\n",pos.x,pos.y);
  // out of reasons i can't get behind, this version is segfaulting when calling getSizeX2D or getSizeY2D. the other
  // element2D- related function works tough.. :s

  for (weaponWidget = this->weaponsWidgetsPrim.begin(); weaponWidget != this->weaponsWidgetsPrim.end(); weaponWidget++)
  {
    float ySize = (*weaponWidget)->getSizeY2D();
    float xSize = (*weaponWidget)->getSizeX2D();
    if (xSize > largestWidgetSizeX)
      largestWidgetSizeX = xSize;
    if (pos.x < ySize)
    {
      pos.x = overlayWidth;
      pos.y += largestWidgetSizeX;
    }
    pos.x -= ySize;
    (*weaponWidget)->setAbsCoor2D(pos.x + this->rightRect->getAbsCoor2D().x, pos.y);
    //(*weaponWidget)->setAbsCoor2D(0,100);
    if (!this->hidden)
        (*weaponWidget)->show();
    else
        (*weaponWidget)->hide();
    //printf("update thing %s::%s\n", (*weaponWidget)->getClassCName(), (*weaponWidget)->getName());
  }
  
  weaponWidget = this->weaponsWidgetsSec.begin();
  float expectedWidgetSizeY = 0;
  if (weaponWidget != this->weaponsWidgetsSec.end())
  {
    expectedWidgetSizeY = (*weaponWidget)->getSizeY2D();
  }
  pos.y = resY - expectedWidgetSizeY * 0.6;
  pos.x = overlayWidth + this->rightRect->getAbsCoor2D().x;

  for (weaponWidget = this->weaponsWidgetsSec.begin(); weaponWidget != this->weaponsWidgetsSec.end(); weaponWidget++)
  {
    float ySize = (*weaponWidget)->getSizeY2D();
    float xSize = (*weaponWidget)->getSizeX2D();
    if (xSize > largestWidgetSizeX)
      largestWidgetSizeX = xSize;
    if (pos.x < ySize)
    {
      pos.x = overlayWidth;
      pos.y -= largestWidgetSizeX + expectedWidgetSizeY * 0.6;
    }
    pos.x -= ySize;
    //PRINTF(0)("secweaponwidget y-size: %f/n", (*weaponWidget)->getSizeY2D());
    (*weaponWidget)->setAbsCoor2D(pos.x, pos.y);//+this->rightRect->getAbsCoor2D().x, pos.y);
    if (!this->hidden)
        (*weaponWidget)->show();
    else
        (*weaponWidget)->hide();
    //printf("update thing %s::%s\n", (*weaponWidget)->getClassCName(), (*weaponWidget)->getName());
  }
 }
 else
 {
        std::list<OrxGui::GLGuiEnergyWidgetVertical*>::iterator weaponWidget;
        Vector2D pos = Vector2D(overlayWidth, 0.4*this->resY);
        float largestWidgetSizeX = 0;

        for (weaponWidget = this->weaponsWidgetsPrim.begin(); weaponWidget != this->weaponsWidgetsPrim.end(); weaponWidget++)
        {
                (*weaponWidget)->setParent2D(this->barSocket);
                (*weaponWidget)->setRelCoor2D(overlayWidth/2, 0);
                //(*weaponWidget)->setAbsCoor2D(0,100);
                if (!this->hidden)
                        (*weaponWidget)->show();
                else
                        (*weaponWidget)->hide();
                //printf("update thing %s::%s\n", (*weaponWidget)->getClassCName(), (*weaponWidget)->getName());
        }
 }

}

void Hud::draw() const
{
  //  GLGuiWidget::draw();
}


void Hud::process(const Event &event)
{
  if (event.type == EV_VIDEO_RESIZE)
    this->updateResolution();
  else if (event.type == SDLK_TAB)
  {
    /// TODO SHOW THE INPUT-LINE
  //  this->inputLine->select();
  }
}

/*
void Hud::createShipValuesBox()
{
  this->shipValuesBox = new OrxGui::GLGuiBox(OrxGui::Vertical);
  //this->shipValuesBox->setWidgetSize(1000,500);
  //this->shipValuesBox->setBackgroundTexture("textures/gui_container_background.png");
  this->shipValuesBox->setBackgroundTexture(Texture());
  this->shipValuesBox->setBackgroundColor(Color(0,0,1,0.5));
  this->shipValuesBox->setVisibility(true);
}
*/