source: orxonox.OLD/orxonox/trunk/src/world_entities/test_gun.cc @ 3757

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

   Copyright (C) 2004 orx

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

   ### File Specific
   main-programmer: Patrick Boenzli
   co-programmer: 


   \todo: direction in which the projectile flights
   \todo: a target to set/hit
*/


#include "test_gun.h"

#include "stdincl.h"
#include "world_entity.h"
#include "model.h"
#include "test_bullet.h"

#include "vector.h"
#include "list.h"
#include "simple_animation.h"

using namespace std;


/**
   \brief standard constructor

   creates a new weapon
*/
TestGun::TestGun (PNode* parent, Vector* coordinate, Quaternion* direction, int leftRight) 
  :  Weapon (parent, coordinate, direction) 
{
  this->model = (Model*)ResourceManager::getInstance()->load("models/test_gun.obj", OBJ, RP_CAMPAIGN);
  this->idleTime = 0.2f;
  this->leftRight = leftRight;

  if( this->leftRight == 0)
    this->projOffset = new Vector(1.0, 0.0, -0.35);
  else if( this->leftRight == 1)
    this->projOffset = new Vector(1.0, 0.0, 0.5);

  this->animator = SimpleAnimation::getInstance();
  this->dummy1 = new WorldEntity(); /* a world entity that is not drawed: use this for the weapon */
  parent->addChild(this->dummy1, PNODE_ALL);

  
  this->animator->animatorBegin();
  this->animator->selectObject(this->dummy1);
  this->animator->setAnimationMode(SINGLE);
  if( this->leftRight == 0)
    {
      this->animator->addKeyFrame(new Vector(-2.6, 0.1, 3.0), new Quaternion(), 0.0, NEG_EXP);
      this->animator->addKeyFrame(new Vector(-3.0, 0.1, 3.0), new Quaternion(), 0.1, NEG_EXP);
      this->animator->addKeyFrame(new Vector(-2.6, 0.1, 3.0), new Quaternion(), 0.5, NEG_EXP);
    }
  else if( this->leftRight == 1)
    {
      this->animator->addKeyFrame(new Vector(-2.6, 0.1, -2.5), new Quaternion(), 0.0, NEG_EXP);
      this->animator->addKeyFrame(new Vector(-3.0, 0.1, -2.5), new Quaternion(), 0.1, NEG_EXP);
      this->animator->addKeyFrame(new Vector(-2.6, 0.1, -2.5), new Quaternion(), 0.5, NEG_EXP);
    }
  this->animator->animatorEnd();
  
}


/**
   \brief standard deconstructor
*/
TestGun::~TestGun () 
{
  // model will be deleted from WorldEntity-destructor
}


/**
   \brief this activates the weapon

   This is needed, since there can be more than one weapon on a ship. the 
   activation can be connected with an animation. for example the weapon is 
   been armed out. 
*/
void TestGun::activate()
{}


/**
   \brief this deactivates the weapon

   This is needed, since there can be more than one weapon on a ship. the 
   activation can be connected with an animation. for example the weapon is 
   been armed out.
*/
void TestGun::deactivate()
{}


/**
   \brief fires the weapon
   
   this is called from the player.cc, when fire-button is been pushed
*/
void TestGun::fire()
{
  if( this->localTime < this->idleTime)
    {
      this->weaponIdle();
      return;
    }
  Projectile* pj = new TestBullet(this);

  pj->setAbsCoor(this->getAbsCoor() + *this->projOffset);
  pj->setAbsDir(this->getAbsDir());

  pj->setFlightDirection(this->getAbsDir());
  pj->setSpeed(this->getSpeed());

  this->worldEntities->add(pj);
  this->localTime = 0;
  
  this->animator->animatorBegin();
  this->animator->selectObject(this->dummy1);
  this->animator->start();
  this->animator->animatorEnd();
}


/**
   \brief is called, when the weapon gets hit (=collide with something)
   \param from which entity it is been hit
   \param where it is been hit

   this may not be used, since it would make the game relay complicated when one
   can destroy the weapons of enemies or vice versa.
*/
void TestGun::hit (WorldEntity* entity, Vector* position) 
{}


/**
   \brief is called, when the weapon is destroyed

   this is in conjunction with the hit function, so when a weapon is able to get
   hit, it can also be destoryed.
*/
void TestGun::destroy () 
{}


/**
   \brief tick signal for time dependent/driven stuff
*/
void TestGun::tick (float time) 
{
  this->localTime += time;
}


/**
   \brief is called, when there is no fire button pressed
*/
void TestGun::weaponIdle()
{}


/**
   \brief this will draw the weapon
*/
void TestGun::draw () 
{
  
  /* draw gun body 1 */
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  float matrix[4][4];
  
  if( this->leftRight == 0)
    {
      glTranslatef (this->getAbsCoor ().x, 
                    this->getAbsCoor ().y, 
                    this->getAbsCoor ().z);
      
      this->getAbsDir ().matrix (matrix);
      glMultMatrixf((float*)matrix);
      this->model->draw(1);
    }
  else if( this->leftRight == 1)
    {
      glTranslatef (this->getAbsCoor ().x, 
                    this->getAbsCoor ().y, 
                    this->getAbsCoor ().z);
      
      this->getAbsDir ().matrix (matrix);
      glMultMatrixf((float*)matrix);
      glScalef(1.0, 1.0, -1.0);
      this->model->draw(1);
    }

  glPopMatrix();


  /* draw gun coil 1 */
  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  
  glTranslatef (this->dummy1->getAbsCoor ().x, 
                this->dummy1->getAbsCoor ().y, 
                this->dummy1->getAbsCoor ().z);

  this->dummy1->getAbsDir ().matrix (matrix);
  glMultMatrixf((float*)matrix);
  this->model->draw(0);
  glPopMatrix();
}