Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 9869 was 9869, checked in by bensch, 17 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
Line 
1
2/*
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
12### File Specific
13   main-programmer: Patrick Boenzli
14   co-programmer: Benjamin Grauer
15
16   2005-07-15: Benjamin Grauer: restructurating the entire Class
17*/
18
19#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WEAPON
20
21#include "weapon.h"
22
23#include "loading/fast_factory.h"
24#include "world_entities/projectiles/projectile.h"
25
26#include "util/loading/factory.h"
27#include "util/loading/load_param.h"
28#include "state.h"
29#include "animation3d.h"
30
31#include "sound_source.h"
32#include "sound_buffer.h"
33#include "resource_sound_buffer.h"
34
35#include "elements/glgui_energywidget.h"
36
37ObjectListDefinition(Weapon);
38
39////////////////////
40// INITAILISATION //
41// SETTING VALUES //
42////////////////////
43/**
44 * standard constructor
45 *
46 * creates a new weapon
47*/
48Weapon::Weapon ()
49{
50  this->init();
51}
52
53/**
54 * standard deconstructor
55*/
56Weapon::~Weapon ()
57{
58  for (int i = 0; i < WS_STATE_COUNT; i++)
59    if (this->animation[i] && Animation::objectList().exists(animation[i]))  //!< @todo this should check animation3D
60      delete this->animation[i];
61
62  if (OrxSound::SoundSource::objectList().exists(this->soundSource))
63    delete this->soundSource;
64}
65
66/**
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 */
71Weapon* Weapon::createWeapon(const ClassID& weaponID)
72{
73  BaseObject* createdObject = Factory::fabricate(weaponID);
74  if (createdObject != NULL)
75  {
76    if (createdObject->isA(Weapon::staticClassID()))
77      return dynamic_cast<Weapon*>(createdObject);
78    else
79    {
80      delete createdObject;
81      return NULL;
82    }
83  }
84  return NULL;
85}
86
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
104/**
105 * initializes the Weapon with ALL default values
106 *
107 * This Sets the default values of the Weapon
108 */
109void Weapon::init()
110{
111  this->registerObject(this, Weapon::_objectList);
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:
116  {
117    this->times[i] = 0.0;                        //< An infinitesimal duration
118    this->animation[i] = NULL;                   //< No animation
119  }
120
121  this->soundSource = new OrxSound::SoundSource(this);       //< Every Weapon has exacty one SoundSource.
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
123  this->emissionPoint.setName("EmissionPoint");
124  this->emissionPoint.addNodeFlags(PNODE_PROHIBIT_DELETE_WITH_PARENT);
125
126  this->defaultTarget = NULL;                      //< Nothing is Targeted by default.
127
128  this->projectile = NullClass::staticClassID();         //< No Projectile Class is Connected to this weapon
129  this->projectileFactory = NULL;                  //< No Factory generating Projectiles is selected.
130
131  this->hideInactive = true;                       //< The Weapon will be hidden if it is inactive (by default)
132
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.
135
136  this->energy = 10;                               //< The secondary Buffer (before we have to reload)
137  this->energyMax = 10.0;                          //< How much energy can be carried
138  this->capability = WTYPE_ALL;                    //< The Weapon has all capabilities @see W_Capability.
139
140  this->energyWidget = NULL;
141
142  // set this object to be synchronized over network
143  //this->setSynchronized(true);
144}
145
146/**
147 * loads the Parameters of a Weapon
148 * @param root the XML-Element to load the Weapons settings from
149 */
150void Weapon::loadParams(const TiXmlElement* root)
151{
152  WorldEntity::loadParams(root);
153
154  LoadParam(root, "projectile", this, Weapon, setProjectileTypeC)
155  .describe("Sets the name of the Projectile to load onto the Entity");
156
157  LoadParam(root, "emission-point", this, Weapon, setEmissionPoint)
158  .describe("Sets the Point of emission of this weapon");
159
160  LoadParam(root, "state-duration", this, Weapon, setStateDuration)
161  .describe("Sets the duration of a given state (1: state-Name; 2: duration in seconds)");
162
163  LoadParam(root, "action-sound", this, Weapon, setActionSound)
164  .describe("Sets a given sound to an action (1: action-Name; 2: name of the sound (relative to the Data-Path))");
165}
166
167
168/**
169 * sets the Projectile to use for this weapon.
170 * @param projectile The ID of the Projectile to use
171 * @returns true, if it was sucessfull, false on error
172 *
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.
175 */
176void Weapon::setProjectileType(const ClassID& projectile)
177{
178  this->projectile = projectile;
179  this->projectileFactory = FastFactory::searchFastFactory(projectile);
180  if (this->projectileFactory == NULL)
181  {
182    PRINTF(1)("unable to find FastFactory for the Projectile.\n");
183    return;
184  }
185  else
186  {
187    // grabbing Parameters from the Projectile to have them at hand here.
188    Projectile* pj = dynamic_cast<Projectile*>(this->projectileFactory->resurrect());
189    this->minCharge = pj->getMinEnergy();
190    this->maxCharge = pj->getHealthMax();
191    this->chargeable = pj->isChageable();
192    this->projectileFactory->kill(pj);
193  }
194}
195
196
197/**
198 * @see bool Weapon::setProjectile(ClassID projectile)
199 * @param projectile the Name of the Projectile.
200 */
201void Weapon::setProjectileTypeC(const std::string& projectile)
202{
203  FastFactory* tmpFac = FastFactory::searchFastFactory(projectile);
204  if (tmpFac != NULL)
205  {
206    this->setProjectileType(tmpFac->getStoredID());
207  }
208  else
209  {
210    PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile.c_str(), this->getCName());
211  }
212}
213
214
215/**
216 * prepares Projectiles of the Weapon
217 * @param count how many Projectiles to create (they will be stored in the ProjectileFactory)
218 */
219void Weapon::prepareProjectiles(unsigned int count)
220{
221  if (likely(this->projectileFactory != NULL))
222    projectileFactory->prepare(count);
223  else
224    PRINTF(2)("unable to create %d projectile for Weapon %s::%s\n", count, this->getClassCName(), this->getCName());
225}
226
227
228/**
229 * resurects and returns a Projectile
230 * @returns a Projectile on success, NULL on error
231 *
232 * errors: 1. (ProjectileFastFactory not Found)
233 *         2. No more Projectiles availiable.
234 */
235Projectile* Weapon::getProjectile()
236{
237  if (likely (this->projectileFactory != NULL))
238  {
239    Projectile* pj = dynamic_cast<Projectile*>(this->projectileFactory->resurrect());
240    pj->toList((OM_LIST)(this->getOMListNumber()+1));
241    return pj;
242  }
243  else
244  {
245    PRINTF(2)("No projectile defined for Weapon %s(%s) can't return any\n", this->getCName(), this->getClassCName());
246    return NULL;
247  }
248}
249
250
251/**
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
260
261/**
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 */
266void Weapon::setActionSound(WeaponAction action, const std::string& soundFile)
267{
268  if (action >= WA_ACTION_COUNT)
269    return;
270
271  else if (!soundFile.empty())
272  {
273    this->soundBuffers[action] = OrxSound::ResourceSoundBuffer(soundFile);
274    if (this->soundBuffers[action].loaded())
275    {
276      PRINTF(4)("Loaded sound %s to action %s.\n", soundFile.c_str(), actionToChar(action));
277    }
278    else
279    {
280      PRINTF(2)("Failed to load sound %s to %s.\n.", soundFile.c_str(), actionToChar(action));
281    }
282  }
283  else
284    this->soundBuffers[action] = OrxSound::SoundBuffer();
285}
286
287
288/**
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).
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 */
298Animation3D* Weapon::getAnimation(WeaponState state, PNode* node)
299{
300  if (state >= WS_STATE_COUNT) // if the state is not known
301    return NULL;
302
303  if (unlikely(this->animation[state] == NULL)) // if the animation does not exist yet create it.
304  {
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    }
312  }
313  else
314    return this->animation[state];
315}
316
317OrxGui::GLGuiWidget* Weapon::getEnergyWidget()
318{
319  if (this->energyWidget == NULL)
320  {
321    this->energyWidget = new OrxGui::GLGuiEnergyWidget();
322    this->energyWidget->setDisplayedName(this->getClassCName());
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
339/////////////////
340//  EXECUTION  //
341// GAME ACTION //
342/////////////////
343/**
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{
352  if (likely(this->isActive()))
353  {
354    if (this->requestedAction != WA_NONE)
355      return;
356    PRINTF(5)("next action will be %s in %f seconds\n", actionToChar(action), this->stateDuration);
357    this->requestedAction = action;
358  }
359  //else
360  else if (unlikely(action == WA_ACTIVATE))
361  {
362    this->currentState = WS_ACTIVATING;
363    this->requestedAction = WA_ACTIVATE;
364  }
365}
366
367
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
389
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////////////////////////////////////////////////////////////
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 */
405bool Weapon::execute()
406{
407#if DEBUG_LEVEL > 4
408  PRINTF(4)("trying to execute action %s\n", actionToChar(this->requestedAction));
409  this->debug();
410#endif
411
412  WeaponAction action = this->requestedAction;
413  this->requestedAction = WA_NONE;
414
415  switch (action)
416  {
417    case WA_SHOOT:
418    return this->fireW();
419    break;
420    case WA_CHARGE:
421    return this->chargeW();
422    break;
423    case WA_RELOAD:
424    return this->reloadW();
425    break;
426    case WA_DEACTIVATE:
427    return this->deactivateW();
428    break;
429    case WA_ACTIVATE:
430    return this->activateW();
431    break;
432    default:
433    PRINTF(2)("Action %s Not Implemented yet \n", Weapon::actionToChar(action));
434    return false;
435  }
436}
437
438/**
439 * checks and activates the Weapon.
440 * @return true on success.
441 */
442bool Weapon::activateW()
443{
444  //  if (this->currentState == WS_INACTIVE)
445  {
446    // play Sound
447    if (likely(this->soundBuffers[WA_ACTIVATE].loaded()))
448      this->soundSource->play(this->soundBuffers[WA_ACTIVATE]);
449    this->updateWidgets();
450    // activate
451    PRINTF(4)("Activating the Weapon %s\n", this->getCName());
452    this->activate();
453    // setting up for next action
454    this->enterState(WS_ACTIVATING);
455  }
456  return true;
457}
458
459/**
460 * checks and deactivates the Weapon
461 * @return true on success.
462 */
463bool Weapon::deactivateW()
464{
465  //  if (this->currentState != WS_INACTIVE)
466  {
467    PRINTF(4)("Deactivating the Weapon %s\n", this->getCName());
468    // play Sound
469    if (this->soundBuffers[WA_DEACTIVATE].loaded())
470      this->soundSource->play(this->soundBuffers[WA_DEACTIVATE]);
471    // deactivate
472    this->deactivate();
473    this->enterState(WS_DEACTIVATING);
474  }
475
476  return true;
477}
478
479/**
480 * checks and charges the Weapon
481 * @return true on success.
482 */
483bool Weapon::chargeW()
484{
485  if ( this->currentState != WS_INACTIVE && this->energy >= this->minCharge)
486  {
487    // playing Sound
488    if (this->soundBuffers[WA_CHARGE].loaded())
489      this->soundSource->play(this->soundBuffers[WA_CHARGE]);
490
491    // charge
492    this->charge();
493    // setting up for the next state
494    this->enterState(WS_CHARGING);
495  }
496  else // deactivate the Weapon if we do not have enough energy
497  {
498    this->requestAction(WA_RELOAD);
499  }
500  return true;
501}
502
503/**
504 * checks and fires the Weapon
505 * @return true on success.
506 */
507bool Weapon::fireW()
508{
509  //if (likely(this->currentState != WS_INACTIVE))
510  if (this->minCharge <= this->energy)
511  {
512    // playing Sound
513    if (this->soundBuffers[WA_SHOOT].loaded())
514      this->soundSource->play(this->soundBuffers[WA_SHOOT]);
515    this->updateWidgets();
516    // fire
517    this->energy -= this->minCharge;
518    this->fire();
519    // setting up for the next state
520    this->enterState(WS_SHOOTING);
521  }
522  else  // reload if we still have the charge
523  {
524    this->requestAction(WA_RELOAD);
525    this->execute();
526  }
527  return true;
528}
529
530/**
531 * checks and Reloads the Weapon
532 * @return true on success.
533 */
534bool Weapon::reloadW()
535{
536  PRINTF(4)("Reloading Weapon %s\n", this->getCName());
537  if (!this->ammoContainer.isNull() &&
538      unlikely(this->energy + this->ammoContainer->getStoredEnergy() < this->minCharge))
539  {
540    this->requestAction(WA_DEACTIVATE);
541    this->execute();
542    return false;
543  }
544
545
546  if (this->soundBuffers[WA_RELOAD].loaded())
547    this->soundSource->play(this->soundBuffers[WA_RELOAD]);
548
549  if (!this->ammoContainer.isNull())
550    this->ammoContainer->fillWeapon(this);
551  else
552  {
553    this->energy = this->energyMax;
554  }
555  this->updateWidgets();
556  this->reload();
557  this->enterState(WS_RELOADING);
558
559  return true;
560}
561
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{
568  PRINTF(4)("ENTERING STATE %s\n", stateToChar(state));
569  // playing animation if availiable
570  if (likely(this->animation[state] != NULL))
571    this->animation[state]->replay();
572
573  this->stateDuration += this->times[state];
574  this->currentState = state;
575}
576
577///////////////////
578//  WORLD-ENTITY //
579// FUNCTIONALITY //
580///////////////////
581/**
582 * tick signal for time dependent/driven stuff
583*/
584bool Weapon::tickW(float dt)
585{
586  //printf("%s ", stateToChar(this->currentState));
587
588  // setting up the timing properties
589  this->stateDuration -= dt;
590
591  if (this->stateDuration <= 0.0)
592  {
593    if (unlikely (this->currentState == WS_DEACTIVATING))
594    {
595      this->currentState = WS_INACTIVE;
596      return false;
597    }
598    else
599      this->currentState = WS_IDLE;
600
601    if (this->requestedAction != WA_NONE)
602    {
603      this->stateDuration = -dt;
604      this->execute();
605    }
606  }
607  return true;
608}
609
610
611
612
613//////////////////////
614// HELPER FUNCTIONS //
615//////////////////////
616/**
617 * checks wether all the Weapons functions are valid, and if it is possible to go to action with it.
618 * @todo IMPLEMENT the Weapons Check
619 */
620bool Weapon::check() const
621{
622  bool retVal = true;
623
624  //  if (this->projectile == NULL)
625  {
626    PRINTF(1)("There was no projectile assigned to the Weapon.\n");
627    retVal = false;
628  }
629
630
631
632
633  return retVal;
634}
635
636/**
637 * some nice debugging information about this Weapon
638 */
639void Weapon::debug() const
640{
641  PRINT(0)("Weapon-Debug %s, state: %s (duration: %fs), nextAction: %s\n", this->getCName(), Weapon::stateToChar(this->currentState), this->stateDuration, Weapon::actionToChar(requestedAction));
642  PRINT(0)("Energy: max: %f; current: %f; chargeMin: %f, chargeMax %f\n",
643           this->energyMax, this->energy, this->minCharge, this->maxCharge);
644
645
646}
647
648////////////////////////////////////////////////////////
649// static Definitions (transormators for readability) //
650////////////////////////////////////////////////////////
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 */
656WeaponAction Weapon::charToAction(const std::string& action)
657{
658  if (action == "none")
659    return WA_NONE;
660  else if (action == "shoot")
661    return WA_SHOOT;
662  else if (action == "charge")
663    return WA_CHARGE;
664  else if (action == "reload")
665    return WA_RELOAD;
666  else if (action == "acitvate")
667    return WA_ACTIVATE;
668  else if (action == "deactivate")
669    return WA_DEACTIVATE;
670  else if (action == "special1")
671    return WA_SPECIAL1;
672  else
673  {
674    PRINTF(2)("action %s could not be identified.\n", action.c_str());
675    return WA_NONE;
676  }
677}
678
679/**
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  {
688    case WA_SHOOT:
689    return "shoot";
690    break;
691    case WA_CHARGE:
692    return "charge";
693    break;
694    case WA_RELOAD:
695    return "reload";
696    break;
697    case WA_ACTIVATE:
698    return "activate";
699    break;
700    case WA_DEACTIVATE:
701    return "deactivate";
702    break;
703    case WA_SPECIAL1:
704    return "special1";
705    break;
706    default:
707    return "none";
708    break;
709  }
710}
711
712/**
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 */
717WeaponState Weapon::charToState(const std::string& state)
718{
719  if (state == "none")
720    return WS_NONE;
721  else if (state == "shooting")
722    return WS_SHOOTING;
723  else if (state == "charging")
724    return WS_CHARGING;
725  else if (state == "reloading")
726    return WS_RELOADING;
727  else if (state == "activating")
728    return WS_ACTIVATING;
729  else if (state == "deactivating")
730    return WS_DEACTIVATING;
731  else if (state == "inactive")
732    return WS_INACTIVE;
733  else if (state == "idle")
734    return WS_IDLE;
735  else
736  {
737    PRINTF(2)("state %s could not be identified.\n", state.c_str());
738    return WS_NONE;
739  }
740}
741
742/**
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  {
751    case WS_SHOOTING:
752    return "shooting";
753    break;
754    case WS_CHARGING:
755    return "charging";
756    break;
757    case WS_RELOADING:
758    return "reloading";
759    break;
760    case WS_ACTIVATING:
761    return "activating";
762    break;
763    case WS_DEACTIVATING:
764    return "deactivating";
765    break;
766    case WS_IDLE:
767    return "idle";
768    break;
769    case WS_INACTIVE:
770    return "inactive";
771    break;
772    default:
773    return "none";
774    break;
775  }
776}
Note: See TracBrowser for help on using the repository browser.