From 8898ad9b25fca6afe2374d293a981db02a83d7e9 Mon Sep 17 00:00:00 2001 From: "FWoltermann@gmail.com" Date: Thu, 31 May 2012 14:46:27 +0000 Subject: Committing the documentation to svn to have it accessible online --- Doc/doxygen/html/_drive_8cpp_source.html | 614 +++++++++++++++++++++++++++++++ 1 file changed, 614 insertions(+) create mode 100644 Doc/doxygen/html/_drive_8cpp_source.html (limited to 'Doc/doxygen/html/_drive_8cpp_source.html') diff --git a/Doc/doxygen/html/_drive_8cpp_source.html b/Doc/doxygen/html/_drive_8cpp_source.html new file mode 100644 index 0000000..5ee0b5e --- /dev/null +++ b/Doc/doxygen/html/_drive_8cpp_source.html @@ -0,0 +1,614 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/Stars45/Drive.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
Drive.cpp
+
+
+Go to the documentation of this file.
1 /* Project Starshatter 4.5
+
2  Destroyer Studios LLC
+
3  Copyright © 1997-2004. All Rights Reserved.
+
4 
+
5  SUBSYSTEM: Stars.exe
+
6  FILE: Drive.cpp
+
7  AUTHOR: John DiCamillo
+
8 
+
9 
+
10  OVERVIEW
+
11  ========
+
12  Weapon class
+
13 */
+
14 
+
15 #include "MemDebug.h"
+
16 #include "Drive.h"
+
17 #include "Power.h"
+
18 #include "Ship.h"
+
19 #include "Sim.h"
+
20 #include "DriveSprite.h"
+
21 #include "CameraDirector.h"
+
22 #include "AudioConfig.h"
+
23 
+
24 #include "Light.h"
+
25 #include "Bitmap.h"
+
26 #include "Sound.h"
+
27 #include "DataLoader.h"
+
28 #include "Bolt.h"
+
29 #include "Solid.h"
+
30 #include "Game.h"
+
31 
+
32 // +--------------------------------------------------------------------+
+
33 
+
34 static int drive_value[] = {
+
35  1, 1, 1, 1, 1, 1, 1, 1
+
36 };
+
37 
+
38 static float drive_light[] = {
+
39  10.0f, 100.0f, 5.0f, 1.0e3f, 100.0f, 10.0f, 0.0f, 0.0f
+
40 };
+
41 
+
42 Bitmap* drive_flare_bitmap[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
43 Bitmap* drive_trail_bitmap[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
44 Bitmap* drive_glow_bitmap[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
45 
+
46 static Sound* sound_resource[3] = { 0, 0, 0 };
+
47 
+
48 #define CLAMP(x, a, b) if (x < (a)) x = (a); else if (x > (b)) x = (b);
+
49 
+
50 // +----------------------------------------------------------------------+
+
51 
+
52 DrivePort::DrivePort(const Point& l, float s)
+
53 : loc(l), flare(0), trail(0), scale(s)
+
54 { }
+
55 
+
56 DrivePort::~DrivePort()
+
57 {
+
58  GRAPHIC_DESTROY(flare);
+
59  GRAPHIC_DESTROY(trail);
+
60 }
+
61 
+
62 // +----------------------------------------------------------------------+
+
63 
+
64 Drive::Drive(SUBTYPE drive_type, float max_thrust, float max_aug, bool show)
+
65 : System(DRIVE, drive_type, "Drive", drive_value[drive_type],
+
66 max_thrust*2, max_thrust*2, max_thrust*2),
+
67 thrust(max_thrust), augmenter(max_aug), scale(0.0f),
+
68 throttle(0.0f), augmenter_throttle(0.0f), intensity(0.0f),
+
69 sound(0), burner_sound(0), show_trail(show)
+
70 {
+
71  power_flags = POWER_WATTS;
+
72 
+
73  switch (drive_type) {
+
74  default:
+
75  case PLASMA: name = Game::GetText("sys.drive.plasma"); break;
+
76  case FUSION: name = Game::GetText("sys.drive.fusion"); break;
+
77  case GREEN: name = Game::GetText("sys.drive.green"); break;
+
78  case RED: name = Game::GetText("sys.drive.red"); break;
+
79  case BLUE: name = Game::GetText("sys.drive.blue"); break;
+
80  case YELLOW: name = Game::GetText("sys.drive.yellow"); break;
+
81  case STEALTH: name = Game::GetText("sys.drive.stealth"); break;
+
82  }
+
83 
+
84  abrv = Game::GetText("sys.drive.abrv");
+
85 
+
86  emcon_power[0] = 0;
+
87  emcon_power[1] = 50;
+
88  emcon_power[2] = 100;
+
89 }
+
90 
+
91 // +----------------------------------------------------------------------+
+
92 
+
93 Drive::Drive(const Drive& d)
+
94 : System(d), thrust(d.thrust), augmenter(d.augmenter), scale(d.scale),
+
95 throttle(0.0f), augmenter_throttle(0.0f), intensity(0.0f),
+
96 sound(0), burner_sound(0), show_trail(d.show_trail)
+
97 {
+
98  power_flags = POWER_WATTS;
+
99 
+
100  Mount(d);
+
101 
+
102  if (subtype != Drive::STEALTH) {
+
103  for (int i = 0; i < d.ports.size(); i++) {
+
104  DrivePort* p = d.ports[i];
+
105  CreatePort(p->loc, p->scale);
+
106  }
+
107  }
+
108 }
+
109 
+
110 // +--------------------------------------------------------------------+
+
111 
+
112 Drive::~Drive()
+
113 {
+
114  if (sound) {
+
115  sound->Stop();
+
116  sound->Release();
+
117  sound = 0;
+
118  }
+
119 
+
120  if (burner_sound) {
+
121  burner_sound->Stop();
+
122  burner_sound->Release();
+
123  burner_sound = 0;
+
124  }
+
125 
+
126  ports.destroy();
+
127 }
+
128 
+
129 // +--------------------------------------------------------------------+
+
130 
+
131 void
+
132 Drive::Initialize()
+
133 {
+
134  static int initialized = 0;
+
135  if (initialized) return;
+
136 
+
137  DataLoader* loader = DataLoader::GetLoader();
+
138  loader->SetDataPath("Drive/");
+
139  loader->LoadTexture("Drive0.pcx", drive_flare_bitmap[0], Bitmap::BMP_TRANSLUCENT);
+
140  loader->LoadTexture("Drive1.pcx", drive_flare_bitmap[1], Bitmap::BMP_TRANSLUCENT);
+
141  loader->LoadTexture("Drive2.pcx", drive_flare_bitmap[2], Bitmap::BMP_TRANSLUCENT);
+
142  loader->LoadTexture("Drive3.pcx", drive_flare_bitmap[3], Bitmap::BMP_TRANSLUCENT);
+
143  loader->LoadTexture("Drive4.pcx", drive_flare_bitmap[4], Bitmap::BMP_TRANSLUCENT);
+
144  loader->LoadTexture("Drive5.pcx", drive_flare_bitmap[5], Bitmap::BMP_TRANSLUCENT);
+
145 
+
146  loader->LoadTexture("Trail0.pcx", drive_trail_bitmap[0], Bitmap::BMP_TRANSLUCENT);
+
147  loader->LoadTexture("Trail1.pcx", drive_trail_bitmap[1], Bitmap::BMP_TRANSLUCENT);
+
148  loader->LoadTexture("Trail2.pcx", drive_trail_bitmap[2], Bitmap::BMP_TRANSLUCENT);
+
149  loader->LoadTexture("Trail3.pcx", drive_trail_bitmap[3], Bitmap::BMP_TRANSLUCENT);
+
150  loader->LoadTexture("Trail4.pcx", drive_trail_bitmap[4], Bitmap::BMP_TRANSLUCENT);
+
151  loader->LoadTexture("Trail5.pcx", drive_trail_bitmap[5], Bitmap::BMP_TRANSLUCENT);
+
152 
+
153  loader->LoadTexture("Glow0.pcx", drive_glow_bitmap[0], Bitmap::BMP_TRANSLUCENT);
+
154  loader->LoadTexture("Glow1.pcx", drive_glow_bitmap[1], Bitmap::BMP_TRANSLUCENT);
+
155  loader->LoadTexture("Glow2.pcx", drive_glow_bitmap[2], Bitmap::BMP_TRANSLUCENT);
+
156  loader->LoadTexture("Glow3.pcx", drive_glow_bitmap[3], Bitmap::BMP_TRANSLUCENT);
+
157  loader->LoadTexture("Glow4.pcx", drive_glow_bitmap[4], Bitmap::BMP_TRANSLUCENT);
+
158  loader->LoadTexture("Glow5.pcx", drive_glow_bitmap[5], Bitmap::BMP_TRANSLUCENT);
+
159 
+
160  const int SOUND_FLAGS = Sound::LOCALIZED |
+
161  Sound::LOC_3D |
+
162  Sound::LOOP |
+
163  Sound::LOCKED;
+
164 
+
165  loader->SetDataPath("Sounds/");
+
166  loader->LoadSound("engine.wav", sound_resource[0], SOUND_FLAGS);
+
167  loader->LoadSound("burner2.wav", sound_resource[1], SOUND_FLAGS);
+
168  loader->LoadSound("rumble.wav", sound_resource[2], SOUND_FLAGS);
+
169  loader->SetDataPath(0);
+
170 
+
171  if (sound_resource[0])
+
172  sound_resource[0]->SetMaxDistance(30.0e3f);
+
173 
+
174  if (sound_resource[1])
+
175  sound_resource[1]->SetMaxDistance(30.0e3f);
+
176 
+
177  if (sound_resource[2])
+
178  sound_resource[2]->SetMaxDistance(50.0e3f);
+
179 
+
180  initialized = 1;
+
181 }
+
182 
+
183 // +--------------------------------------------------------------------+
+
184 
+
185 void
+
186 Drive::Close()
+
187 {
+
188  for (int i = 0; i < 3; i++) {
+
189  delete sound_resource[i];
+
190  sound_resource[i] = 0;
+
191  }
+
192 }
+
193 
+
194 // +--------------------------------------------------------------------+
+
195 
+
196 void
+
197 Drive::StartFrame()
+
198 {
+
199 }
+
200 
+
201 // +--------------------------------------------------------------------+
+
202 
+
203 void
+
204 Drive::AddPort(const Point& loc, float flare_scale)
+
205 {
+
206  if (flare_scale == 0) flare_scale = scale;
+
207  DrivePort* port = new(__FILE__,__LINE__) DrivePort(loc, flare_scale);
+
208  ports.append(port);
+
209 }
+
210 
+
211 // +--------------------------------------------------------------------+
+
212 
+
213 void
+
214 Drive::CreatePort(const Point& loc, float flare_scale)
+
215 {
+
216  Bitmap* flare_bmp = drive_flare_bitmap[subtype];
+
217  Bitmap* trail_bmp = drive_trail_bitmap[subtype];
+
218  Bitmap* glow_bmp = 0;
+
219 
+
220  if (flare_scale <= 0)
+
221  flare_scale = scale;
+
222 
+
223  if (augmenter <= 0)
+
224  glow_bmp = drive_glow_bitmap[subtype];
+
225 
+
226  if (subtype != Drive::STEALTH && flare_scale > 0) {
+
227  DrivePort* port = new(__FILE__,__LINE__) DrivePort(loc, flare_scale);
+
228 
+
229  if (flare_bmp) {
+
230  DriveSprite* flare_rep = new(__FILE__,__LINE__) DriveSprite(flare_bmp, glow_bmp);
+
231  flare_rep->Scale(flare_scale * 1.5);
+
232  flare_rep->SetShade(0);
+
233  port->flare = flare_rep;
+
234  }
+
235 
+
236  if (trail_bmp && show_trail) {
+
237  Bolt* trail_rep = new(__FILE__,__LINE__) Bolt(flare_scale * 30, flare_scale * 8, trail_bmp, true);
+
238  port->trail = trail_rep;
+
239  }
+
240 
+
241  ports.append(port);
+
242  }
+
243 }
+
244 
+
245 // +--------------------------------------------------------------------+
+
246 
+
247 void
+
248 Drive::Orient(const Physical* rep)
+
249 {
+
250  System::Orient(rep);
+
251 
+
252  const Matrix& orientation = rep->Cam().Orientation();
+
253  Point ship_loc = rep->Location();
+
254 
+
255  for (int i = 0; i < ports.size(); i++) {
+
256  DrivePort* p = ports[i];
+
257 
+
258  Point projector = (p->loc * orientation) + ship_loc;
+
259 
+
260  if (p->flare) {
+
261  p->flare->MoveTo(projector);
+
262  p->flare->SetFront(rep->Cam().vpn() * -10 * p->scale);
+
263  }
+
264 
+
265  if (p->trail) {
+
266  if (intensity > 0.5) {
+
267  double len = -60 * p->scale * intensity;
+
268 
+
269  if (augmenter > 0 && augmenter_throttle > 0)
+
270  len += len * augmenter_throttle;
+
271 
+
272  p->trail->Show();
+
273  p->trail->SetEndPoints(projector, projector + rep->Cam().vpn() * len);
+
274  }
+
275  else {
+
276  p->trail->Hide();
+
277  }
+
278  }
+
279  }
+
280 }
+
281 
+
282 // +--------------------------------------------------------------------+
+
283 
+
284 static double drive_seconds=0;
+
285 
+
286 void
+
287 Drive::SetThrottle(double t, bool aug)
+
288 {
+
289  double spool = 1.2 * drive_seconds;
+
290  double throttle_request = t / 100;
+
291 
+
292  if (throttle < throttle_request) {
+
293  if (throttle_request-throttle < spool) {
+
294  throttle = (float) throttle_request;
+
295  }
+
296  else {
+
297  throttle += (float) spool;
+
298  }
+
299  }
+
300 
+
301  else if (throttle > throttle_request) {
+
302  if (throttle - throttle_request < spool) {
+
303  throttle = (float) throttle_request;
+
304  }
+
305  else {
+
306  throttle -= (float) spool;
+
307  }
+
308  }
+
309 
+
310  if (throttle < 0.5)
+
311  aug = false;
+
312 
+
313  if (aug && augmenter_throttle < 1) {
+
314  augmenter_throttle += (float) spool;
+
315 
+
316  if (augmenter_throttle > 1)
+
317  augmenter_throttle = 1.0f;
+
318  }
+
319  else if (!aug && augmenter_throttle > 0) {
+
320  augmenter_throttle -= (float) spool;
+
321 
+
322  if (augmenter_throttle < 0)
+
323  augmenter_throttle = 0.0f;
+
324  }
+
325 }
+
326 
+
327 // +----------------------------------------------------------------------+
+
328 
+
329 double
+
330 Drive::GetRequest(double seconds) const
+
331 {
+
332  if (!power_on) return 0;
+
333 
+
334  double t_factor = max(throttle + 0.5 * augmenter_throttle, 0.3);
+
335 
+
336  return t_factor * power_level * sink_rate * seconds;
+
337 }
+
338 
+
339 bool
+
340 Drive::IsAugmenterOn() const
+
341 {
+
342  return augmenter > 0 &&
+
343  augmenter_throttle > 0.05 &&
+
344  IsPowerOn() &&
+
345  status > CRITICAL;
+
346 }
+
347 
+
348 // +--------------------------------------------------------------------+
+
349 
+
350 int
+
351 Drive::NumEngines() const
+
352 {
+
353  return ports.size();
+
354 }
+
355 
+
356 DriveSprite*
+
357 Drive::GetFlare(int port) const
+
358 {
+
359  if (port >= 0 && port < ports.size()) {
+
360  return ports[port]->flare;
+
361  }
+
362 
+
363  return 0;
+
364 }
+
365 
+
366 Bolt*
+
367 Drive::GetTrail(int port) const
+
368 {
+
369  if (port >= 0 && port < ports.size()) {
+
370  return ports[port]->trail;
+
371  }
+
372 
+
373  return 0;
+
374 }
+
375 
+
376 // +--------------------------------------------------------------------+
+
377 
+
378 float
+
379 Drive::Thrust(double seconds)
+
380 {
+
381  drive_seconds = seconds;
+
382 
+
383  float eff = (energy/capacity) * availability * 100.0f;
+
384  float output = throttle * thrust * eff;
+
385  bool aug_on = IsAugmenterOn();
+
386 
+
387  if (aug_on) {
+
388  output += augmenter * augmenter_throttle * eff;
+
389 
+
390  // augmenter burns extra fuel:
+
391  PowerSource* reac = ship->Reactors()[source_index];
+
392  reac->SetCapacity(reac->GetCapacity() - (0.1 * drive_seconds));
+
393  }
+
394 
+
395  energy = 0.0f;
+
396 
+
397  if (output < 0 || GetPowerLevel() < 0.01)
+
398  output = 0.0f;
+
399 
+
400  int vol = -10000;
+
401  int vol_aug = -10000;
+
402  double fraction = output / thrust;
+
403 
+
404  for (int i = 0; i < ports.size(); i++) {
+
405  DrivePort* p = ports[i];
+
406 
+
407  if (p->flare) {
+
408  if (i == 0) {
+
409  if (fraction > 0)
+
410  intensity += (float) seconds;
+
411  else
+
412  intensity -= (float) seconds;
+
413 
+
414  // capture volume based on actual output:
+
415  CLAMP(intensity, 0.0f, 1.0f);
+
416 
+
417  if (intensity > 0.25) {
+
418  vol = (int) ((intensity - 1.0) * 10000.0);
+
419  CLAMP(vol, -10000, -1500);
+
420 
+
421  if (aug_on && intensity > 0.5) {
+
422  vol_aug = (int) ((5 * augmenter_throttle - 1.0) * 10000.0);
+
423  CLAMP(vol_aug, -10000, -1000);
+
424  }
+
425  }
+
426  }
+
427 
+
428  p->flare->SetShade(intensity);
+
429  }
+
430 
+
431  if (p->trail) {
+
432  p->trail->SetShade(intensity);
+
433  }
+
434  }
+
435 
+
436  CameraDirector* cam_dir = CameraDirector::GetInstance();
+
437 
+
438  // no sound when paused!
+
439  if (!Game::Paused() && subtype != STEALTH && cam_dir && cam_dir->GetCamera()) {
+
440  if (ship && ship->GetRegion() == Sim::GetSim()->GetActiveRegion()) {
+
441  if (!sound) {
+
442  int sound_index = 0;
+
443  if (thrust > 100)
+
444  sound_index = 2;
+
445 
+
446  if (sound_resource[sound_index])
+
447  sound = sound_resource[sound_index]->Duplicate();
+
448  }
+
449 
+
450  if (aug_on && !burner_sound) {
+
451  if (sound_resource[1])
+
452  burner_sound = sound_resource[1]->Duplicate();
+
453  }
+
454 
+
455  Point cam_loc = cam_dir->GetCamera()->Pos();
+
456  double dist = (ship->Location() - cam_loc).length();
+
457 
+
458  if (sound && dist < sound->GetMaxDistance()) {
+
459  long max_vol = AudioConfig::EfxVolume();
+
460 
+
461  if (vol > max_vol)
+
462  vol = max_vol;
+
463 
+
464  if (sound) {
+
465  sound->SetLocation(ship->Location());
+
466  sound->SetVolume(vol);
+
467  sound->Play();
+
468  }
+
469 
+
470  if (burner_sound) {
+
471  if (vol_aug > max_vol)
+
472  vol_aug = max_vol;
+
473 
+
474  burner_sound->SetLocation(ship->Location());
+
475  burner_sound->SetVolume(vol_aug);
+
476  burner_sound->Play();
+
477  }
+
478  }
+
479  else {
+
480  if (sound && sound->IsPlaying())
+
481  sound->Stop();
+
482 
+
483  if (burner_sound && burner_sound->IsPlaying())
+
484  burner_sound->Stop();
+
485  }
+
486  }
+
487  else {
+
488  if (sound && sound->IsPlaying())
+
489  sound->Stop();
+
490 
+
491  if (burner_sound && burner_sound->IsPlaying())
+
492  burner_sound->Stop();
+
493  }
+
494  }
+
495 
+
496  return output;
+
497 }
+
+
+ + + + -- cgit v1.1