Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/world_entities/weapons/weapon.cc @ 10178

Last change on this file since 10178 was 9869, checked in by bensch, 18 years ago

orxonox/trunk: merged the new_class_id branche back to the trunk.
merged with command:
svn merge https://svn.orxonox.net/orxonox/branches/new_class_id trunk -r9683:HEAD
no conflicts… puh..

File size: 20.1 KB
RevLine 
[3573]1
[4597]2/*
[3573]3   orxonox - the future of 3D-vertical-scrollers
4
5   Copyright (C) 2004 orx
6
7   This program is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 2, or (at your option)
10   any later version.
11
[4826]12### File Specific
[3573]13   main-programmer: Patrick Boenzli
[4832]14   co-programmer: Benjamin Grauer
[4885]15
16   2005-07-15: Benjamin Grauer: restructurating the entire Class
[3573]17*/
18
[4885]19#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WEAPON
20
[4828]21#include "weapon.h"
22
[9869]23#include "loading/fast_factory.h"
[6434]24#include "world_entities/projectiles/projectile.h"
[4834]25
[7350]26#include "util/loading/factory.h"
[7193]27#include "util/loading/load_param.h"
[4828]28#include "state.h"
[4885]29#include "animation3d.h"
[3573]30
[5930]31#include "sound_source.h"
32#include "sound_buffer.h"
[9869]33#include "resource_sound_buffer.h"
[5930]34
[8976]35#include "elements/glgui_energywidget.h"
[6438]36
[9869]37ObjectListDefinition(Weapon);
[7350]38
[4892]39////////////////////
40// INITAILISATION //
41// SETTING VALUES //
42////////////////////
[3870]43/**
[4885]44 * standard constructor
45 *
46 * creates a new weapon
[3575]47*/
[5750]48Weapon::Weapon ()
[3620]49{
[4885]50  this->init();
[3620]51}
[3573]52
[3575]53/**
[4885]54 * standard deconstructor
[3575]55*/
[4597]56Weapon::~Weapon ()
[3573]57{
[4885]58  for (int i = 0; i < WS_STATE_COUNT; i++)
[9869]59    if (this->animation[i] && Animation::objectList().exists(animation[i]))  //!< @todo this should check animation3D
[4885]60      delete this->animation[i];
[4959]61
[9869]62  if (OrxSound::SoundSource::objectList().exists(this->soundSource))
[4959]63    delete this->soundSource;
[4885]64}
[4597]65
[4885]66/**
[7350]67 * @brief creates a new Weapon of type weaponID and returns it.
68 * @param weaponID the WeaponID type to create.
69 * @returns the newly created Weapon.
70 */
[9869]71Weapon* Weapon::createWeapon(const ClassID& weaponID)
[7350]72{
73  BaseObject* createdObject = Factory::fabricate(weaponID);
74  if (createdObject != NULL)
75  {
[9869]76    if (createdObject->isA(Weapon::staticClassID()))
[7350]77      return dynamic_cast<Weapon*>(createdObject);
78    else
79    {
80      delete createdObject;
81      return NULL;
82    }
83  }
[8316]84  return NULL;
[7350]85}
86
[9869]87Weapon* Weapon::createWeapon(const std::string& weaponName)
88{
89  BaseObject* createdObject = Factory::fabricate(weaponName);
90  if (createdObject != NULL)
91  {
92    if (createdObject->isA(Weapon::staticClassID()))
93      return dynamic_cast<Weapon*>(createdObject);
94    else
95    {
96      delete createdObject;
97      return NULL;
98    }
99  }
100  return NULL;
101}
102
103
[7350]104/**
[4885]105 * initializes the Weapon with ALL default values
[5498]106 *
107 * This Sets the default values of the Weapon
[4885]108 */
109void Weapon::init()
110{
[9869]111  this->registerObject(this, Weapon::_objectList);
[5498]112  this->currentState     = WS_INACTIVE;            //< Normaly the Weapon is Inactive
113  this->requestedAction  = WA_NONE;                //< No action is requested by default
114  this->stateDuration    = 0.0;                    //< All the States have zero duration
115  for (int i = 0; i < WS_STATE_COUNT; i++)         //< Every State has:
[6438]116  {
117    this->times[i] = 0.0;                        //< An infinitesimal duration
118    this->animation[i] = NULL;                   //< No animation
119  }
[3888]120
[7460]121  this->soundSource = new OrxSound::SoundSource(this);       //< Every Weapon has exacty one SoundSource.
[5498]122  this->emissionPoint.setParent(this);             //< One EmissionPoint, that is a PNode connected to the weapon. You can set this to the exitting point of the Projectiles
[7126]123  this->emissionPoint.setName("EmissionPoint");
124  this->emissionPoint.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
[4885]125
[6920]126  this->defaultTarget = NULL;                      //< Nothing is Targeted by default.
[6756]127
[9869]128  this->projectile = NullClass::staticClassID();         //< No Projectile Class is Connected to this weapon
[5498]129  this->projectileFactory = NULL;                  //< No Factory generating Projectiles is selected.
[4885]130
[5498]131  this->hideInactive = true;                       //< The Weapon will be hidden if it is inactive (by default)
[4906]132
[5498]133  this->minCharge = 1.0;                           //< The minimum charge the Weapon can hold is 1 unit.
134  this->maxCharge = 1.0;                           //< The maximum charge is also one unit.
[4927]135
[6671]136  this->energy = 10;                               //< The secondary Buffer (before we have to reload)
[5498]137  this->energyMax = 10.0;                          //< How much energy can be carried
138  this->capability = WTYPE_ALL;                    //< The Weapon has all capabilities @see W_Capability.
[6438]139
140  this->energyWidget = NULL;
[6695]141
142  // set this object to be synchronized over network
143  //this->setSynchronized(true);
[3573]144}
145
[5498]146/**
147 * loads the Parameters of a Weapon
148 * @param root the XML-Element to load the Weapons settings from
149 */
[4972]150void Weapon::loadParams(const TiXmlElement* root)
151{
[6512]152  WorldEntity::loadParams(root);
[4972]153
[7102]154  LoadParam(root, "projectile", this, Weapon, setProjectileTypeC)
[6438]155  .describe("Sets the name of the Projectile to load onto the Entity");
[4972]156
[5671]157  LoadParam(root, "emission-point", this, Weapon, setEmissionPoint)
[6438]158  .describe("Sets the Point of emission of this weapon");
[4972]159
[5671]160  LoadParam(root, "state-duration", this, Weapon, setStateDuration)
[6438]161  .describe("Sets the duration of a given state (1: state-Name; 2: duration in seconds)");
[4972]162
[5671]163  LoadParam(root, "action-sound", this, Weapon, setActionSound)
[6438]164  .describe("Sets a given sound to an action (1: action-Name; 2: name of the sound (relative to the Data-Path))");
[4972]165}
166
[6728]167
[4947]168/**
169 * sets the Projectile to use for this weapon.
170 * @param projectile The ID of the Projectile to use
[4950]171 * @returns true, if it was sucessfull, false on error
[4947]172 *
[5498]173 * be aware, that this function does not create Factories, as this is job of Projecitle/Bullet-classes.
174 * What it does, is telling the Weapon what Projectiles it can Emit.
[4947]175 */
[9869]176void Weapon::setProjectileType(const ClassID& projectile)
[4947]177{
178  this->projectile = projectile;
179  this->projectileFactory = FastFactory::searchFastFactory(projectile);
180  if (this->projectileFactory == NULL)
[4979]181  {
182    PRINTF(1)("unable to find FastFactory for the Projectile.\n");
[4972]183    return;
[4979]184  }
[4948]185  else
186  {
187    // grabbing Parameters from the Projectile to have them at hand here.
188    Projectile* pj = dynamic_cast<Projectile*>(this->projectileFactory->resurrect());
[6431]189    this->minCharge = pj->getMinEnergy();
[6700]190    this->maxCharge = pj->getHealthMax();
[4948]191    this->chargeable = pj->isChageable();
[4979]192    this->projectileFactory->kill(pj);
[4948]193  }
[4979]194}
[3573]195
[6728]196
[4891]197/**
[4950]198 * @see bool Weapon::setProjectile(ClassID projectile)
199 * @param projectile the Name of the Projectile.
200 */
[7221]201void Weapon::setProjectileTypeC(const std::string& projectile)
[4950]202{
203  FastFactory* tmpFac = FastFactory::searchFastFactory(projectile);
204  if (tmpFac != NULL)
205  {
[5356]206    this->setProjectileType(tmpFac->getStoredID());
[4950]207  }
[4972]208  else
209  {
[9406]210    PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile.c_str(), this->getCName());
[4972]211  }
[4950]212}
213
[6728]214
[4950]215/**
[5356]216 * prepares Projectiles of the Weapon
[5498]217 * @param count how many Projectiles to create (they will be stored in the ProjectileFactory)
[5356]218 */
219void Weapon::prepareProjectiles(unsigned int count)
220{
[5357]221  if (likely(this->projectileFactory != NULL))
[5356]222    projectileFactory->prepare(count);
223  else
[9406]224    PRINTF(2)("unable to create %d projectile for Weapon %s::%s\n", count, this->getClassCName(), this->getCName());
[5356]225}
226
[6728]227
[5356]228/**
229 * resurects and returns a Projectile
[5498]230 * @returns a Projectile on success, NULL on error
231 *
232 * errors: 1. (ProjectileFastFactory not Found)
233 *         2. No more Projectiles availiable.
[5356]234 */
235Projectile* Weapon::getProjectile()
236{
[5357]237  if (likely (this->projectileFactory != NULL))
[6142]238  {
239    Projectile* pj = dynamic_cast<Projectile*>(this->projectileFactory->resurrect());
240    pj->toList((OM_LIST)(this->getOMListNumber()+1));
241    return pj;
242  }
[5356]243  else
244  {
[9406]245    PRINTF(2)("No projectile defined for Weapon %s(%s) can't return any\n", this->getCName(), this->getClassCName());
[5356]246    return NULL;
247  }
248}
249
250
251/**
[4892]252 * sets the emissionPoint's relative position from the Weapon
253 * @param point the Point relative to the mass-point of the Weapon
254 */
255void Weapon::setEmissionPoint(const Vector& point)
256{
257  this->emissionPoint.setRelCoor(point);
258}
259
[6728]260
[4892]261/**
[4891]262 * assigns a Sound-file to an action
263 * @param action the action the sound should be assigned too
264 * @param soundFile the soundFile's relative position to the data-directory (will be looked for by the ResourceManager)
265 */
[7221]266void Weapon::setActionSound(WeaponAction action, const std::string& soundFile)
[4885]267{
268  if (action >= WA_ACTION_COUNT)
269    return;
[4930]270
[7221]271  else if (!soundFile.empty())
[4885]272  {
[9869]273    this->soundBuffers[action] = OrxSound::ResourceSoundBuffer(soundFile);
274    if (this->soundBuffers[action].loaded())
[4885]275    {
[7221]276      PRINTF(4)("Loaded sound %s to action %s.\n", soundFile.c_str(), actionToChar(action));
[4885]277    }
278    else
279    {
[7221]280      PRINTF(2)("Failed to load sound %s to %s.\n.", soundFile.c_str(), actionToChar(action));
[4885]281    }
282  }
283  else
[9869]284    this->soundBuffers[action] = OrxSound::SoundBuffer();
[4885]285}
286
[6728]287
[4893]288/**
[4895]289 * creates/returns an Animation3D for a certain State.
290 * @param state what State should the Animation be created/returned for
291 * @param node the node this Animation should apply to. (NULL is fine if the animation was already created)
292 * @returns The created animation.Animation(), NULL on error (or if the animation does not yet exist).
[4893]293 *
294 * This function does only generate the Animation Object, and if set it will
295 * automatically be executed, when a certain State is reached.
296 * What this does not do, is set keyframes, you have to operate on the returned animation.
297 */
[4895]298Animation3D* Weapon::getAnimation(WeaponState state, PNode* node)
[4893]299{
[4895]300  if (state >= WS_STATE_COUNT) // if the state is not known
[4893]301    return NULL;
302
[4895]303  if (unlikely(this->animation[state] == NULL)) // if the animation does not exist yet create it.
[4893]304  {
[4895]305    if (likely(node != NULL))
306      return this->animation[state] = new Animation3D(node);
307    else
308    {
309      PRINTF(2)("Node not defined for the Creation of the 3D-animation of state %s\n", stateToChar(state));
310      return NULL;
311    }
[4893]312  }
[4895]313  else
314    return this->animation[state];
[4893]315}
316
[7779]317OrxGui::GLGuiWidget* Weapon::getEnergyWidget()
[6438]318{
319  if (this->energyWidget == NULL)
320  {
[8977]321    this->energyWidget = new OrxGui::GLGuiEnergyWidget();
[9406]322    this->energyWidget->setDisplayedName(this->getClassCName());
[6438]323    this->energyWidget->setSize2D( 20, 100);
324    this->energyWidget->setMaximum(this->getEnergyMax());
325    this->energyWidget->setValue(this->getEnergy());
326  }
327  return this->energyWidget;
328}
329
330void Weapon::updateWidgets()
331{
332  if (this->energyWidget != NULL)
333  {
334    this->energyWidget->setMaximum(this->energyMax);
335    this->energyWidget->setValue(this->energy);
336  }
337}
338
[4892]339/////////////////
340//  EXECUTION  //
341// GAME ACTION //
342/////////////////
[4597]343/**
[4885]344 * request an action that should be executed,
345 * @param action the next action to take
346 *
347 * This function must be called instead of the actions (like fire/reload...)
348 * to make all the checks needed to have a usefull WeaponSystem.
349 */
350void Weapon::requestAction(WeaponAction action)
351{
[4906]352  if (likely(this->isActive()))
[4885]353  {
[4906]354    if (this->requestedAction != WA_NONE)
355      return;
[5041]356    PRINTF(5)("next action will be %s in %f seconds\n", actionToChar(action), this->stateDuration);
[4885]357    this->requestedAction = action;
358  }
[4906]359  //else
360  else if (unlikely(action == WA_ACTIVATE))
361  {
362    this->currentState = WS_ACTIVATING;
[4926]363    this->requestedAction = WA_ACTIVATE;
[4906]364  }
[4885]365}
[3577]366
[6728]367
[4890]368/**
369 * adds energy to the Weapon
370 * @param energyToAdd The amount of energy
371 * @returns the amount of energy we did not pick up, because the weapon is already full
372 */
373float Weapon::increaseEnergy(float energyToAdd)
374{
375  float maxAddEnergy = this->energyMax - this->energy;
376
377  if (maxAddEnergy >= energyToAdd)
378  {
379    this->energy += energyToAdd;
380    return 0.0;
381  }
382  else
383  {
384    this->energy += maxAddEnergy;
385    return energyToAdd - maxAddEnergy;
386  }
387}
388
[6728]389
[5498]390////////////////////////////////////////////////////////////
391// WEAPON INTERNALS                                       //
392// These are functions, that no other Weapon should over- //
393// write. No class has direct Access to them, as it is    //
394// quite a complicated process, handling a Weapon from    //
395// the outside                                            //
396////////////////////////////////////////////////////////////
[4891]397/**
398 * executes an action, and with it starts a new State.
399 * @return true, if it worked, false otherwise
400 *
401 * This function checks, wheter the possibility of executing an action is valid,
402 * and does all the necessary stuff, to execute them. If an action does not succeed,
403 * it tries to go around it. (ex. shoot->noAmo->reload()->wait until shoot comes again)
404 */
[4885]405bool Weapon::execute()
[3583]406{
[7729]407#if DEBUG_LEVEL > 4
[4885]408  PRINTF(4)("trying to execute action %s\n", actionToChar(this->requestedAction));
409  this->debug();
[4906]410#endif
[4885]411
[4926]412  WeaponAction action = this->requestedAction;
413  this->requestedAction = WA_NONE;
414
415  switch (action)
[4885]416  {
[7350]417    case WA_SHOOT:
[9869]418    return this->fireW();
419    break;
[7350]420    case WA_CHARGE:
[9869]421    return this->chargeW();
422    break;
[7350]423    case WA_RELOAD:
[9869]424    return this->reloadW();
425    break;
[7350]426    case WA_DEACTIVATE:
[9869]427    return this->deactivateW();
428    break;
[7350]429    case WA_ACTIVATE:
[9869]430    return this->activateW();
431    break;
[8316]432    default:
[9869]433    PRINTF(2)("Action %s Not Implemented yet \n", Weapon::actionToChar(action));
434    return false;
[4885]435  }
[3583]436}
[3577]437
[4597]438/**
[4894]439 * checks and activates the Weapon.
440 * @return true on success.
[4892]441 */
442bool Weapon::activateW()
[3583]443{
[6438]444  //  if (this->currentState == WS_INACTIVE)
[4892]445  {
[6433]446    // play Sound
[9869]447    if (likely(this->soundBuffers[WA_ACTIVATE].loaded()))
[4892]448      this->soundSource->play(this->soundBuffers[WA_ACTIVATE]);
[6444]449    this->updateWidgets();
[6438]450    // activate
[9406]451    PRINTF(4)("Activating the Weapon %s\n", this->getCName());
[4892]452    this->activate();
[4895]453    // setting up for next action
[4926]454    this->enterState(WS_ACTIVATING);
[4892]455  }
[8316]456  return true;
[3583]457}
[3577]458
[4597]459/**
[4894]460 * checks and deactivates the Weapon
461 * @return true on success.
[4892]462 */
463bool Weapon::deactivateW()
[3583]464{
[6438]465  //  if (this->currentState != WS_INACTIVE)
[4892]466  {
[9406]467    PRINTF(4)("Deactivating the Weapon %s\n", this->getCName());
[6438]468    // play Sound
[9869]469    if (this->soundBuffers[WA_DEACTIVATE].loaded())
[4892]470      this->soundSource->play(this->soundBuffers[WA_DEACTIVATE]);
[4926]471    // deactivate
[4892]472    this->deactivate();
[4926]473    this->enterState(WS_DEACTIVATING);
[4892]474  }
[8316]475
476  return true;
[3583]477}
[3577]478
[4892]479/**
[4894]480 * checks and charges the Weapon
481 * @return true on success.
[4892]482 */
483bool Weapon::chargeW()
[4885]484{
[6671]485  if ( this->currentState != WS_INACTIVE && this->energy >= this->minCharge)
[4892]486  {
[6438]487    // playing Sound
[9869]488    if (this->soundBuffers[WA_CHARGE].loaded())
[4892]489      this->soundSource->play(this->soundBuffers[WA_CHARGE]);
[4893]490
[6438]491    // charge
[4892]492    this->charge();
[6438]493    // setting up for the next state
[4926]494    this->enterState(WS_CHARGING);
[4892]495  }
496  else // deactivate the Weapon if we do not have enough energy
497  {
498    this->requestAction(WA_RELOAD);
499  }
[8316]500  return true;
[4885]501}
[3573]502
[4892]503/**
[4894]504 * checks and fires the Weapon
505 * @return true on success.
[4892]506 */
507bool Weapon::fireW()
[3575]508{
[6438]509  //if (likely(this->currentState != WS_INACTIVE))
[6671]510  if (this->minCharge <= this->energy)
[4892]511  {
[6438]512    // playing Sound
[9869]513    if (this->soundBuffers[WA_SHOOT].loaded())
[4892]514      this->soundSource->play(this->soundBuffers[WA_SHOOT]);
[6444]515    this->updateWidgets();
[6438]516    // fire
[6671]517    this->energy -= this->minCharge;
[4892]518    this->fire();
[6438]519    // setting up for the next state
[4926]520    this->enterState(WS_SHOOTING);
[4892]521  }
522  else  // reload if we still have the charge
523  {
524    this->requestAction(WA_RELOAD);
[4930]525    this->execute();
[4892]526  }
[8316]527  return true;
[4892]528}
529
530/**
[4894]531 * checks and Reloads the Weapon
532 * @return true on success.
[4892]533 */
534bool Weapon::reloadW()
535{
[9406]536  PRINTF(4)("Reloading Weapon %s\n", this->getCName());
[9869]537  if (!this->ammoContainer.isNull() &&
[7350]538      unlikely(this->energy + this->ammoContainer->getStoredEnergy() < this->minCharge))
[4885]539  {
540    this->requestAction(WA_DEACTIVATE);
[4930]541    this->execute();
[4892]542    return false;
[4885]543  }
[3573]544
545
[9869]546  if (this->soundBuffers[WA_RELOAD].loaded())
[4892]547    this->soundSource->play(this->soundBuffers[WA_RELOAD]);
548
[9869]549  if (!this->ammoContainer.isNull())
[6671]550    this->ammoContainer->fillWeapon(this);
[4885]551  else
552  {
[6671]553    this->energy = this->energyMax;
[4885]554  }
[6444]555  this->updateWidgets();
[4892]556  this->reload();
[4926]557  this->enterState(WS_RELOADING);
[8316]558
559  return true;
[4926]560}
[3575]561
[4926]562/**
563 * enters the requested State, plays back animations updates the timing.
564 * @param state the state to enter.
565 */
566inline void Weapon::enterState(WeaponState state)
567{
[5041]568  PRINTF(4)("ENTERING STATE %s\n", stateToChar(state));
[4926]569  // playing animation if availiable
570  if (likely(this->animation[state] != NULL))
571    this->animation[state]->replay();
572
[6728]573  this->stateDuration += this->times[state];
[4926]574  this->currentState = state;
[3575]575}
576
[4927]577///////////////////
578//  WORLD-ENTITY //
579// FUNCTIONALITY //
580///////////////////
[3575]581/**
[4885]582 * tick signal for time dependent/driven stuff
[3575]583*/
[6736]584bool Weapon::tickW(float dt)
[4885]585{
[4934]586  //printf("%s ", stateToChar(this->currentState));
[4910]587
[4885]588  // setting up the timing properties
589  this->stateDuration -= dt;
[3575]590
[4949]591  if (this->stateDuration <= 0.0)
[4885]592  {
[4949]593    if (unlikely (this->currentState == WS_DEACTIVATING))
[4885]594    {
[4949]595      this->currentState = WS_INACTIVE;
[6736]596      return false;
[4949]597    }
598    else
599      this->currentState = WS_IDLE;
[4906]600
[4949]601    if (this->requestedAction != WA_NONE)
602    {
603      this->stateDuration = -dt;
604      this->execute();
[4885]605    }
606  }
[6736]607  return true;
[4885]608}
609
[3575]610
611
612
[4885]613//////////////////////
614// HELPER FUNCTIONS //
615//////////////////////
[3576]616/**
[4891]617 * checks wether all the Weapons functions are valid, and if it is possible to go to action with it.
[5498]618 * @todo IMPLEMENT the Weapons Check
[4891]619 */
620bool Weapon::check() const
621{
622  bool retVal = true;
623
[6438]624  //  if (this->projectile == NULL)
[4891]625  {
[5041]626    PRINTF(1)("There was no projectile assigned to the Weapon.\n");
[4891]627    retVal = false;
628  }
629
630
631
632
633  return retVal;
634}
635
636/**
[4885]637 * some nice debugging information about this Weapon
638 */
639void Weapon::debug() const
640{
[9406]641  PRINT(0)("Weapon-Debug %s, state: %s (duration: %fs), nextAction: %s\n", this->getCName(), Weapon::stateToChar(this->currentState), this->stateDuration, Weapon::actionToChar(requestedAction));
[6671]642  PRINT(0)("Energy: max: %f; current: %f; chargeMin: %f, chargeMax %f\n",
643           this->energyMax, this->energy, this->minCharge, this->maxCharge);
[4967]644
645
[4885]646}
[3575]647
[5498]648////////////////////////////////////////////////////////
649// static Definitions (transormators for readability) //
650////////////////////////////////////////////////////////
[4885]651/**
652 * Converts a String into an Action.
653 * @param action the String input holding the Action.
654 * @return The Action if known, WA_NONE otherwise.
655 */
[7221]656WeaponAction Weapon::charToAction(const std::string& action)
[4885]657{
[7221]658  if (action == "none")
[4885]659    return WA_NONE;
[7221]660  else if (action == "shoot")
[4885]661    return WA_SHOOT;
[7221]662  else if (action == "charge")
[4885]663    return WA_CHARGE;
[7221]664  else if (action == "reload")
[4885]665    return WA_RELOAD;
[7221]666  else if (action == "acitvate")
[4885]667    return WA_ACTIVATE;
[7221]668  else if (action == "deactivate")
[4885]669    return WA_DEACTIVATE;
[7221]670  else if (action == "special1")
[4885]671    return WA_SPECIAL1;
672  else
[6438]673  {
[7221]674    PRINTF(2)("action %s could not be identified.\n", action.c_str());
[6438]675    return WA_NONE;
676  }
[4885]677}
[3575]678
679/**
[4885]680 * converts an action into a String
681 * @param action the action to convert
682 * @return a String matching the name of the action
683 */
684const char* Weapon::actionToChar(WeaponAction action)
685{
686  switch (action)
687  {
[7350]688    case WA_SHOOT:
[9869]689    return "shoot";
690    break;
[7350]691    case WA_CHARGE:
[9869]692    return "charge";
693    break;
[7350]694    case WA_RELOAD:
[9869]695    return "reload";
696    break;
[7350]697    case WA_ACTIVATE:
[9869]698    return "activate";
699    break;
[7350]700    case WA_DEACTIVATE:
[9869]701    return "deactivate";
702    break;
[7350]703    case WA_SPECIAL1:
[9869]704    return "special1";
705    break;
[7350]706    default:
[9869]707    return "none";
708    break;
[4885]709  }
710}
[3577]711
712/**
[4885]713 * Converts a String into a State.
714 * @param state the String input holding the State.
715 * @return The State if known, WS_NONE otherwise.
716 */
[7221]717WeaponState Weapon::charToState(const std::string& state)
[4885]718{
[7221]719  if (state == "none")
[4885]720    return WS_NONE;
[7221]721  else if (state == "shooting")
[4885]722    return WS_SHOOTING;
[7221]723  else if (state == "charging")
[4885]724    return WS_CHARGING;
[7221]725  else if (state == "reloading")
[4885]726    return WS_RELOADING;
[7221]727  else if (state == "activating")
[4885]728    return WS_ACTIVATING;
[7221]729  else if (state == "deactivating")
[4885]730    return WS_DEACTIVATING;
[7221]731  else if (state == "inactive")
[4885]732    return WS_INACTIVE;
[7221]733  else if (state == "idle")
[4885]734    return WS_IDLE;
735  else
[6438]736  {
[7221]737    PRINTF(2)("state %s could not be identified.\n", state.c_str());
[6438]738    return WS_NONE;
739  }
[4885]740}
[3583]741
742/**
[4885]743 * converts a State into a String
744 * @param state the state to convert
745 * @return a String matching the name of the state
746 */
747const char* Weapon::stateToChar(WeaponState state)
748{
749  switch (state)
750  {
[7350]751    case WS_SHOOTING:
[9869]752    return "shooting";
753    break;
[7350]754    case WS_CHARGING:
[9869]755    return "charging";
756    break;
[7350]757    case WS_RELOADING:
[9869]758    return "reloading";
759    break;
[7350]760    case WS_ACTIVATING:
[9869]761    return "activating";
762    break;
[7350]763    case WS_DEACTIVATING:
[9869]764    return "deactivating";
765    break;
[7350]766    case WS_IDLE:
[9869]767    return "idle";
768    break;
[7350]769    case WS_INACTIVE:
[9869]770    return "inactive";
771    break;
[7350]772    default:
[9869]773    return "none";
774    break;
[4885]775  }
776}
Note: See TracBrowser for help on using the repository browser.