Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

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

Last change on this file since 6675 was 6669, checked in by bensch, 19 years ago

some WeaponManager remake

File size: 13.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-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
206bool WeaponManager::addWeapon(Weapon* weapon)
207{
208  int weaponConf = this->currentConfigID;
209  int slot;
210  if (slot = this->getNextFreeSlot(weaponConf, weapon->getCapability()) == -1 )
211    this->addWeapon(weapon, weaponConf, slot);
212}
213
214/**
215 * adds a weapon to the selected weaponconfiguration into the selected slot
216 * @param weapon the weapon to add
217 * @param configID an identifier for the slot: number between 0..7 if not specified: slotID=next free slot
218 * @param slotID an identifier for the weapon configuration, number between 0..3
219 *
220 * if you add explicitly a weapon at config:n, slot:m, the weapon placed at this location will be
221 * replaced by the weapon specified. if you use the WM_FREE_SLOT, the manager will look for a free
222 * slot in this weaponconfiguration. if there is non, the weapon won't be added and there will be
223 * a error message.
224 */
225bool WeaponManager::addWeapon(Weapon* weapon, int configID, int slotID)
226{
227  if (unlikely(configID >= WM_MAX_CONFIGS || slotID >= (int)this->slotCount))
228  {
229    PRINTF(2)("Slot %d of config %d is not availiabe (max: %d)\n", slotID, configID, this->slotCount);
230    return false;
231  }
232
233  if (this->configs[configID][slotID] != NULL && configID > 0 && slotID > 0)
234    PRINTF(3)("Weapon-slot %d/%d of %s already poulated, overwriting\n", configID, slotID, this->getName());
235
236  if (slotID == -1) // WM_FREE_SLOT
237  {
238    slotID = this->getNextFreeSlot(configID, weapon->getCapability());
239    if( slotID < 0 || slotID >= this->slotCount)
240    {
241      PRINTF(1)("There is no free slot in this WeaponConfig to dock this weapon at! Aborting\n");
242      return false;
243    }
244  }
245
246  if (!(this->currentSlotConfig[slotID].capability & weapon->getCapability() & WTYPE_ALLKINDS) &&
247        this->currentSlotConfig[slotID].capability & weapon->getCapability() & WTYPE_ALLDIRS)
248  {
249    PRINTF(2)("Unable to add Weapon with wrong capatibility to Slot %d (W:%d M:%d)\n",
250              slotID, weapon->getCapability(), this->currentSlotConfig[slotID].capability);
251    return false;
252  }
253
254  //! @todo check if the weapon is already assigned to another config in another slot
255  this->configs[configID][slotID] = weapon;
256  weapon->setAmmoContainer(this->getAmmoContainer(weapon->getProjectileType()));
257  if (this->parent != NULL)
258  {
259    this->parent->addChild(weapon);
260  }
261  PRINTF(3)("Added a new Weapon to the WeaponManager: config %i/ slot %i\n", configID, slotID);
262  return true;
263}
264
265/**
266 * sets the capabilities of a Slot
267 * @param slot the slot to set the capability
268 * @param slotCapability the capability @see WM_SlotCapability
269 */
270void WeaponManager::setSlotCapability(int slot, long slotCapability)
271{
272  if (slot > slotCount)
273    return;
274  this->currentSlotConfig[slot].capability = slotCapability;
275}
276
277
278/**
279 * removes a Weapon from the WeaponManager
280 *
281 * !! The weapon must be inactive before you can delete it,    !!
282 * !! because it will still be deactivated (if it is selected) !!
283 */
284void WeaponManager::removeWeapon(Weapon* weapon, int configID)
285{
286  if (weapon == NULL)
287    return;
288  if (configID < 0)
289  {
290    for (int j = 0; j < WM_MAX_SLOTS; j++)
291    {
292      for (int i = 0; i < WM_MAX_CONFIGS; i++)
293      {
294        if (this->configs[i][j] == weapon)
295          this->configs[i][j] = NULL;
296      }
297      if (this->currentSlotConfig[j].currentWeapon == weapon)
298      {
299        this->currentSlotConfig[j].nextWeapon = NULL;
300      }
301    }
302  }
303}
304
305
306/**
307 * changes to the next weapon configuration
308 */
309void WeaponManager::nextWeaponConfig()
310{
311  ++this->currentConfigID;
312  if (this->currentConfigID >= WM_MAX_CONFIGS)
313    this->currentConfigID = 0;
314  this->changeWeaponConfig(this->currentConfigID);
315}
316
317/**
318 * changes to the previous configuration
319 */
320void WeaponManager::previousWeaponConfig()
321{
322  --this->currentConfigID;
323  if (this->currentConfigID < 0)
324    this->currentConfigID = WM_MAX_CONFIGS -1;
325  this->changeWeaponConfig(this->currentConfigID);
326}
327
328/**
329 * change to a desired configuration
330 * @param weaponConfig the configuration to jump to.
331 */
332void WeaponManager::changeWeaponConfig(int weaponConfig)
333{
334  this->currentConfigID = weaponConfig;
335  PRINTF(4)("Changing weapon configuration: to %i\n", this->currentConfigID);
336  for (int i = 0; i < WM_MAX_SLOTS; i++)
337  {
338    this->currentSlotConfig[i].nextWeapon = this->configs[currentConfigID][i];
339    if (this->currentSlotConfig[i].currentWeapon != this->currentSlotConfig[i].nextWeapon)
340    {
341      if (this->currentSlotConfig[i].currentWeapon != NULL)
342        (this->currentSlotConfig[i].currentWeapon->requestAction(WA_DEACTIVATE));
343      if (this->currentSlotConfig[i].nextWeapon != NULL && this->currentSlotConfig[i].nextWeapon->isActive())
344        this->currentSlotConfig[i].nextWeapon = NULL;
345    }
346  }
347}
348
349
350/**
351 * triggers fire of all weapons in the current weaponconfig
352 */
353void WeaponManager::fire()
354{
355  Weapon* firingWeapon;
356  for(int i = 0; i < this->slotCount; i++)
357  {
358    firingWeapon = this->currentSlotConfig[i].currentWeapon;
359    if( firingWeapon != NULL) firingWeapon->requestAction(WA_SHOOT);
360  }
361  this->crosshair->setRotationSpeed(500);
362  this->crossHairSizeAnim->replay();
363}
364
365
366/**
367 * triggers tick of all weapons in the current weaponconfig
368 * @param second passed since last tick
369 */
370void WeaponManager::tick(float dt)
371{
372  Weapon* tickWeapon;
373
374  // all weapons
375  for(int i = 0; i < this->slotCount; i++)
376  {
377
378    tickWeapon = this->currentSlotConfig[i].currentWeapon;
379    if (tickWeapon != this->currentSlotConfig[i].nextWeapon) // if no change occures
380    {
381      if (tickWeapon != NULL && tickWeapon->isActive())
382      {
383        tickWeapon->requestAction(WA_DEACTIVATE);
384      }
385      else
386      {
387        if (this->currentSlotConfig[i].currentWeapon != NULL)
388          this->currentSlotConfig[i].currentWeapon->toList(OM_NULL);
389        tickWeapon = this->currentSlotConfig[i].currentWeapon = this->currentSlotConfig[i].nextWeapon;
390        if (tickWeapon != NULL)
391        {
392          tickWeapon->requestAction(WA_ACTIVATE);
393          tickWeapon->setParent(&this->currentSlotConfig[i].position);
394          tickWeapon->toList(this->parent->getOMListNumber());
395          this->currentSlotConfig[i].position.activateNode();
396          if (this->parent->isA(CL_PLAYABLE))
397          {
398            dynamic_cast<Playable*>(this->parent)->weaponConfigChanged();
399          }
400        }
401        else
402          this->currentSlotConfig[i].position.deactivateNode();
403      }
404    }
405
406    if( tickWeapon != NULL && tickWeapon->isActive())
407      tickWeapon->tickW(dt);
408  }
409
410  crosshair->setRotationSpeed(5);
411}
412
413
414/**
415 * triggers draw of all weapons in the current weaponconfig
416 */
417void WeaponManager::draw() const
418{
419  Weapon* drawWeapon;
420  for (int i = 0; i < this->slotCount; i++)
421  {
422    drawWeapon = this->currentSlotConfig[i].currentWeapon;
423    if( drawWeapon != NULL && drawWeapon->isVisible())
424      drawWeapon->draw();
425  }
426}
427
428
429/**
430 * private gets the next free slot in a certain weaponconfig
431 * @param the selected weaponconfig -1 if none found
432 */
433int WeaponManager::getNextFreeSlot(int configID, long capability)
434{
435  for( int i = 0; i < this->slotCount; ++i)
436  {
437    if( this->configs[configID][i] == NULL &&
438        (this->currentSlotConfig[i].capability & capability & WTYPE_ALLKINDS) &&
439        (this->currentSlotConfig[i].capability & capability & WTYPE_ALLDIRS))
440      return i;
441  }
442  return -1;
443}
444
445CountPointer<AmmoContainer>& WeaponManager::getAmmoContainer(ClassID projectileType)
446{
447  for (unsigned int i = 0; i < this->ammo.size(); i++)
448  {
449    if (this->ammo[i]->getProjectileType() == projectileType)
450      return this->ammo[i];
451  }
452  this->ammo.push_back(CountPointer<AmmoContainer>(new AmmoContainer(projectileType)));
453  return this->ammo.back();
454}
455
456
457/**
458 * outputs some nice debug information about the WeaponManager
459 */
460void WeaponManager::debug() const
461{
462  PRINT(3)("WeaponManager Debug Information\n");
463  PRINT(3)("-------------------------------\n");
464  PRINT(3)("current Config is %d\n", this->currentConfigID);
465  for (int i = 0; i < WM_MAX_CONFIGS; i++)
466  {
467    PRINT(3)("Listing Weapons in Configuration %d\n", i);
468    for (int j = 0; j < WM_MAX_SLOTS; j++)
469    {
470      if (this->configs[i][j] != NULL)
471        PRINT(3)("Slot %d loaded a %s\n", j, this->configs[i][j]->getClassName());
472    }
473  }
474}
Note: See TracBrowser for help on using the repository browser.