]> icculus.org git repositories - taylor/freespace2.git/blob - src/nebula/neblightning.cpp
get rid of extra static box flag
[taylor/freespace2.git] / src / nebula / neblightning.cpp
1 /*
2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
3  *
4  * All source code herein is the property of Volition, Inc. You may not sell 
5  * or otherwise commercially exploit the source or things you created based on
6  * the source.
7  */
8
9 /*
10  * $Logfile: /Freespace2/code/Nebula/NebLightning.cpp $
11  * $Revision$
12  * $Date$
13  * $Author$
14  *
15  * Nebula effect
16  *
17  * $Log$
18  * Revision 1.7  2004/09/20 01:31:44  theoddone33
19  * GCC 3.4 fixes.
20  *
21  * Revision 1.6  2004/07/04 11:39:06  taylor
22  * fix missing debrief text, crash on exit, path separator's, warning fixes, no GR_SOFT
23  *
24  * Revision 1.5  2003/05/25 02:30:43  taylor
25  * Freespace 1 support
26  *
27  * Revision 1.4  2002/06/17 06:33:09  relnev
28  * ryan's struct patch for gcc 2.95
29  *
30  * Revision 1.3  2002/06/09 04:41:23  relnev
31  * added copyright header
32  *
33  * Revision 1.2  2002/05/07 03:16:47  theoddone33
34  * The Great Newline Fix
35  *
36  * Revision 1.1.1.1  2002/05/03 03:28:10  root
37  * Initial import.
38  * 
39  * 
40  * 10    8/15/99 3:50p Dave
41  * Don't process lightning at the very beginning of a mission.
42  * 
43  * 9     8/12/99 10:38a Anoop
44  * Removed unnecessary Int3().
45  * 
46  * 8     8/05/99 2:06a Dave
47  * Whee.
48  * 
49  * 7     7/27/99 9:51p Andsager
50  * make mprintf's into nprintf's
51  * 
52  * 6     7/03/99 5:50p Dave
53  * Make rotated bitmaps draw properly in padlock views.
54  * 
55  * 5     7/02/99 4:31p Dave
56  * Much more sophisticated lightning support.
57  * 
58  * 4     6/09/99 10:32a Dave
59  * Made random lighting bolts behave more like the E3 demo. Generally more
60  * active.
61  * 
62  * 3     5/26/99 11:46a Dave
63  * Added ship-blasting lighting and made the randomization of lighting
64  * much more customizable.
65  * 
66  * 2     5/24/99 5:45p Dave
67  * Added detail levels to the nebula, with a decent speedup. Split nebula
68  * lightning into its own section.
69  * 
70  * $NoKeywords: $
71  */
72
73 #include "parselo.h"
74 #include "linklist.h"
75 #include "bmpman.h"
76 #include "timer.h"
77 #include "freespace.h"
78 #include "gamesnd.h"
79 #include "3d.h"
80 #include "missionparse.h"
81 #include "neb.h"
82 #include "neblightning.h"
83 #include "multi.h"
84 #include "emp.h"
85 #include "multimsgs.h"
86
87 // ------------------------------------------------------------------------------------------------------
88 // NEBULA LIGHTNING DEFINES/VARS
89 //
90
91 // debug stuff
92 #define MAX_BOLT_TYPES_INTERNAL         11
93
94 // see lightning.tbl for explanations of these values
95 typedef struct bolt_type {
96         char            name[NAME_LENGTH];
97
98         float           b_scale;
99         float           b_shrink;
100         float           b_poly_pct;     
101         float           b_add;
102         float           b_rand;
103
104         float           noise;
105         int             lifetime;
106         int             num_strikes;
107
108         float           emp_intensity;
109         float           emp_time;
110         
111         int             texture;
112         int             glow;   
113
114         float           b_bright;
115 } bolt_type;
116
117 int Num_bolt_types = 0;
118 bolt_type Bolt_types[MAX_BOLT_TYPES_INTERNAL];
119
120 // storm types
121 int Num_storm_types = 0;
122 storm_type Storm_types[MAX_STORM_TYPES];
123
124
125 // actual lightning bolt stuff -------
126
127 #define MAX_LIGHTNING_NODES                                     500
128
129 // nodes in a lightning bolt
130 #define LINK_LEFT               0
131 #define LINK_RIGHT      1
132 #define LINK_CHILD      2
133 typedef struct l_node {
134         vector  pos;                            // world position
135         l_node  *links[3];              // 3 links for lightning children
136
137         l_node *next, *prev;            // for used and free-lists only
138 } l_node;
139
140
141 // nodes
142 l_node Nebl_nodes[MAX_LIGHTNING_NODES];
143 int Num_lnodes = 0;
144
145 // lightning node lists
146 l_node Nebl_free_list;
147 l_node Nebl_used_list;
148
149 // actual lightning bolt themselves
150 typedef struct l_bolt {
151         l_node *head;                           // head of the lightning bolt
152         int bolt_life;                          // remaining life timestamp
153         ubyte used;                                     // used or not
154         ubyte   first_frame;            // if he hasn't been rendered at least once     
155         char type;
156
157         // bolt info
158         vector start, strike, midpoint;
159         int delay;                                      // delay stamp
160         int strikes_left;                       // #of strikes left
161         float width;
162 } l_bolt;
163
164 #define MAX_LIGHTNING_BOLTS                                     10
165
166 // lightning bolts
167 l_bolt Nebl_bolts[MAX_LIGHTNING_BOLTS];
168 int Nebl_bolt_count = 0;
169
170 // one cross-section of a lightning bolt
171 typedef struct l_section {              
172         vertex  vex[3];
173         vertex  glow_vex[2];
174 } l_section;
175
176 // points on the basic cross section
177 vector Nebl_ring[3] = { 
178         { { { -1.0f, 0.0f, 0.0f } } },
179         { { { 1.0f, 0.70f, 0.0f } } },
180         { { { 1.0f, -0.70f, 0.0f } } }  
181 };
182
183 // pinched off cross-section
184 vector Nebl_ring_pinched[3] = { 
185         { { { -0.05f, 0.0f, 0.0f } } },
186         { { { 0.05f, 0.035f, 0.0f } } },
187         { { { 0.05f, -0.035f, 0.0f } } }        
188 };
189
190 // globals used for rendering and generating bolts
191 int Nebl_flash_count = 0;               // # of points rendered onscreen for this bolt
192 float Nebl_flash_x = 0.0f;              // avg x of the points rendered
193 float Nebl_flash_y = 0.0f;              // avg y of the points rendered
194 float Nebl_bang = 0.0;                  // distance to the viewer object
195 float Nebl_alpha = 0.0f;                // alpha to use when rendering the bolt itself
196 float Nebl_glow_alpha = 0.0f;   // alpha to use when rendering the bolt glow
197 int Nebl_stamp = -1;                            // random timestamp for making bolts
198 float Nebl_bolt_len;                            // length of the current bolt being generated
199 bolt_type *Nebl_type;                   // bolt type
200 matrix Nebl_bolt_dir;                   // orientation matrix of the bolt being generated
201 vector Nebl_bolt_start;                 // start point of the bolt being generated
202 vector Nebl_bolt_strike;                // strike point of the bolt being generated
203
204 // the type of active storm
205 storm_type *Storm = NULL;
206
207 // vars
208 DCF(b_scale, "")
209 {
210         dc_get_arg(ARG_FLOAT);
211         Bolt_types[DEBUG_BOLT].b_scale = Dc_arg_float;
212 }
213 DCF(b_rand, "")
214 {
215         dc_get_arg(ARG_FLOAT);
216         Bolt_types[DEBUG_BOLT].b_rand = Dc_arg_float;
217 }
218 DCF(b_shrink, "")
219 {
220         dc_get_arg(ARG_FLOAT);
221         Bolt_types[DEBUG_BOLT].b_shrink = Dc_arg_float;
222 }
223 DCF(b_poly_pct, "")
224 {
225         dc_get_arg(ARG_FLOAT);
226         Bolt_types[DEBUG_BOLT].b_poly_pct = Dc_arg_float;
227 }
228 DCF(b_add, "")
229 {
230         dc_get_arg(ARG_FLOAT);
231         Bolt_types[DEBUG_BOLT].b_add = Dc_arg_float;
232 }
233 DCF(b_strikes, "")
234 {
235         dc_get_arg(ARG_INT);
236         Bolt_types[DEBUG_BOLT].num_strikes = Dc_arg_int;
237 }
238 DCF(b_noise, "")
239 {
240         dc_get_arg(ARG_FLOAT);
241         Bolt_types[DEBUG_BOLT].noise = Dc_arg_float;
242 }
243 DCF(b_bright, "")
244 {
245         dc_get_arg(ARG_FLOAT);
246         Bolt_types[DEBUG_BOLT].b_bright = Dc_arg_float;
247 }
248 DCF(b_lifetime, "")
249 {
250         dc_get_arg(ARG_INT);
251         Bolt_types[DEBUG_BOLT].lifetime = Dc_arg_int;
252 }
253 DCF(b_list, "")
254 {
255         dc_printf("Debug lightning bolt settings :\n");
256
257         dc_printf("b_scale : %f\n", Bolt_types[DEBUG_BOLT].b_scale);
258         dc_printf("b_rand : %f\n", Bolt_types[DEBUG_BOLT].b_rand);
259         dc_printf("b_shrink : %f\n", Bolt_types[DEBUG_BOLT].b_shrink);
260         dc_printf("b_poly_pct : %f\n", Bolt_types[DEBUG_BOLT].b_poly_pct);
261         dc_printf("b_add : %f\n", Bolt_types[DEBUG_BOLT].b_add);
262         dc_printf("b_strikes : %d\n", Bolt_types[DEBUG_BOLT].num_strikes);
263         dc_printf("b_noise : %f\n", Bolt_types[DEBUG_BOLT].noise);
264         dc_printf("b_bright : %f\n", Bolt_types[DEBUG_BOLT].b_bright);
265         dc_printf("b_lifetime : %d\n", Bolt_types[DEBUG_BOLT].lifetime);
266 }
267
268
269 // nebula lightning intensity (0.0 to 1.0)
270 float Nebl_intensity = 0.6667f;
271
272 // min and max times for random lightning
273 int Nebl_random_min = 750;                              // min random time
274 int Nebl_random_max = 10000;                    // max random time
275
276 // min and max times for cruiser lightning
277 int Nebl_cruiser_min = 5000;                    // min cruiser time
278 int Nebl_cruiser_max = 25000;                   // max cruiser time
279
280 // min and max times for cap ships
281 int Nebl_cap_min = 4000;                                // min cap time
282 int Nebl_cap_max = 18000;                               // max cap time
283
284 // min and max time for super caps
285 int Nebl_supercap_min = 3000;                   // min supercap time
286 int Nebl_supercap_max = 12000;          // max supercap time
287
288 DCF(lightning_intensity, "")
289 {
290         dc_get_arg(ARG_FLOAT);
291         float val = Dc_arg_float;
292         if(val < 0.0f){
293                 val = 0.0f;
294         } else if(val > 1.0f){
295                 val = 1.0f;
296         }
297
298         Nebl_intensity = 1.0f - val;
299 }
300
301 // ------------------------------------------------------------------------------------------------------
302 // NEBULA LIGHTNING FORWARD DECLARATIONS
303 //
304
305 // "new" a lightning node
306 l_node *nebl_new();
307
308 // "delete" a lightning node
309 void nebl_delete(l_node *lp);
310
311 // free up a the nodes of the passed in bolt
312 void nebl_release(l_node *bolt_head);
313
314 // generate a lightning bolt, returns l_left (the "head") and l_right (the "tail")
315 int nebl_gen(vector *left, vector *right, float depth, float max_depth, int child, l_node **l_left, l_node **l_right);
316
317 // output top and bottom vectors
318 // fvec == forward vector (eye viewpoint basically. in world coords)
319 // pos == world coordinate of the point we're calculating "around"
320 // w == width of the diff between top and bottom around pos
321 void nebl_calc_facing_pts_smart( vector *top, vector *bot, vector *fvec, vector *pos, float w, float z_add );
322
323 // render a section of the bolt
324 void nebl_render_section(bolt_type *bi, l_section *a, l_section *b);
325
326 // generate a section
327 void nebl_generate_section(bolt_type *bi, float width, l_node *a, l_node *b, l_section *c, l_section *cap, int pinch_a, int pinch_b);
328
329 // render the bolt
330 void nebl_render(bolt_type *bi, l_node *whee, float width, l_section *prev = NULL);
331
332 // given a valid, complete bolt, jitter him based upon his noise
333 void nebl_jitter(l_bolt *b);
334
335 // return the index of a given bolt type by name
336 int nebl_get_bolt_index(char *name);
337
338 // return the index of a given storm type by name
339 int nebl_get_storm_index(char *name);
340
341
342 // ------------------------------------------------------------------------------------------------------
343 // NEBULA LIGHTNING FUNCTIONS
344 //
345
346 // initialize nebula lightning at game startup
347 void nebl_init()
348 {
349 #ifndef MAKE_FS1
350         char name[NAME_LENGTH+10] = "";
351         bolt_type bogus_lightning, *l;
352         storm_type bogus_storm, *s;
353         int temp;
354
355         try {
356                 // parse the lightning table
357                 read_file_text("lightning.tbl");
358                 reset_parse();
359
360                 Num_bolt_types = 0;
361                 Num_storm_types = 0;
362
363                 memset(Bolt_types, 0, sizeof(bolt_type) * MAX_BOLT_TYPES_INTERNAL);
364
365                 // parse the individual lightning bolt types
366                 required_string("#Bolts begin");
367                 while(!optional_string("#Bolts end")){
368                         // get a pointer
369                         if(Num_bolt_types >= MAX_BOLT_TYPES){
370                                 l = &bogus_lightning;
371                         } else {
372                                 l = &Bolt_types[Num_bolt_types];
373                         }
374
375                         // bolt title
376                         required_string("$Bolt:");
377                         stuff_string(l->name, F_NAME, NULL);
378
379                         // b_scale
380                         required_string("+b_scale:");
381                         stuff_float(&l->b_scale);
382
383                         // b_shrink
384                         required_string("+b_shrink:");
385                         stuff_float(&l->b_shrink);
386
387                         // b_poly_pct
388                         required_string("+b_poly_pct:");
389                         stuff_float(&l->b_poly_pct);
390
391                         // child rand
392                         required_string("+b_rand:");
393                         stuff_float(&l->b_rand);
394
395                         // z add
396                         required_string("+b_add:");
397                         stuff_float(&l->b_add);
398
399                         // # strikes
400                         required_string("+b_strikes:");
401                         stuff_int(&l->num_strikes);
402
403                         // lifetime
404                         required_string("+b_lifetime:");
405                         stuff_int(&l->lifetime);
406
407                         // noise
408                         required_string("+b_noise:");
409                         stuff_float(&l->noise);
410
411                         // emp effect
412                         required_string("+b_emp:");
413                         stuff_float(&l->emp_intensity);
414                         stuff_float(&l->emp_time);
415
416                         // texture
417                         required_string("+b_texture:");
418                         stuff_string(name, F_NAME, NULL);
419                         if((l != &bogus_lightning) && !Fred_running){
420                                 l->texture = bm_load(name);
421                         }
422
423                         // glow
424                         required_string("+b_glow:");
425                         stuff_string(name, F_NAME, NULL);
426                         if((l != &bogus_lightning) && !Fred_running){
427                                 l->glow = bm_load(name);
428                         }
429
430                         // brightness
431                         required_string("+b_bright:");
432                         stuff_float(&l->b_bright);
433
434                         // increment the # of bolt types
435                         if(l != &bogus_lightning){
436                                 Num_bolt_types++;
437                         }
438                 }
439
440                 // copy the first bolt to the debug bolt
441                 memcpy(&Bolt_types[DEBUG_BOLT], &Bolt_types[0], sizeof(bolt_type));
442
443                 // parse storm types
444                 required_string("#Storms begin");
445                 while(!optional_string("#Storms end")){
446                         // get a pointer
447                         if(Num_storm_types >= MAX_STORM_TYPES){
448                                 s = &bogus_storm;
449                         } else {
450                                 s = &Storm_types[Num_storm_types];
451                         }
452
453                         // bolt title
454                         required_string("$Storm:");
455                         stuff_string(s->name, F_NAME, NULL);
456
457                         // bolt types
458                         s->num_bolt_types = 0;
459                         while(optional_string("+bolt:")){
460                                 stuff_string(name, F_NAME, NULL);
461
462                                 // fill this guy in
463                                 if(s->num_bolt_types < MAX_BOLT_TYPES){
464                                         s->bolt_types[s->num_bolt_types] = (char)nebl_get_bolt_index(name);
465                                         SDL_assert(s->bolt_types[s->num_bolt_types] != -1);
466
467                                         s->num_bolt_types++;
468                                 }
469                                 // bogus
470                                 else {
471                                         required_string("+bolt_prec:");
472                                         stuff_int(&temp);
473                                 }
474                         }
475
476                         // flavor
477                         required_string("+flavor:");
478                         stuff_float(&s->flavor.xyz.x);
479                         stuff_float(&s->flavor.xyz.y);
480                         stuff_float(&s->flavor.xyz.z);
481
482                         // frequencies
483                         required_string("+random_freq:");
484                         stuff_int(&s->min);
485                         stuff_int(&s->max);
486
487                         // counts
488                         required_string("+random_count:");
489                         stuff_int(&s->min_count);
490                         stuff_int(&s->max_count);
491
492                         // increment the # of bolt types
493                         if(s != &bogus_storm){
494                                 Num_storm_types++;
495                         }
496                 }
497         } catch (parse_error_t rval) {
498                 Error(LOCATION, "Unable to parse lightning.tbl!  Code = %i.\n", (int)rval);
499         }
500 #endif
501 }
502
503 // initialize lightning before entering a level
504 void nebl_level_init()
505 {
506         int idx;        
507
508         // zero all lightning bolts
509         for(idx=0; idx<MAX_LIGHTNING_BOLTS; idx++){
510                 Nebl_bolts[idx].head = NULL;
511                 Nebl_bolts[idx].bolt_life = -1;
512                 Nebl_bolts[idx].used = 0;
513         }       
514         
515         // initialize node list
516         Num_lnodes = 0;
517         list_init( &Nebl_free_list );
518         list_init( &Nebl_used_list );
519
520         // Link all object slots into the free list
521         for (idx=0; idx<MAX_LIGHTNING_NODES; idx++)     {
522                 list_append(&Nebl_free_list, &Nebl_nodes[idx] );
523         }
524
525         // zero the random timestamp
526         Nebl_stamp = -1;                
527
528         // null the storm. let mission parsing set it up
529         Storm = NULL;
530 }
531
532 // render all lightning bolts
533 void nebl_render_all()
534 {
535         int idx;
536         l_bolt *b;
537         bolt_type *bi;
538
539         // no lightning in non-nebula missions
540         if(!(The_mission.flags & MISSION_FLAG_FULLNEB)){
541                 return;
542         }
543
544         // if we have no storm
545         if(Storm == NULL){
546                 return;
547         }
548
549         // traverse the list
550         for(idx=0; idx<MAX_LIGHTNING_BOLTS; idx++){
551                 b = &Nebl_bolts[idx];           
552
553                 // if this is being used
554                 if(b->used){
555                         SDL_assert(b->head != NULL);
556
557                         // bogus bolt
558                         if(b->head == NULL){
559                                 b->used = 0;
560                                 continue;
561                         }
562                         if((b->type < 0) || ((b->type >= Num_bolt_types) && (b->type != DEBUG_BOLT)) ){
563                                 Int3();
564                                 b->used = 0;
565                                 continue;
566                         }
567                         bi = &Bolt_types[(int)b->type];
568
569                         // if this guy is still on a delay
570                         if(b->delay != -1){
571                                 if(timestamp_elapsed(b->delay)){
572                                         b->delay = -1;
573                                 } else {
574                                         continue;
575                                 }
576                         }
577
578                         // if the timestamp on this guy has expired
579                         if((b->bolt_life < 0) || timestamp_elapsed(b->bolt_life)){
580                                 // if this is a multiple strike bolt, jitter it and reset
581                                 if(b->strikes_left-1 > 0){
582                                         b->bolt_life = timestamp(bi->lifetime / bi->num_strikes);
583                                         b->first_frame = 1;
584                                         b->strikes_left--;
585                                         nebl_jitter(b);
586
587                                         // by continuing here we skip rendering for one frame, which makes it look more like real lightning
588                                         continue;
589                                 }
590                                 // otherwise he's completely done, so release him
591                                 else {
592                                         // maybe free up node data
593                                         if(b->head != NULL){
594                                                 nebl_release(b->head);
595                                                 b->head = NULL;
596
597                                                 Nebl_bolt_count--;
598
599                                                 nprintf(("lightning", "Released bolt. %d used nodes!\n", Num_lnodes));
600                                         }
601
602                                         b->used = 0;
603                                 }
604                         }
605
606                         // pick some cool alpha values
607                         Nebl_alpha = frand();
608                         Nebl_glow_alpha = frand();
609
610                         // otherwise render him
611                         Nebl_flash_count = 0;
612                         Nebl_flash_x = 0.0f;
613                         Nebl_flash_y = 0.0f;
614                         Nebl_bang = 10000000.0f;
615                         nebl_render(bi, b->head, b->width);
616
617                         // if this is the first frame he has been rendered, determine if we need to make a flash and sound effect
618                         if(b->first_frame){
619                                 float flash = 0.0f;                             
620
621                                 b->first_frame = 0;
622
623                                 // if we rendered any points
624                                 if(Nebl_flash_count){
625                                         Nebl_flash_x /= (float)Nebl_flash_count;
626                                         Nebl_flash_y /= (float)Nebl_flash_count;
627
628                                         // quick distance from the center of the screen                 
629                                         float x = Nebl_flash_x - (gr_screen.max_w / 2.0f);
630                                         float y = Nebl_flash_y - (gr_screen.max_h / 2.0f);
631                                         float dist = fl_sqrt((x * x) + (y * y));                
632                                         if(dist / (gr_screen.max_w / 2.0f) < 1.0f){
633                                                 flash = 1.0f - (dist / (gr_screen.max_w / 2.0f));                                                                               
634
635                                                 // scale the flash by bolt type
636                                                 flash *= bi->b_bright;
637
638                                                 game_flash(flash, flash, flash);                                                                                
639                                         }                                       
640
641                                         // do some special stuff on the very first strike of the bolt
642                                         if(b->strikes_left == bi->num_strikes){                                 
643                                                 // play a sound                                         
644                                                 float bang;
645                                                 if(Nebl_bang < 40.0f){
646                                                         bang = 1.0f;
647                                                 } else if(Nebl_bang > 400.0f){
648                                                         bang = 0.0f;
649                                                 } else {
650                                                         bang = 1.0f - (Nebl_bang / 400.0f);
651                                                 }
652                                                 if(frand_range(0.0f, 1.0f) < 0.5f){
653                                                         snd_play(&Snds[SND_LIGHTNING_2], 0.0f, bang, SND_PRIORITY_DOUBLE_INSTANCE);
654                                                 } else {
655                                                         snd_play(&Snds[SND_LIGHTNING_1], 0.0f, bang, SND_PRIORITY_DOUBLE_INSTANCE);
656                                                 }                                               
657
658                                                 // apply em pulse
659                                                 if(bi->emp_intensity > 0.0f){
660                                                         emp_apply(&b->midpoint, 0.0f, vm_vec_dist(&b->start, &b->strike), bi->emp_intensity, bi->emp_time);
661                                                 }
662                                         }
663                                 }                               
664                         }
665                 }
666         }       
667 }
668
669 // process lightning (randomly generate bolts, etc, etc);
670 void nebl_process()
671 {               
672         int num_bolts, idx;
673
674         // non-nebula mission
675         if(!(The_mission.flags & MISSION_FLAG_FULLNEB)){
676                 return;
677         }               
678         
679         // non servers in multiplayer don't do this
680         if((Game_mode & GM_MULTIPLAYER) && !MULTIPLAYER_MASTER){
681                 return;
682         }
683
684         // if there's no chosen storm
685         if(Storm == NULL){
686                 return;
687         }
688
689         // don't process lightning bolts unless we're a few seconds in
690         if(f2fl(Missiontime) < 3.0f){
691                 return;
692         }
693                 
694         // random stamp
695         if(Nebl_stamp == -1){
696                 Nebl_stamp = timestamp((int)frand_range((float)Storm->min, (float)Storm->max));
697                 return;
698         }       
699
700         // maybe make a bolt
701         if(timestamp_elapsed(Nebl_stamp)){
702                 // determine how many bolts to spew
703                 num_bolts = (int)frand_range((float)Storm->min_count, (float)Storm->max_count);
704                 for(idx=0; idx<num_bolts; idx++){
705                         // hmm. for now just pick a random bolt type and run with it
706                         int s1, s2, s3;
707                         int e1, e2, e3;
708                         do {
709                                 s1 = (int)frand_range(0.0f, (float)Neb2_slices);
710                                 s2 = (int)frand_range(0.0f, (float)Neb2_slices);
711                                 s3 = (int)frand_range(0.0f, (float)Neb2_slices);
712
713                                 e1 = (int)frand_range(0.0f, (float)Neb2_slices);
714                                 e2 = (int)frand_range(0.0f, (float)Neb2_slices);
715                                 e3 = (int)frand_range(0.0f, (float)Neb2_slices);
716                         
717                                 // never choose the middle cube
718                                 if((s1 == 2) && (s2 == 2) && (s3 == 2)){
719                                         s1 = 4;
720                                         s2 = 0;
721                                 }
722                                 if((e1 == 2) && (e2 == 2) && (e3 == 2)){
723                                         e1 = 0;
724                                         e2 = 4;
725                                 }
726
727                         // sanity
728                         } while((s1 == e1) && (s2 == e2) && (s3 == e3));
729
730                         vector start = Neb2_cubes[s1][s2][s3].pt;
731                         vector strike = Neb2_cubes[e1][e2][e3].pt;
732
733                         // add some flavor to the bolt. mmmmmmmm, lightning
734                         if(!IS_VEC_NULL(&Storm->flavor)){                       
735                                 // start with your basic hot sauce. measure how much you have                   
736                                 vector your_basic_hot_sauce;
737                                 vm_vec_sub(&your_basic_hot_sauce, &strike, &start);
738                                 float how_much_hot_sauce = vm_vec_normalize(&your_basic_hot_sauce);
739
740                                 // now figure out how much of that good wing sauce to add
741                                 vector wing_sauce = Storm->flavor;
742                                 if(frand_range(0.0, 1.0f) < 0.5f){
743                                         vm_vec_scale(&wing_sauce, -1.0f);
744                                 }
745                                 float how_much_of_that_good_wing_sauce_to_add = vm_vec_normalize(&wing_sauce);
746
747                                 // mix the two together, taking care not to add too much
748                                 vector the_mixture;
749                                 if(how_much_of_that_good_wing_sauce_to_add > 1000.0f){
750                                         how_much_of_that_good_wing_sauce_to_add = 1000.0f;
751                                 }
752                                 vm_vec_interp_constant(&the_mixture, &your_basic_hot_sauce, &wing_sauce, how_much_of_that_good_wing_sauce_to_add / 1000.0f);
753
754                                 // take the final sauce and store it in the proper container
755                                 vm_vec_scale(&the_mixture, how_much_hot_sauce);
756
757                                 // make sure to put it on everything! whee!                     
758                                 vm_vec_add(&strike, &start, &the_mixture);
759                         }
760
761                         int type = (int)frand_range(0.0f, (float)(Storm->num_bolt_types-1));
762                         nebl_bolt(Storm->bolt_types[type], &start, &strike);
763                 }
764
765                 // reset the timestamp
766                 Nebl_stamp = timestamp((int)frand_range((float)Storm->min, (float)Storm->max));
767         }       
768 }
769
770 // create a lightning bolt
771 void nebl_bolt(int type, vector *start, vector *strike)
772 {
773         vector dir;
774         l_bolt *bolt;
775         l_node *tail;
776         int idx;
777         int found;              
778         bolt_type *bi;
779         float bolt_len;
780
781         if(!(The_mission.flags & MISSION_FLAG_FULLNEB)){
782                 return;
783         }
784
785         // find a free bolt
786         found = 0;
787         for(idx=0; idx<MAX_LIGHTNING_BOLTS; idx++){
788                 if(!Nebl_bolts[idx].used){
789                         found = 1;
790                         break;
791                 }
792         }
793         if(!found){
794                 // Int3();
795                 return;
796         }
797
798         if((type < 0) || ((type >= Num_bolt_types) && (type != DEBUG_BOLT)) ){
799                 return;
800         }
801         bi = &Bolt_types[type]; 
802
803         // get a pointer to the bolt
804         bolt = &Nebl_bolts[idx];        
805
806         // setup bolt into
807         bolt->start = *start;
808         bolt->strike = *strike;
809         bolt->strikes_left = bi->num_strikes;
810         bolt->delay = -1;
811         bolt->type = (char)type;
812         bolt->first_frame = 1;
813         bolt->bolt_life = timestamp(bi->lifetime / bi->num_strikes);            
814
815         Nebl_bolt_start = *start;
816         Nebl_bolt_strike = *strike;
817
818         // setup fire delay
819         if(bolt->delay != -1){
820                 bolt->delay = timestamp(bolt->delay);
821         }
822
823         // setup the rest of the important bolt data
824         if(vm_vec_same(&Nebl_bolt_start, &Nebl_bolt_strike)){
825                 Nebl_bolt_strike.xyz.z += 150.0f;
826         }
827         Nebl_bolt_len = vm_vec_dist(&Nebl_bolt_start, &Nebl_bolt_strike);       
828         vm_vec_sub(&dir, &Nebl_bolt_strike, &Nebl_bolt_start);
829
830         // setup midpoint
831         vm_vec_scale_add(&bolt->midpoint, &Nebl_bolt_start, &dir, 0.5f);
832
833         bolt_len = vm_vec_normalize(&dir);
834         vm_vector_2_matrix(&Nebl_bolt_dir, &dir, NULL, NULL);
835
836         // global type for generating the bolt
837         Nebl_type = bi;
838
839         // try and make the bolt
840         if(!nebl_gen(&Nebl_bolt_start, &Nebl_bolt_strike, 0, 4, 0, &bolt->head, &tail)){
841                 if(bolt->head != NULL){
842                         nebl_release(bolt->head);
843                 }
844
845                 return;
846         }
847
848         Nebl_bolt_count++;      
849         
850         // setup the rest of the data   
851         bolt->used = 1; 
852         bolt->width = bi->b_poly_pct * bolt_len;
853
854         // if i'm a multiplayer master, send a bolt packet
855         if(MULTIPLAYER_MASTER){
856                 send_lightning_packet(type, start, strike);
857         }
858 }
859
860 // get the current # of active lightning bolts
861 int nebl_get_active_bolts()
862 {
863         return Nebl_bolt_count;
864 }
865
866 // get the current # of active nodes
867 int nebl_get_active_nodes()
868 {
869         return Num_lnodes;
870 }
871
872 // set the storm (call from mission parse)
873 void nebl_set_storm(char *name)
874 {
875         int index = nebl_get_storm_index(name);
876
877         // sanity
878         Storm = NULL;
879         if((index >= 0) && (index < Num_storm_types)){
880                 Storm = &Storm_types[index];
881         }
882 }
883
884 // ------------------------------------------------------------------------------------------------------
885 // NEBULA LIGHTNING FORWARD DEFINITIONS
886 //
887
888 // "new" a lightning node
889 l_node *nebl_new()
890 {
891         l_node *lp;
892
893         // if we're out of nodes
894         if(Num_lnodes >= MAX_LIGHTNING_NODES){
895                 // Int3();
896                 nprintf(("lightning", "Out of lightning nodes!\n"));
897                 return NULL;
898         }
899
900         // get a new node off the freelist
901         lp = GET_FIRST(&Nebl_free_list);
902         SDL_assert( lp != &Nebl_free_list );            // shouldn't have the dummy element
903
904         // remove trailp from the free list
905         list_remove( &Nebl_free_list, lp );
906         
907         // insert trailp onto the end of used list
908         list_append( &Nebl_used_list, lp );
909
910         // increment counter
911         Num_lnodes++;
912
913         lp->links[0] = NULL;
914         lp->links[1] = NULL;
915         lp->links[2] = NULL;    
916
917         // return the pointer
918         return lp;
919 }
920
921 // "delete" a lightning node
922 void nebl_delete(l_node *lp)
923 {
924         // remove objp from the used list
925         list_remove( &Nebl_used_list, lp );
926
927         // add objp to the end of the free
928         list_append( &Nebl_free_list, lp );
929
930         // decrement counter
931         Num_lnodes--;
932 }
933
934 // free a lightning bolt
935 void nebl_release(l_node *whee)
936 {
937         // if we're invalid
938         if(whee == NULL){
939                 return;
940         }
941
942         // release all of our children
943         if(whee->links[LINK_RIGHT] != NULL){
944                 nebl_release(whee->links[LINK_RIGHT]);
945         }       
946         if(whee->links[LINK_CHILD] != NULL){
947                 nebl_release(whee->links[LINK_CHILD]);
948         }       
949
950         // delete this node
951         nebl_delete(whee);
952 }
953
954 int nebl_gen(vector *left, vector *right, float depth, float max_depth, int child, l_node **l_left, l_node **l_right)
955 {
956         l_node *child_node = NULL;
957         float d = vm_vec_dist_quick( left, right );             
958
959         // if we've reached the critical point
960         if ( d < 0.30f || (depth > max_depth) ){
961                 // generate ne items
962                 l_node *new_left = nebl_new();
963                 if(new_left == NULL){
964                         return 0;
965                 }               
966                 new_left->links[0] = NULL; new_left->links[1] = NULL; new_left->links[2] = NULL;
967                 new_left->pos = vmd_zero_vector;
968                 l_node *new_right = nebl_new();
969                 if(new_right == NULL){
970                         nebl_delete(new_left);                  
971                         return 0;
972                 }               
973                 new_right->links[0] = NULL; new_right->links[1] = NULL; new_right->links[2] = NULL;
974                 new_right->pos = vmd_zero_vector;
975
976                 // left side
977                 new_left->pos = *left;          
978                 new_left->links[LINK_RIGHT] = new_right;                
979                 *l_left = new_left;
980                 
981                 // right side
982                 new_right->pos = *right;
983                 new_right->links[LINK_LEFT] = new_left;
984                 *l_right = new_right;
985
986                 // done
987                 return 1;
988         }  
989
990         // divide in half
991         vector tmp;
992         vm_vec_avg( &tmp, left, right );
993
994         // sometimes generate children
995         if(!child && (frand() <= Nebl_type->b_rand)){
996                 // get a point on the plane of the strike
997                 vector tmp2;
998                 vm_vec_random_in_circle(&tmp2, &Nebl_bolt_strike, &Nebl_bolt_dir, Nebl_bolt_len * Nebl_type->b_scale, 0);
999
1000                 // maybe move away from the plane
1001                 vector dir;
1002                 vm_vec_sub(&dir, &tmp2, &tmp);          
1003                 vm_vec_scale_add(&tmp2, &tmp, &dir, Nebl_type->b_shrink);
1004
1005                 // child
1006                 l_node *argh;           
1007                 if(!nebl_gen(&tmp, &tmp2, 0, 2, 1, &child_node, &argh)){
1008                         if(child_node != NULL){
1009                                 nebl_release(child_node);
1010                         }
1011                         return 0;
1012                 }
1013         }
1014         
1015         float scaler = 0.30f;
1016         tmp.xyz.x += (frand()-0.5f)*d*scaler;
1017         tmp.xyz.y += (frand()-0.5f)*d*scaler;
1018         tmp.xyz.z += (frand()-0.5f)*d*scaler;
1019
1020         // generate left half
1021         l_node *ll = NULL;
1022         l_node *lr = NULL;
1023         if(!nebl_gen( left, &tmp, depth+1, max_depth, child, &ll, &lr )){
1024                 if(child_node != NULL){
1025                         nebl_release(child_node);
1026                 }
1027                 if(ll != NULL){
1028                         nebl_release(ll);
1029                 }
1030                 return 0;
1031         }
1032
1033         // generate right half
1034         l_node *rl = NULL;
1035         l_node *rr = NULL;
1036         if(!nebl_gen( &tmp, right, depth+1, max_depth, child, &rl, &rr )){
1037                 if(child_node != NULL){
1038                         nebl_release(child_node);
1039                 }
1040                 if(ll != NULL){
1041                         nebl_release(ll);
1042                 }
1043                 if(rl != NULL){
1044                         nebl_release(rl);
1045                 }
1046                 return 0;
1047         }
1048         
1049         // splice the two together
1050         lr->links[LINK_RIGHT] = rl->links[LINK_RIGHT];
1051         lr->links[LINK_RIGHT]->links[LINK_LEFT] = lr;
1052         nebl_delete(rl);
1053
1054         // if we generated a child, stick him on
1055         if(child_node != NULL){
1056                 lr->links[LINK_CHILD] = child_node;
1057         }
1058
1059         // return these
1060         *l_left = ll;
1061         *l_right = rr;
1062
1063         return 1;
1064 }
1065
1066
1067 // output top and bottom vectors
1068 // fvec == forward vector (eye viewpoint basically. in world coords)
1069 // pos == world coordinate of the point we're calculating "around"
1070 // w == width of the diff between top and bottom around pos
1071 void nebl_calc_facing_pts_smart( vector *top, vector *bot, vector *fvec, vector *pos, float w, float z_add )
1072 {
1073         vector uvec, rvec;
1074         vector temp;    
1075
1076         temp = *pos;
1077
1078         vm_vec_sub( &rvec, &Eye_position, &temp );
1079         vm_vec_normalize( &rvec );      
1080
1081         vm_vec_crossprod(&uvec,fvec,&rvec);
1082         vm_vec_normalize(&uvec);
1083
1084         vm_vec_scale_add( top, &temp, &uvec, w/2.0f );
1085         vm_vec_scale_add( bot, &temp, &uvec, -w/2.0f ); 
1086         
1087         vm_vec_scale_add2( top, &rvec, z_add );
1088         vm_vec_scale_add2( bot, &rvec, z_add );
1089 }
1090
1091 // render a section of the bolt
1092 void nebl_render_section(bolt_type *bi, l_section *a, l_section *b)
1093 {               
1094         vertex v[4];
1095         vertex *verts[4] = {&v[0], &v[1], &v[2], &v[3]};
1096         int idx;
1097
1098         // Sets mode.  Returns previous mode.
1099         gr_zbuffer_set(GR_ZBUFF_FULL);  
1100
1101         // draw some stuff
1102         for(idx=0; idx<2; idx++){               
1103                 v[0] = a->vex[idx];             
1104                 v[0].u = 0.0f; v[0].v = 0.0f;
1105
1106                 v[1] = a->vex[idx+1];           
1107                 v[1].u = 1.0f; v[1].v = 0.0f;
1108
1109                 v[2] = b->vex[idx+1];           
1110                 v[2].u = 1.0f; v[2].v = 1.0f;
1111
1112                 v[3] = b->vex[idx];             
1113                 v[3].u = 0.0f; v[3].v = 1.0f;
1114
1115                 // draw
1116                 gr_set_bitmap(bi->texture, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, Nebl_alpha, -1, -1);
1117                 g3_draw_poly(4, verts, TMAP_FLAG_TEXTURED | TMAP_FLAG_CORRECT);         
1118         }
1119
1120         // draw
1121         v[0] = a->vex[2];               
1122         v[0].u = 0.0f; v[0].v = 0.0f;
1123
1124         v[1] = a->vex[0];               
1125         v[1].u = 1.0f; v[1].v = 0.0f;
1126
1127         v[2] = b->vex[0];               
1128         v[2].u = 1.0f; v[2].v = 1.0f;
1129
1130         v[3] = b->vex[2];               
1131         v[3].u = 0.0f; v[3].v = 1.0f;
1132
1133         gr_set_bitmap(bi->texture, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, Nebl_alpha, -1, -1);
1134         g3_draw_poly(4, verts, TMAP_FLAG_TEXTURED | TMAP_FLAG_CORRECT); 
1135
1136         // draw the glow beam   
1137         verts[0] = &a->glow_vex[0];
1138         verts[0]->v = 0.0f; verts[0]->u = 0.0f;
1139
1140         verts[1] = &a->glow_vex[1];
1141         verts[1]->v = 1.0f; verts[1]->u = 0.0f;
1142
1143         verts[2] = &b->glow_vex[1];
1144         verts[2]->v = 1.0f; verts[2]->u = 1.0f;
1145
1146         verts[3] = &b->glow_vex[0];
1147         verts[3]->v = 0.0f; verts[3]->u = 1.0f;
1148
1149         gr_set_bitmap(bi->glow, GR_ALPHABLEND_FILTER, GR_BITBLT_MODE_NORMAL, Nebl_glow_alpha, -1, -1);
1150         g3_draw_poly(4, verts, TMAP_FLAG_TEXTURED | TMAP_FLAG_CORRECT); 
1151 }
1152
1153 // generate a section
1154 void nebl_generate_section(bolt_type *bi, float width, l_node *a, l_node *b, l_section *c, l_section *cap, int pinch_a, int pinch_b)
1155 {
1156         vector dir;
1157         vector dir_normal;
1158         matrix m;
1159         int idx;        
1160         vector temp, pt;
1161         vector glow_a, glow_b;
1162
1163         // direction matrix
1164         vm_vec_sub(&dir, &a->pos, &b->pos);
1165         vm_vec_copy_normalize(&dir_normal, &dir);
1166         vm_vector_2_matrix(&m, &dir_normal, NULL, NULL);
1167
1168         // distance to player
1169         float bang_dist = vm_vec_dist_quick(&Eye_position, &a->pos);
1170         if(bang_dist < Nebl_bang){
1171                 Nebl_bang = bang_dist;
1172         }
1173
1174         // rotate the basic section into world  
1175         for(idx=0; idx<3; idx++){
1176                 // rotate to world              
1177                 if(pinch_a){                    
1178                         vm_vec_rotate(&pt, &Nebl_ring_pinched[idx], &m);
1179                 } else {
1180                         vm_vec_copy_scale(&temp, &Nebl_ring[idx], width);
1181                         vm_vec_rotate(&pt, &temp, &m);
1182                 }
1183                 vm_vec_add2(&pt, &a->pos);
1184                         
1185                 // transform
1186                 g3_rotate_vertex(&c->vex[idx], &pt);
1187                 g3_project_vertex(&c->vex[idx]);                
1188
1189                 // if first frame, keep track of the average screen pos
1190                 if((c->vex[idx].sx >= 0) && (c->vex[idx].sx < gr_screen.max_w) && (c->vex[idx].sy >= 0) && (c->vex[idx].sy < gr_screen.max_h)){
1191                         Nebl_flash_x += c->vex[idx].sx;
1192                         Nebl_flash_y += c->vex[idx].sy;
1193                         Nebl_flash_count++;
1194                 }
1195         }
1196         // calculate the glow points            
1197         nebl_calc_facing_pts_smart(&glow_a, &glow_b, &dir_normal, &a->pos, pinch_a ? 0.5f : width * 6.0f, Nebl_type->b_add);
1198         g3_rotate_vertex(&c->glow_vex[0], &glow_a);
1199         g3_project_vertex(&c->glow_vex[0]);
1200         g3_rotate_vertex(&c->glow_vex[1], &glow_b);
1201         g3_project_vertex(&c->glow_vex[1]);     
1202
1203         // maybe do a cap
1204         if(cap != NULL){                
1205                 // rotate the basic section into world
1206                 for(idx=0; idx<3; idx++){
1207                         // rotate to world              
1208                         if(pinch_b){
1209                                 vm_vec_rotate(&pt, &Nebl_ring_pinched[idx], &m);
1210                         } else {
1211                                 vm_vec_copy_scale(&temp, &Nebl_ring[idx], width);
1212                                 vm_vec_rotate(&pt, &temp, &m);          
1213                         }
1214                         vm_vec_add2(&pt, &b->pos);
1215                         
1216                         // transform
1217                         g3_rotate_vertex(&cap->vex[idx], &pt);
1218                         g3_project_vertex(&cap->vex[idx]);                      
1219
1220                         // if first frame, keep track of the average screen pos                 
1221                         if( (c->vex[idx].sx >= 0) && (c->vex[idx].sx < gr_screen.max_w) && (c->vex[idx].sy >= 0) && (c->vex[idx].sy < gr_screen.max_h)){
1222                                 Nebl_flash_x += c->vex[idx].sx;
1223                                 Nebl_flash_y += c->vex[idx].sy;
1224                                 Nebl_flash_count++;
1225                         }
1226                 }
1227                 
1228                 // calculate the glow points            
1229                 nebl_calc_facing_pts_smart(&glow_a, &glow_b, &dir_normal, &b->pos, pinch_b ? 0.5f : width * 6.0f, bi->b_add);
1230                 g3_rotate_vertex(&cap->glow_vex[0], &glow_a);
1231                 g3_project_vertex(&cap->glow_vex[0]);
1232                 g3_rotate_vertex(&cap->glow_vex[1], &glow_b);
1233                 g3_project_vertex(&cap->glow_vex[1]);
1234         }
1235 }
1236
1237 // render the bolt
1238 void nebl_render(bolt_type *bi, l_node *whee, float width, l_section *prev)
1239 {               
1240         l_section start;
1241         l_section end;
1242         l_section child_start;
1243
1244         // bad
1245         if(whee == NULL){
1246                 return;
1247         }
1248
1249         // if prev is NULL, we're just starting so we need our start point
1250         if(prev == NULL){
1251                 SDL_assert(whee->links[LINK_RIGHT] != NULL);
1252                 nebl_generate_section(bi, width, whee, whee->links[LINK_RIGHT], &start, NULL, 1, 0);
1253         } else {
1254                 start = *prev;
1255         }
1256         
1257         // if we have a child section   
1258         if(whee->links[LINK_CHILD]){            
1259                 // generate section
1260                 nebl_generate_section(bi, width * 0.5f, whee, whee->links[LINK_CHILD], &child_start, &end, 0, whee->links[LINK_CHILD]->links[LINK_RIGHT] == NULL ? 1 : 0);
1261
1262                 // render
1263                 nebl_render_section(bi, &child_start, &end);                    
1264
1265                 // maybe continue
1266                 if(whee->links[LINK_CHILD]->links[LINK_RIGHT] != NULL){
1267                         nebl_render(bi, whee->links[LINK_CHILD], width * 0.5f, &end);
1268                 }
1269         }       
1270                 
1271         // if the next section is an end section
1272         if(whee->links[LINK_RIGHT]->links[LINK_RIGHT] == NULL){
1273                 l_section temp;
1274
1275                 // generate section
1276                 nebl_generate_section(bi, width, whee, whee->links[LINK_RIGHT], &temp, &end, 0, 1);
1277
1278                 // render the section
1279                 nebl_render_section(bi, &start, &end);          
1280         }
1281         // a middle section
1282         else if(whee->links[LINK_RIGHT]->links[LINK_RIGHT] != NULL){
1283                 // generate section
1284                 nebl_generate_section(bi, width, whee->links[LINK_RIGHT], whee->links[LINK_RIGHT]->links[LINK_RIGHT], &end, NULL, 0, 0);
1285
1286                 // render the section
1287                 nebl_render_section(bi, &start, &end);
1288
1289                 // recurse through him
1290                 nebl_render(bi, whee->links[LINK_RIGHT], width, &end);
1291         }
1292 }
1293
1294 // given a valid, complete bolt, jitter him based upon his noise
1295 void nebl_jitter(l_bolt *b)
1296 {
1297         matrix m;
1298         vector temp;
1299         float length;
1300         l_node *moveup;
1301         bolt_type *bi = NULL;
1302
1303         // sanity
1304         if(b == NULL){
1305                 return;
1306         }
1307         if((b->type < 0) || ((b->type >= Num_bolt_types) && (b->type != DEBUG_BOLT)) ){
1308                 return;         
1309         }
1310         bi = &Bolt_types[(int)b->type];
1311
1312         // get the bolt direction
1313         vm_vec_sub(&temp, &b->strike, &b->start);
1314         length = vm_vec_normalize_quick(&temp);
1315         vm_vector_2_matrix(&m, &temp, NULL, NULL);
1316
1317         // jitter all nodes on the main trunk
1318         moveup = b->head;
1319         while(moveup != NULL){
1320                 temp = moveup->pos;
1321                 vm_vec_random_in_circle(&moveup->pos, &temp, &m, frand_range(0.0f, length * bi->noise), 0);
1322
1323                 // just on the main trunk
1324                 moveup = moveup->links[LINK_RIGHT];
1325         }       
1326 }
1327
1328 // return the index of a given bolt type by name
1329 int nebl_get_bolt_index(char *name)
1330 {
1331         int idx;
1332
1333         for(idx=0; idx<Num_bolt_types; idx++){
1334                 if(!strcmp(name, Bolt_types[idx].name)){
1335                         return idx;
1336                 }
1337         }
1338
1339         return -1;
1340 }
1341
1342 // return the index of a given storm type by name
1343 int nebl_get_storm_index(char *name)
1344 {
1345         int idx;
1346
1347         for(idx=0; idx<Num_bolt_types; idx++){
1348                 if(!strcmp(name, Storm_types[idx].name)){
1349                         return idx;
1350                 }
1351         }
1352
1353         return -1;
1354 }
1355