source: orxonox.OLD/orxonox/branches/weaponSystem/src/world_entities/weapons/weapon.cc @ 4879

/*
   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: Benjamin Grauer
*/

#include "weapon.h"

#include "projectile.h"

#include "load_param.h"
#include "vector.h"
#include "list.h"
#include "state.h"

/**
 * standard constructor
 *
 * creates a new weapon
*/
Weapon::Weapon (PNode* parent, const Vector& coordinate, const Quaternion& direction)
{
  this->init();
  parent->addChild(this, PNODE_ALL);
  this->setRelCoor(coordinate);
  this->setRelDir(direction);
}

/**
 * standard deconstructor
*/
Weapon::~Weapon ()
{
  // model will be deleted from WorldEntity-destructor
  //this->worldEntities = NULL;

  /* dont delete objectComponentsX here, they will be killed when the pnodes are cleaned out */

  /* all animations are deleted via the animation player*/
}

void Weapon::init()
{
  this->currentState     = WS_INACTIVE;
  this->stateTime        = 0.0;
  for (int i = 0; i < WS_STATE_COUNT; i++)
  {
    this->times[i] = 0.0;
    this->animation[i] = NULL;
  }
  for (int i = 0; i < WA_ACTION_COUNT; i++)
    this->soundBuffers[i] = NULL;

  this->weaponSource = NULL;
  this->minCharge;
  this->maxCharge;

  this->active = false;
  this->projectile = NULL;
}

/**
 * sets a new projectile to the weapon
 * @param new projectile for this weapon
 *
 * weapon an projectile are independent, so you can combine them as you want
*/
void Weapon::setProjectile(Projectile* projectile)
{
  this->projectile = projectile;
}


/**
 * sets a new projectile to the weapon
 * @returns the current projectile of this weapon
 *
 * weapon an projectile are independent, so you can combine them as you want
*/
Projectile* Weapon::getProjectile()
{
  return this->projectile;
}


/**
 * 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 Weapon::activate()
{}


/**
 * 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 Weapon::deactivate()
{}

/**
 * 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 Weapon::hit (WorldEntity* entity, const Vector& position)
{}


/**
 *  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 Weapon::destroy ()
{}


/**
 *  tick signal for time dependent/driven stuff
*/
void Weapon::tick (float time)
{}

/**
 *  this will draw the weapon
*/
void Weapon::draw ()
{}





/**
 * Converts a String into an Action.
 * @param action the String input holding the Action.
 * @return The Action if known, WA_NONE otherwise.
 */
WeaponAction Weapon::charToAction(const char* action)
{
  if (!strcmp(action, "none"))
    return WA_NONE;
  else if (!strcmp(action, "shoot"))
    return WA_SHOOT;
  else if (!strcmp(action, "charge"))
    return WA_CHARGE;
  else if (!strcmp(action, "reload"))
    return WA_RELOAD;
  else if (!strcmp(action, "acitvate"))
    return WA_ACTIVATE;
  else if (!strcmp(action, "deactivate"))
    return WA_DEACTIVATE;
  else if (!strcmp(action, "special1"))
    return WA_SPECIAL1;
  else
  {
    PRINTF(2)("action %s could not be identified.\n", action);
    return WA_NONE;
  }
}

/**
 * Converts a String into a State.
 * @param state the String input holding the State.
 * @return The State if known, WS_NONE otherwise.
 */
WeaponState Weapon::charToState(const char* state)
{
  if (!strcmp(state, "none"))
    return WS_NONE;
  else if (!strcmp(state, "shooting"))
    return WS_SHOOTING;
  else if (!strcmp(state, "reloading"))
    return WS_RELOADING;
  else if (!strcmp(state, "activating"))
    return WS_ACTIVATING;
  else if (!strcmp(state, "deactivating"))
    return WS_DEACTIVATING;
  else if (!strcmp(state, "inactive"))
    return WS_INACTIVE;
  else if (!strcmp(state, "idle"))
    return WS_IDLE;
  else
  {
    PRINTF(2)("state %s could not be identified.\n", state);
    return WS_NONE;
  }
}