Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/world_entities/weapons/weapon_manager.cc @ 6699

Last change on this file since 6699 was 6679, checked in by bensch, 19 years ago

orxonox/trunk: WeaponManager seems to work, better than before.

File size: 13.9 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-24: Benjamin Grauer: restructurate, so it can handle the new Weapons.
17*/
18
19#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_WEAPON
20
21#include "weapon_manager.h"
22#include "weapon.h"
23#include "crosshair.h"
24
25#include "playable.h"
26
27#include "load_param.h"
28#include "factory.h"
29
30#include "t_animation.h"
31
32using namespace std;
33
34
35/**
36 * @brief this initializes the weaponManager for a given nnumber of weapon slots
37 * @param number of weapon slots of the model/ship <= 8 (limitied)
38 */
39WeaponManager::WeaponManager(WorldEntity* parent)
40{
41  this->init();
42  this->setParent(parent);
43}
44
45WeaponManager::WeaponManager(const TiXmlElement* root)
46{
47  this->init();
48  this->loadParams(root);
49}
50
51/**
52 * @brief Destroys a WeaponManager
53 */
54WeaponManager::~WeaponManager()
55{
56  // crosshair being a PNode it must not be deleted (this is because PNodes delete themselves.)
57  //delete this->crosshair;
58}
59
60/**
61 * @brief initializes the WeaponManager
62 */
63void WeaponManager::init()
64{
65  this->setClassID(CL_WEAPON_MANAGER, "WeaponManager");
66
67  this->parent = NULL;
68
69  for (int i = 0; i < WM_MAX_CONFIGS; i++)
70    for (int j = 0; j < WM_MAX_SLOTS; j++)
71      this->configs[i][j] = NULL;
72
73  for (int i = 0; i < WM_MAX_SLOTS; i++)
74  {
75    this->currentSlotConfig[i].capability = WTYPE_ALL;
76    this->currentSlotConfig[i].currentWeapon = NULL;
77    this->currentSlotConfig[i].nextWeapon = NULL;
78
79    // NAMING
80    char* tmpName;
81    if (this->getName())
82    {
83      tmpName = new char[strlen(this->getName()) + 10];
84      sprintf(tmpName, "%s_slot%d", this->getName(), i);
85    }
86    else
87    {
88      tmpName = new char[30];
89      sprintf(tmpName, "WeaponMan_slot%d", i);
90    }
91    this->currentSlotConfig[i].position.setName(tmpName);
92    this->currentSlotConfig[i].position.deactivateNode();
93    delete[] tmpName;
94  }
95
96  for (int i = 0; i < WM_MAX_LOADED_WEAPONS; i++)
97    this->availiableWeapons[i] = NULL;
98
99
100  this->currentConfigID = 0;
101  this->slotCount = 2;
102  this->weaponChange;
103
104  // CROSSHAIR INITIALISATION
105  this->crosshair = new Crosshair();
106
107  this->crossHairSizeAnim = new tAnimation<Crosshair>(this->crosshair, &Crosshair::setSize);
108  this->crossHairSizeAnim->setInfinity(ANIM_INF_REWIND);
109  this->crossHairSizeAnim->addKeyFrame(50, .1, ANIM_LINEAR);
110  this->crossHairSizeAnim->addKeyFrame(100, .05, ANIM_LINEAR);
111  this->crossHairSizeAnim->addKeyFrame(50, .01, ANIM_LINEAR);
112}
113
114/**
115 * loads the settings of the WeaponManager
116 * @param root the XML-element to load from
117 */
118void WeaponManager::loadParams(const TiXmlElement* root)
119{
120  BaseObject::loadParams(root);
121
122  LoadParam(root, "slot-count", this, WeaponManager, setSlotCount)
123      .describe("how many slots(cannons) the WeaponManager can handle");
124
125  LOAD_PARAM_START_CYCLE(root, element);
126  {
127    // CHECK IF THIS WORKS....
128    LoadParamXML_CYCLE(element, "weapons", this, WeaponManager, loadWeapons)
129        .describe("loads Weapons");
130  }
131  LOAD_PARAM_END_CYCLE(element);
132}
133
134/**
135 * loads a Weapon onto the WeaponManager
136 * @param root the XML-element to load the Weapons from
137 */
138void WeaponManager::loadWeapons(const TiXmlElement* root)
139{
140  LOAD_PARAM_START_CYCLE(root, element);
141
142  Weapon* newWeapon = dynamic_cast<Weapon*>(Factory::fabricate(element));
143  /// @todo implement this !!
144
145
146  LOAD_PARAM_END_CYCLE(element);
147}
148
149/**
150 * sets the Parent of the WeaponManager.
151 * @param parent the parent of the WeaponManager
152 *
153 * this is used, to identify to which ship/man/whatever this WeaponManager is connected.
154 * also all the Slots will be subconnected to this parent.
155 *
156 * The reason this function exists is that the WeaponManager is neither a WorldEntity nor
157 * a PNode.
158 */
159void WeaponManager::setParent(WorldEntity* parent)
160{
161  this->parent = parent;
162  if (this->parent != NULL)
163  {
164    for (int i = 0; i < WM_MAX_SLOTS; i++)
165      this->parent->addChild(&this->currentSlotConfig[i].position);
166  }
167}
168
169/**
170 * sets the number of Slots the WeaponManager has
171 * @param slotCount the number of slots
172 */
173void WeaponManager::setSlotCount(unsigned int slotCount)
174{
175  if (slotCount <= WM_MAX_SLOTS)
176    this->slotCount = slotCount;
177  else
178    this->slotCount = WM_MAX_SLOTS;
179}
180
181
182/**
183 * sets the position of the Slot relative to the parent
184 * @param slot the slot to set-up
185 * @param position the position of the given slot
186 */
187void WeaponManager::setSlotPosition(int slot, const Vector& position)
188{
189  if (slot < this->slotCount)
190    this->currentSlotConfig[slot].position.setRelCoor(position);
191}
192
193
194/**
195 * sets the relative rotation of the slot to its parent
196 * @param slot the slot to set-up
197 * @param rotation the relative rotation of the given slot
198 */
199void WeaponManager::setSlotDirection(int slot, const Quaternion& rotation)
200{
201  if (slot < this->slotCount)
202    this->currentSlotConfig[slot].position.setRelDir(rotation);
203}
204
205
206/**
207 * adds a weapon to the selected weaponconfiguration into the selected slot
208 * @param weapon the weapon to add
209 * @param configID an identifier for the slot: number between 0..7 if not specified: slotID=next free slot
210 * @param slotID an identifier for the weapon configuration, number between 0..3
211 *
212 * if you add explicitly a weapon at config:n, slot:m, the weapon placed at this location will be
213 * replaced by the weapon specified. if you use the WM_FREE_SLOT, the manager will look for a free
214 * slot in this weaponconfiguration. if there is non, the weapon won't be added and there will be
215 * a error message.
216 */
217bool WeaponManager::addWeapon(Weapon* weapon, int configID, int slotID)
218{
219  assert(weapon != NULL);
220
221  if (unlikely(configID >= WM_MAX_CONFIGS || slotID >= (int)this->slotCount))
222  {
223    PRINTF(2)("Slot %d of config %d is not availiabe (max: %d) searching for suitable slot\n", slotID, configID, this->slotCount);
224    if (configID >= WM_MAX_CONFIGS)
225      configID = -1;
226    if (slotID >= (int)this->slotCount)
227      slotID = -1;
228  }
229  // if no ConfigID is supplied set to Current Config.
230  if (configID <= -1)
231    configID = this->currentConfigID;
232  //
233  if (configID > -1 && slotID == -1)
234  {
235    slotID = this->getNextFreeSlot(configID, weapon->getCapability());
236    if (slotID == -1)
237      configID = -1;
238  }
239
240  if (configID > 0 && slotID > 0 && this->configs[configID][slotID] != NULL)
241  {
242    PRINTF(3)("Weapon-slot %d/%d of %s already poulated, remove weapon (%s::%s) first\n", configID, slotID, this->getName(), weapon->getClassName(), weapon->getName());
243    return false;
244  }
245
246  if (slotID <= -1) // WM_FREE_SLOT
247  {
248    slotID = this->getNextFreeSlot(configID, weapon->getCapability());
249    if( slotID < 0 || slotID >= this->slotCount)
250    {
251      PRINTF(1)("There is no free slot in this WeaponConfig to dock this weapon at! Aborting\n");
252      return false;
253    }
254  }
255
256  if (!(this->currentSlotConfig[slotID].capability & weapon->getCapability() & WTYPE_ALLKINDS) &&
257        this->currentSlotConfig[slotID].capability & weapon->getCapability() & WTYPE_ALLDIRS)
258  {
259    PRINTF(2)("Unable to add Weapon with wrong capatibility to Slot %d (W:%d M:%d)\n",
260              slotID, weapon->getCapability(), this->currentSlotConfig[slotID].capability);
261    return false;
262  }
263
264  //! @todo check if the weapon is already assigned to another config in another slot
265  assert(this->configs[configID][slotID] == NULL);
266
267  this->configs[configID][slotID] = weapon;
268  weapon->setAmmoContainer(this->getAmmoContainer(weapon->getProjectileType()));
269  if (this->parent != NULL)
270  {
271    this->parent->addChild(weapon);
272  }
273  PRINTF(3)("Added a new Weapon (%s::%s) to the WeaponManager: config %i/ slot %i\n", weapon->getClassName(), weapon->getName(), configID, slotID);
274  return true;
275}
276
277/**
278 * sets the capabilities of a Slot
279 * @param slot the slot to set the capability
280 * @param slotCapability the capability @see WM_SlotCapability
281 */
282void WeaponManager::setSlotCapability(int slot, long slotCapability)
283{
284  if (slot > slotCount)
285    return;
286  this->currentSlotConfig[slot].capability = slotCapability;
287}
288
289
290/**
291 * removes a Weapon from the WeaponManager
292 *
293 * !! The weapon must be inactive before you can delete it,    !!
294 * !! because it will still be deactivated (if it is selected) !!
295 */
296void WeaponManager::removeWeapon(Weapon* weapon, int configID)
297{
298  if (weapon == NULL)
299    return;
300  if (configID < 0)
301  {
302    for (int j = 0; j < WM_MAX_SLOTS; j++)
303    {
304      for (int i = 0; i < WM_MAX_CONFIGS; i++)
305      {
306        if (this->configs[i][j] == weapon)
307          this->configs[i][j] = NULL;
308      }
309      if (this->currentSlotConfig[j].currentWeapon == weapon)
310      {
311        this->currentSlotConfig[j].nextWeapon = NULL;
312      }
313    }
314  }
315}
316
317
318/**
319 * changes to the next weapon configuration
320 */
321void WeaponManager::nextWeaponConfig()
322{
323  ++this->currentConfigID;
324  if (this->currentConfigID >= WM_MAX_CONFIGS)
325    this->currentConfigID = 0;
326  this->changeWeaponConfig(this->currentConfigID);
327}
328
329/**
330 * changes to the previous configuration
331 */
332void WeaponManager::previousWeaponConfig()
333{
334  --this->currentConfigID;
335  if (this->currentConfigID < 0)
336    this->currentConfigID = WM_MAX_CONFIGS -1;
337  this->changeWeaponConfig(this->currentConfigID);
338}
339
340/**
341 * change to a desired configuration
342 * @param weaponConfig the configuration to jump to.
343 */
344void WeaponManager::changeWeaponConfig(int weaponConfig)
345{
346  this->currentConfigID = weaponConfig;
347  PRINTF(4)("Changing weapon configuration: to %i\n", this->currentConfigID);
348  for (int i = 0; i < WM_MAX_SLOTS; i++)
349  {
350    this->currentSlotConfig[i].nextWeapon = this->configs[currentConfigID][i];
351    if (this->currentSlotConfig[i].currentWeapon != this->currentSlotConfig[i].nextWeapon)
352    {
353      if (this->currentSlotConfig[i].currentWeapon != NULL)
354        (this->currentSlotConfig[i].currentWeapon->requestAction(WA_DEACTIVATE));
355      if (this->currentSlotConfig[i].nextWeapon != NULL && this->currentSlotConfig[i].nextWeapon->isActive())
356        this->currentSlotConfig[i].nextWeapon = NULL;
357    }
358  }
359}
360
361
362/**
363 * triggers fire of all weapons in the current weaponconfig
364 */
365void WeaponManager::fire()
366{
367  Weapon* firingWeapon;
368  for(int i = 0; i < this->slotCount; i++)
369  {
370    firingWeapon = this->currentSlotConfig[i].currentWeapon;
371    if( firingWeapon != NULL) firingWeapon->requestAction(WA_SHOOT);
372  }
373  this->crosshair->setRotationSpeed(500);
374  this->crossHairSizeAnim->replay();
375}
376
377
378/**
379 * triggers tick of all weapons in the current weaponconfig
380 * @param second passed since last tick
381 */
382void WeaponManager::tick(float dt)
383{
384  Weapon* tickWeapon;
385
386  // all weapons
387  for(int i = 0; i < this->slotCount; i++)
388  {
389
390    tickWeapon = this->currentSlotConfig[i].currentWeapon;
391    if (tickWeapon != this->currentSlotConfig[i].nextWeapon) // if no change occures
392    {
393      if (tickWeapon != NULL && tickWeapon->isActive())
394      {
395        tickWeapon->requestAction(WA_DEACTIVATE);
396      }
397      else
398      {
399        if (this->currentSlotConfig[i].currentWeapon != NULL)
400          this->currentSlotConfig[i].currentWeapon->toList(OM_NULL);
401        tickWeapon = this->currentSlotConfig[i].currentWeapon = this->currentSlotConfig[i].nextWeapon;
402        if (tickWeapon != NULL)
403        {
404          tickWeapon->requestAction(WA_ACTIVATE);
405          tickWeapon->setParent(&this->currentSlotConfig[i].position);
406          tickWeapon->toList(this->parent->getOMListNumber());
407          this->currentSlotConfig[i].position.activateNode();
408          if (this->parent->isA(CL_PLAYABLE))
409          {
410            dynamic_cast<Playable*>(this->parent)->weaponConfigChanged();
411          }
412        }
413        else
414          this->currentSlotConfig[i].position.deactivateNode();
415      }
416    }
417
418    if( tickWeapon != NULL && tickWeapon->isActive())
419      tickWeapon->tickW(dt);
420  }
421
422  crosshair->setRotationSpeed(5);
423}
424
425
426/**
427 * triggers draw of all weapons in the current weaponconfig
428 */
429void WeaponManager::draw() const
430{
431  Weapon* drawWeapon;
432  for (int i = 0; i < this->slotCount; i++)
433  {
434    drawWeapon = this->currentSlotConfig[i].currentWeapon;
435    if( drawWeapon != NULL && drawWeapon->isVisible())
436      drawWeapon->draw();
437  }
438}
439
440
441/**
442 * private gets the next free slot in a certain weaponconfig
443 * @param the selected weaponconfig -1 if none found
444 */
445int WeaponManager::getNextFreeSlot(int configID, long capability)
446{
447  if (configID == -1)
448  {
449    for (configID = 0; configID < WM_MAX_CONFIGS; configID++)
450      for( int i = 0; i < this->slotCount; ++i)
451      {
452        if( this->configs[configID][i] == NULL &&
453            (this->currentSlotConfig[i].capability & capability & WTYPE_ALLKINDS) &&
454            (this->currentSlotConfig[i].capability & capability & WTYPE_ALLDIRS))
455          return i;
456    }
457  }
458  else
459  {
460    for( int i = 0; i < this->slotCount; ++i)
461    {
462      if( this->configs[configID][i] == NULL &&
463          (this->currentSlotConfig[i].capability & capability & WTYPE_ALLKINDS) &&
464          (this->currentSlotConfig[i].capability & capability & WTYPE_ALLDIRS))
465        return i;
466    }
467  }
468  return -1;
469}
470
471CountPointer<AmmoContainer>& WeaponManager::getAmmoContainer(ClassID projectileType)
472{
473  for (unsigned int i = 0; i < this->ammo.size(); i++)
474  {
475    if (this->ammo[i]->getProjectileType() == projectileType)
476      return this->ammo[i];
477  }
478  this->ammo.push_back(CountPointer<AmmoContainer>(new AmmoContainer(projectileType)));
479  return this->ammo.back();
480}
481
482
483/**
484 * outputs some nice debug information about the WeaponManager
485 */
486void WeaponManager::debug() const
487{
488  PRINT(3)("WeaponManager Debug Information\n");
489  PRINT(3)("-------------------------------\n");
490  PRINT(3)("current Config is %d\n", this->currentConfigID);
491  for (int i = 0; i < WM_MAX_CONFIGS; i++)
492  {
493    PRINT(3)("Listing Weapons in Configuration %d\n", i);
494    for (int j = 0; j < WM_MAX_SLOTS; j++)
495    {
496      if (this->configs[i][j] != NULL)
497        PRINT(3)("Slot %d loaded a %s\n", j, this->configs[i][j]->getClassName());
498    }
499  }
500}
Note: See TracBrowser for help on using the repository browser.