SpaceShip.cpp

Go to the documentation of this file.

#include "SpaceShip.h"
#include "Plane.h"


SpaceShip::SpaceShip( float r, GLuint displayList ) : MovingObject( ), ModelObject( r, displayList ) {
  initialize();
}


SpaceShip::SpaceShip( Vector3 position, float r, GLuint displayList ) : MovingObject( position ), ModelObject( r, displayList ) {
  initialize();
}


SpaceShip::SpaceShip( float x, float y, float z, float r, GLuint displayList ) : MovingObject( x, y, z ), ModelObject( r, displayList ) {
  initialize();
}

SpaceShip::~SpaceShip(void) {

}

void SpaceShip::initialize( void ) {
  m_laserHeat = 0;
  m_maxLaserHeat = 100;
  m_overHeated = false;
  m_backShieldPower = 100;
  m_frontShieldPower = 100;
  m_maxShieldPower = 100;
  m_missiles = 4;
  m_maxMissiles = 4;
  heatPunishTime = 1000;
  originalView = Vector3(0,0,1);
  originalUp = Vector3(0,1,0);
  shooting = false;
  m_shieldRecovers = false;
  m_ship_was_hit = false;
}


GLvoid SpaceShip::draw( void ) {
  glPushMatrix();
  glTranslatef( getPos().x, getPos().y, getPos().z );

  Vector3 orgView = this->getOriginalView();
  orgView.normalize();

  Vector3 actView = this->getView();
  actView.normalize();

  Vector3 orthogonal = orgView  * actView;
  orthogonal.normalize();

  float projection = orgView.innerProduct(actView); // / actView.length();
  float angle = acos(projection) / ANGLE2DEG;

  Vector3 nullvector = Vector3(0,0,0);

  Plane * testplane = new Plane(nullvector, orthogonal, orgView);

  float testdistance = testplane->distance(actView);

  if (testdistance < 0)
    angle = 360 - angle;

  glRotatef(angle,orthogonal.x,orthogonal.y,orthogonal.z);

  ModelObject::draw();
  glPopMatrix();
}


bool SpaceShip::isDestroyed() {
  if( m_frontShieldPower < 0 || m_backShieldPower < 0 )
    return true;
  else
    return false;
}


void SpaceShip::coolLaser( DWORD time ) {
  m_laserHeat -= time * m_maxLaserHeat/5000.0;
  if( m_laserHeat < 0 )
    m_laserHeat = 0;
  if( heatPunishTime > 0)
    heatPunishTime -= time;
  else
    m_overHeated = false;
}

void SpaceShip::advance( float t)
{
    MovingObject::advance(t);
}

void SpaceShip::updateLaser( float t) {
    if ( shooting && !m_overHeated )
        useLaser(t);
    else
        coolLaser(t);
}

void SpaceShip::update( float t) {
  if( m_shieldRecovers ) {
    this->recoverShieldBack( t );
    this->recoverShieldFront( t );
  }
    advance(t);
    updateLaser(t);
}

float SpaceShip::getLaserHeat() {
  return m_laserHeat;
}

float SpaceShip::getMaxLaserHeat( void ) {
  return m_maxLaserHeat;
}

float SpaceShip::getLaserPercentage() {
  return m_laserHeat/m_maxLaserHeat;
}

unsigned int SpaceShip::getMissileCount( void ) {
  return this->m_missiles;
}

bool SpaceShip::isOverHeated() {
  return m_overHeated;
}


void SpaceShip::useLaser( DWORD time ) {
  m_laserHeat += time*6 * m_maxLaserHeat/5000.0; // this creates over-heating in 5 seconds or 5000 ms
  if( m_laserHeat > m_maxLaserHeat ) {
    m_laserHeat = m_maxLaserHeat;
    m_overHeated = true;
    heatPunishTime = 1000;
  }
}


void SpaceShip::useMissile( void ) {
  if( this->m_missiles > 0 )
    m_missiles--;

}

bool SpaceShip::isShooting(){
    return (shooting&&!m_overHeated);
}

void SpaceShip::setLaserHeat( float heat ) {
  m_laserHeat = heat;
}

void SpaceShip::setShoot(bool status){
    shooting = status;
}

float SpaceShip::getBackShieldPower() {
  return m_backShieldPower;
}

float SpaceShip::getBackShieldPowerPercentage() {
  return m_backShieldPower / m_maxShieldPower;
}

float SpaceShip::getFrontShieldPower() {
  return m_frontShieldPower;
}

float SpaceShip::getFrontShieldPowerPercentage() {
  return m_frontShieldPower / m_maxShieldPower;
}

Vector3 SpaceShip::getOriginalUp(){
  return originalUp;
}

Vector3 SpaceShip::getOriginalView(){
  return originalView;
}

void SpaceShip::receiveHitBack( DWORD time ) {
  m_ship_was_hit=true;
  if( m_backShieldPower >= 0 )
    m_backShieldPower -= time*3* m_maxShieldPower/5000.0; // this creates over-heating in 5 seconds or 5000 ms
}

void SpaceShip::receiveHitFront( DWORD time ) {
  m_ship_was_hit=true;
  if( m_frontShieldPower >= 0 )
    m_frontShieldPower -= time*3* m_maxShieldPower/5000.0; // this creates over-heating in 5 seconds or 5000 ms
}

void SpaceShip::recoverShieldBack( DWORD time ) {
  m_backShieldPower += time*0.75 * m_maxShieldPower / 10000.0;
  if( m_backShieldPower > m_maxShieldPower )
    m_backShieldPower = m_maxShieldPower;
}

void SpaceShip::recoverShieldFront( DWORD time ) {
  m_frontShieldPower += time*0.75 * m_maxShieldPower / 10000.0;
  if( m_frontShieldPower > m_maxShieldPower )
    m_frontShieldPower = m_maxShieldPower;

}
void SpaceShip::setShieldCapacity( float capacity ) {
  if( capacity < 0 )
    return;
  m_maxShieldPower = capacity;
  if( m_frontShieldPower > m_maxShieldPower )
    m_frontShieldPower = m_maxShieldPower;
  if( m_backShieldPower > m_maxShieldPower )
    m_backShieldPower = m_maxShieldPower;
}

void SpaceShip::setShieldRecovering( bool recovers ) {
  m_shieldRecovers = recovers;
}

bool SpaceShip::shipWasHitOnce()
{
    return m_ship_was_hit;
}