Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 6235 was 6142, checked in by bensch, 19 years ago

orxonox/trunk: merge the ObjectManager to the trunk
merged with command:
svn merge -r6082:HEAD objectmanager/ ../trunk/

conflicts resolution was easy this time :)
but specially merged the world to network_world

File size: 19.2 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 "fast_factory.h"
24#include "projectile.h"
25
26#include "resource_manager.h"
27#include "class_list.h"
28#include "load_param.h"
29#include "state.h"
30#include "animation3d.h"
31#include "vector.h"
32
33#include "sound_source.h"
34#include "sound_buffer.h"
35
36////////////////////
37// INITAILISATION //
38// SETTING VALUES //
39////////////////////
40/**
41 * standard constructor
42 *
43 * creates a new weapon
44*/
45Weapon::Weapon ()
46{
47  this->init();
48}
49
50/**
51 * standard deconstructor
52*/
53Weapon::~Weapon ()
54{
55  for (int i = 0; i < WS_STATE_COUNT; i++)
56    if (this->animation[i] && ClassList::exists(animation[i], CL_ANIMATION))  //!< @todo this should check animation3D
57      delete this->animation[i];
58  for (int i = 0; i < WA_ACTION_COUNT; i++)
59    if (this->soundBuffers[i] != NULL && ClassList::exists(this->soundBuffers[i], CL_SOUND_BUFFER))
60      ResourceManager::getInstance()->unload(this->soundBuffers[i]);
61
62  if (ClassList::exists(this->soundSource, CL_SOUND_SOURCE))
63    delete this->soundSource;
64}
65
66/**
67 * initializes the Weapon with ALL default values
68 *
69 * This Sets the default values of the Weapon
70 */
71void Weapon::init()
72{
73  this->currentState     = WS_INACTIVE;            //< Normaly the Weapon is Inactive
74  this->requestedAction  = WA_NONE;                //< No action is requested by default
75  this->stateDuration    = 0.0;                    //< All the States have zero duration
76  for (int i = 0; i < WS_STATE_COUNT; i++)         //< Every State has:
77    {
78      this->times[i] = 0.0;                        //< An infinitesimal duration
79      this->animation[i] = NULL;                   //< No animation
80    }
81  for (int i = 0; i < WA_ACTION_COUNT; i++)
82    this->soundBuffers[i] = NULL;                  //< No Sounds
83
84  this->soundSource = new SoundSource(this);       //< Every Weapon has exacty one SoundSource.
85  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
86
87  this->projectile = CL_NULL;                      //< No Projectile Class is Connected to this weapon
88  this->projectileFactory = NULL;                  //< No Factory generating Projectiles is selected.
89
90  this->hideInactive = true;                       //< The Weapon will be hidden if it is inactive (by default)
91
92  this->minCharge = 1.0;                           //< The minimum charge the Weapon can hold is 1 unit.
93  this->maxCharge = 1.0;                           //< The maximum charge is also one unit.
94
95  this->energyLoaded = .0;                         //< How much energy is loaded in the Gun. (Weapons must be charged befor usage)
96  this->energyLoadedMax = 5.0;                     //< Each Weapon has a Maximum energy that can be charged onto it
97  this->energy = .0;                               //< The secondary Buffer (before we have to reload)
98  this->energyMax = 10.0;                          //< How much energy can be carried
99  this->capability = WTYPE_ALL;                    //< The Weapon has all capabilities @see W_Capability.
100}
101
102/**
103 * loads the Parameters of a Weapon
104 * @param root the XML-Element to load the Weapons settings from
105 */
106void Weapon::loadParams(const TiXmlElement* root)
107{
108  static_cast<WorldEntity*>(this)->loadParams(root);
109
110  LoadParam(root, "projectile", this, Weapon, setProjectileType)
111      .describe("Sets the name of the Projectile to load onto the Entity");
112
113  LoadParam(root, "emission-point", this, Weapon, setEmissionPoint)
114      .describe("Sets the Point of emission of this weapon");
115
116  LoadParam(root, "state-duration", this, Weapon, setStateDuration)
117      .describe("Sets the duration of a given state (1: state-Name; 2: duration in seconds)");
118
119  LoadParam(root, "action-sound", this, Weapon, setActionSound)
120      .describe("Sets a given sound to an action (1: action-Name; 2: name of the sound (relative to the Data-Path))");
121}
122
123/**
124 * sets the Projectile to use for this weapon.
125 * @param projectile The ID of the Projectile to use
126 * @returns true, if it was sucessfull, false on error
127 *
128 * be aware, that this function does not create Factories, as this is job of Projecitle/Bullet-classes.
129 * What it does, is telling the Weapon what Projectiles it can Emit.
130 */
131void Weapon::setProjectileType(ClassID projectile)
132{
133  if (projectile == CL_NULL)
134    return;
135  this->projectile = projectile;
136  this->projectileFactory = FastFactory::searchFastFactory(projectile);
137  if (this->projectileFactory == NULL)
138  {
139    PRINTF(1)("unable to find FastFactory for the Projectile.\n");
140    return;
141  }
142  else
143  {
144    // grabbing Parameters from the Projectile to have them at hand here.
145    Projectile* pj = dynamic_cast<Projectile*>(this->projectileFactory->resurrect());
146    this->minCharge = pj->getEnergyMin();
147    this->maxCharge = pj->getEnergyMax();
148    this->chargeable = pj->isChageable();
149    this->projectileFactory->kill(pj);
150  }
151}
152
153/**
154 * @see bool Weapon::setProjectile(ClassID projectile)
155 * @param projectile the Name of the Projectile.
156 */
157void Weapon::setProjectileType(const char* projectile)
158{
159  if (projectile == NULL)
160    return;
161  FastFactory* tmpFac = FastFactory::searchFastFactory(projectile);
162  if (tmpFac != NULL)
163  {
164    this->setProjectileType(tmpFac->getStoredID());
165  }
166  else
167  {
168    PRINTF(1)("Projectile %s does not exist for weapon %s\n", projectile, this->getName());
169  }
170}
171
172/**
173 * prepares Projectiles of the Weapon
174 * @param count how many Projectiles to create (they will be stored in the ProjectileFactory)
175 */
176void Weapon::prepareProjectiles(unsigned int count)
177{
178  if (likely(this->projectileFactory != NULL))
179    projectileFactory->prepare(count);
180  else
181    PRINTF(2)("unable to create %d projectile for Weapon %s (%s)\n", count, this->getName(), this->getClassName());
182}
183
184/**
185 * resurects and returns a Projectile
186 * @returns a Projectile on success, NULL on error
187 *
188 * errors: 1. (ProjectileFastFactory not Found)
189 *         2. No more Projectiles availiable.
190 */
191Projectile* Weapon::getProjectile()
192{
193  if (likely (this->projectileFactory != NULL))
194  {
195    Projectile* pj = dynamic_cast<Projectile*>(this->projectileFactory->resurrect());
196    pj->toList((OM_LIST)(this->getOMListNumber()+1));
197    return pj;
198  }
199  else
200  {
201    PRINTF(2)("No projectile defined for Weapon %s(%s) can't return any\n", this->getName(), this->getClassName());
202    return NULL;
203  }
204}
205
206
207/**
208 * sets the emissionPoint's relative position from the Weapon
209 * @param point the Point relative to the mass-point of the Weapon
210 */
211void Weapon::setEmissionPoint(const Vector& point)
212{
213  this->emissionPoint.setRelCoor(point);
214}
215
216/**
217 * assigns a Sound-file to an action
218 * @param action the action the sound should be assigned too
219 * @param soundFile the soundFile's relative position to the data-directory (will be looked for by the ResourceManager)
220 */
221void Weapon::setActionSound(WeaponAction action, const char* soundFile)
222{
223  if (action >= WA_ACTION_COUNT)
224    return;
225  if (this->soundBuffers[action] != NULL)
226    ResourceManager::getInstance()->unload(this->soundBuffers[action]);
227
228  else if (soundFile != NULL)
229  {
230    this->soundBuffers[action] = (SoundBuffer*)ResourceManager::getInstance()->load(soundFile, WAV);
231    if (this->soundBuffers[action] != NULL)
232    {
233      PRINTF(4)("Loaded sound %s to action %s.\n", soundFile, actionToChar(action));
234    }
235    else
236    {
237      PRINTF(2)("Failed to load sound %s to %s.\n.", soundFile, actionToChar(action));
238    }
239  }
240  else
241    this->soundBuffers[action] = NULL;
242}
243
244/**
245 * creates/returns an Animation3D for a certain State.
246 * @param state what State should the Animation be created/returned for
247 * @param node the node this Animation should apply to. (NULL is fine if the animation was already created)
248 * @returns The created animation.Animation(), NULL on error (or if the animation does not yet exist).
249 *
250 * This function does only generate the Animation Object, and if set it will
251 * automatically be executed, when a certain State is reached.
252 * What this does not do, is set keyframes, you have to operate on the returned animation.
253 */
254Animation3D* Weapon::getAnimation(WeaponState state, PNode* node)
255{
256  if (state >= WS_STATE_COUNT) // if the state is not known
257    return NULL;
258
259  if (unlikely(this->animation[state] == NULL)) // if the animation does not exist yet create it.
260  {
261    if (likely(node != NULL))
262      return this->animation[state] = new Animation3D(node);
263    else
264    {
265      PRINTF(2)("Node not defined for the Creation of the 3D-animation of state %s\n", stateToChar(state));
266      return NULL;
267    }
268  }
269  else
270    return this->animation[state];
271}
272
273/////////////////
274//  EXECUTION  //
275// GAME ACTION //
276/////////////////
277/**
278 * request an action that should be executed,
279 * @param action the next action to take
280 *
281 * This function must be called instead of the actions (like fire/reload...)
282 * to make all the checks needed to have a usefull WeaponSystem.
283 */
284void Weapon::requestAction(WeaponAction action)
285{
286  if (likely(this->isActive()))
287  {
288    if (this->requestedAction != WA_NONE)
289      return;
290    PRINTF(5)("next action will be %s in %f seconds\n", actionToChar(action), this->stateDuration);
291    this->requestedAction = action;
292  }
293  //else
294  else if (unlikely(action == WA_ACTIVATE))
295  {
296    this->currentState = WS_ACTIVATING;
297    this->requestedAction = WA_ACTIVATE;
298  }
299}
300
301/**
302 * adds energy to the Weapon
303 * @param energyToAdd The amount of energy
304 * @returns the amount of energy we did not pick up, because the weapon is already full
305 */
306float Weapon::increaseEnergy(float energyToAdd)
307{
308  float maxAddEnergy = this->energyMax - this->energy;
309
310  if (maxAddEnergy >= energyToAdd)
311  {
312    this->energy += energyToAdd;
313    return 0.0;
314  }
315  else
316  {
317    this->energy += maxAddEnergy;
318    return energyToAdd - maxAddEnergy;
319  }
320}
321
322////////////////////////////////////////////////////////////
323// WEAPON INTERNALS                                       //
324// These are functions, that no other Weapon should over- //
325// write. No class has direct Access to them, as it is    //
326// quite a complicated process, handling a Weapon from    //
327// the outside                                            //
328////////////////////////////////////////////////////////////
329/**
330 * executes an action, and with it starts a new State.
331 * @return true, if it worked, false otherwise
332 *
333 * This function checks, wheter the possibility of executing an action is valid,
334 * and does all the necessary stuff, to execute them. If an action does not succeed,
335 * it tries to go around it. (ex. shoot->noAmo->reload()->wait until shoot comes again)
336 */
337bool Weapon::execute()
338{
339#if DEBUG > 4
340  PRINTF(4)("trying to execute action %s\n", actionToChar(this->requestedAction));
341  this->debug();
342#endif
343
344  WeaponAction action = this->requestedAction;
345  this->requestedAction = WA_NONE;
346
347  switch (action)
348  {
349    case WA_SHOOT:
350      return this->fireW();
351      break;
352    case WA_CHARGE:
353      return this->chargeW();
354      break;
355    case WA_RELOAD:
356      return this->reloadW();
357      break;
358    case WA_DEACTIVATE:
359      return this->deactivateW();
360      break;
361    case WA_ACTIVATE:
362      return this->activateW();
363      break;
364  }
365}
366
367/**
368 * checks and activates the Weapon.
369 * @return true on success.
370 */
371bool Weapon::activateW()
372{
373//  if (this->currentState == WS_INACTIVE)
374  {
375        // play Sound
376    if (likely(this->soundBuffers[WA_ACTIVATE] != NULL))
377      this->soundSource->play(this->soundBuffers[WA_ACTIVATE]);
378        // activate
379    PRINTF(4)("Activating the Weapon %s\n", this->getName());
380    this->activate();
381    // setting up for next action
382    this->enterState(WS_ACTIVATING);
383  }
384}
385
386/**
387 * checks and deactivates the Weapon
388 * @return true on success.
389 */
390bool Weapon::deactivateW()
391{
392//  if (this->currentState != WS_INACTIVE)
393  {
394    PRINTF(4)("Deactivating the Weapon %s\n", this->getName());
395        // play Sound
396    if (this->soundBuffers[WA_DEACTIVATE] != NULL)
397      this->soundSource->play(this->soundBuffers[WA_DEACTIVATE]);
398    // deactivate
399    this->deactivate();
400    this->enterState(WS_DEACTIVATING);
401  }
402}
403
404/**
405 * checks and charges the Weapon
406 * @return true on success.
407 */
408bool Weapon::chargeW()
409{
410  if ( this->currentState != WS_INACTIVE && this->energyLoaded >= this->minCharge)
411  {
412        // playing Sound
413    if (this->soundBuffers[WA_CHARGE] != NULL)
414      this->soundSource->play(this->soundBuffers[WA_CHARGE]);
415
416        // charge
417    this->charge();
418        // setting up for the next state
419    this->enterState(WS_CHARGING);
420  }
421  else // deactivate the Weapon if we do not have enough energy
422  {
423    this->requestAction(WA_RELOAD);
424  }
425}
426
427/**
428 * checks and fires the Weapon
429 * @return true on success.
430 */
431bool Weapon::fireW()
432{
433     //if (likely(this->currentState != WS_INACTIVE))
434  if (this->minCharge <= this->energyLoaded)
435  {
436          // playing Sound
437    if (this->soundBuffers[WA_SHOOT] != NULL)
438      this->soundSource->play(this->soundBuffers[WA_SHOOT]);
439          // fire
440    this->fire();
441    this->energyLoaded -= this->minCharge;
442          // setting up for the next state
443    this->enterState(WS_SHOOTING);
444  }
445  else  // reload if we still have the charge
446  {
447    this->requestAction(WA_RELOAD);
448    this->execute();
449  }
450}
451
452/**
453 * checks and Reloads the Weapon
454 * @return true on success.
455 */
456bool Weapon::reloadW()
457{
458  PRINTF(4)("Reloading Weapon %s\n", this->getName());
459  if (unlikely(this->energy + this->energyLoaded < this->minCharge))
460  {
461    this->requestAction(WA_DEACTIVATE);
462    this->execute();
463    return false;
464  }
465
466  float chargeSize = this->energyLoadedMax - this->energyLoaded;       //!< The energy to be charged
467
468  if (this->soundBuffers[WA_RELOAD] != NULL)
469    this->soundSource->play(this->soundBuffers[WA_RELOAD]);
470
471  if (chargeSize > this->energy)
472  {
473    this->energyLoaded += this->energy;
474    this->energy = 0.0;
475    PRINT(5)("Energy depleted\n");
476  }
477  else
478  {
479    PRINTF(5)("Loaded %f energy into the Guns Buffer\n", chargeSize);
480    this->energyLoaded += chargeSize;
481    this->energy -= chargeSize;
482  }
483  this->reload();
484  this->enterState(WS_RELOADING);
485}
486
487/**
488 * enters the requested State, plays back animations updates the timing.
489 * @param state the state to enter.
490 */
491inline void Weapon::enterState(WeaponState state)
492{
493  PRINTF(4)("ENTERING STATE %s\n", stateToChar(state));
494  // playing animation if availiable
495  if (likely(this->animation[state] != NULL))
496    this->animation[state]->replay();
497
498  this->stateDuration = this->times[state] + this->stateDuration;
499  this->currentState = state;
500}
501
502///////////////////
503//  WORLD-ENTITY //
504// FUNCTIONALITY //
505///////////////////
506/**
507 * tick signal for time dependent/driven stuff
508*/
509void Weapon::tickW(float dt)
510{
511  //printf("%s ", stateToChar(this->currentState));
512
513  // setting up the timing properties
514  this->stateDuration -= dt;
515
516  if (this->stateDuration <= 0.0)
517  {
518    if (unlikely (this->currentState == WS_DEACTIVATING))
519    {
520      this->currentState = WS_INACTIVE;
521      return;
522    }
523    else
524      this->currentState = WS_IDLE;
525
526    if (this->requestedAction != WA_NONE)
527    {
528      this->stateDuration = -dt;
529      this->execute();
530    }
531  }
532  tick(dt);
533}
534
535
536
537
538//////////////////////
539// HELPER FUNCTIONS //
540//////////////////////
541/**
542 * checks wether all the Weapons functions are valid, and if it is possible to go to action with it.
543 * @todo IMPLEMENT the Weapons Check
544 */
545bool Weapon::check() const
546{
547  bool retVal = true;
548
549//  if (this->projectile == NULL)
550  {
551    PRINTF(1)("There was no projectile assigned to the Weapon.\n");
552    retVal = false;
553  }
554
555
556
557
558  return retVal;
559}
560
561/**
562 * some nice debugging information about this Weapon
563 */
564void Weapon::debug() const
565{
566  PRINT(3)("Weapon-Debug %s, state: %s, nextAction: %s\n", this->getName(), Weapon::stateToChar(this->currentState), Weapon::actionToChar(requestedAction));
567  PRINT(3)("Energy: max: %f; current: %f;  loadedMax: %f; loadedCurrent: %f; chargeMin: %f, chargeMax %f\n",
568            this->energyMax, this->energy, this->energyLoadedMax, this->energyLoaded, this->minCharge, this->maxCharge);
569
570
571}
572
573////////////////////////////////////////////////////////
574// static Definitions (transormators for readability) //
575////////////////////////////////////////////////////////
576/**
577 * Converts a String into an Action.
578 * @param action the String input holding the Action.
579 * @return The Action if known, WA_NONE otherwise.
580 */
581WeaponAction Weapon::charToAction(const char* action)
582{
583  if (!strcmp(action, "none"))
584    return WA_NONE;
585  else if (!strcmp(action, "shoot"))
586    return WA_SHOOT;
587  else if (!strcmp(action, "charge"))
588    return WA_CHARGE;
589  else if (!strcmp(action, "reload"))
590    return WA_RELOAD;
591  else if (!strcmp(action, "acitvate"))
592    return WA_ACTIVATE;
593  else if (!strcmp(action, "deactivate"))
594    return WA_DEACTIVATE;
595  else if (!strcmp(action, "special1"))
596    return WA_SPECIAL1;
597  else
598    {
599      PRINTF(2)("action %s could not be identified.\n", action);
600      return WA_NONE;
601    }
602}
603
604/**
605 * converts an action into a String
606 * @param action the action to convert
607 * @return a String matching the name of the action
608 */
609const char* Weapon::actionToChar(WeaponAction action)
610{
611  switch (action)
612  {
613    case WA_SHOOT:
614      return "shoot";
615      break;
616    case WA_CHARGE:
617      return "charge";
618      break;
619    case WA_RELOAD:
620      return "reload";
621      break;
622    case WA_ACTIVATE:
623      return "activate";
624      break;
625    case WA_DEACTIVATE:
626      return "deactivate";
627      break;
628    case WA_SPECIAL1:
629      return "special1";
630      break;
631    default:
632      return "none";
633      break;
634  }
635}
636
637/**
638 * Converts a String into a State.
639 * @param state the String input holding the State.
640 * @return The State if known, WS_NONE otherwise.
641 */
642WeaponState Weapon::charToState(const char* state)
643{
644  if (!strcmp(state, "none"))
645    return WS_NONE;
646  else if (!strcmp(state, "shooting"))
647    return WS_SHOOTING;
648  else if (!strcmp(state, "charging"))
649    return WS_CHARGING;
650  else if (!strcmp(state, "reloading"))
651    return WS_RELOADING;
652  else if (!strcmp(state, "activating"))
653    return WS_ACTIVATING;
654  else if (!strcmp(state, "deactivating"))
655    return WS_DEACTIVATING;
656  else if (!strcmp(state, "inactive"))
657    return WS_INACTIVE;
658  else if (!strcmp(state, "idle"))
659    return WS_IDLE;
660  else
661    {
662      PRINTF(2)("state %s could not be identified.\n", state);
663      return WS_NONE;
664    }
665}
666
667/**
668 * converts a State into a String
669 * @param state the state to convert
670 * @return a String matching the name of the state
671 */
672const char* Weapon::stateToChar(WeaponState state)
673{
674  switch (state)
675  {
676    case WS_SHOOTING:
677      return "shooting";
678      break;
679    case WS_CHARGING:
680      return "charging";
681      break;
682    case WS_RELOADING:
683      return "reloading";
684      break;
685    case WS_ACTIVATING:
686      return "activating";
687      break;
688    case WS_DEACTIVATING:
689      return "deactivating";
690      break;
691    case WS_IDLE:
692      return "idle";
693      break;
694    case WS_INACTIVE:
695      return "inactive";
696      break;
697    default:
698      return "none";
699      break;
700  }
701}
Note: See TracBrowser for help on using the repository browser.