1 /****************************************************************/
2 /* code copyright 1995-1996 Andrew Johnson - ALL RIGHTS RESERVED*/
3 /* ajohnson@eecs.uic.edu */
4 /* */
5 /* Electronic Visualization Lab (M/C 154) */
6 /* University of Illinois at Chicago */
7 /* 851 South Morgan St. Room 1120 SEO */
8 /* Chicago, IL 60607-7053 */
9 /* */
10 /* (312) 996-3002 (312) 413-7585 FAX */
11 /***********************************************************************/
12 /* graphics.c v 1.3 */
13 /* high level graphics routines for battalion */
14 /***********************************************************************/
15
16 #include "battalion.h"
17
18 /*************/
19 /* colours */
20 /*************/
21
22 float colorolive[4] = {0, 0.34, 0.0, 0.0};
23 float planeGreen[4] = {0.21, 0.49, 0.0, 0.0};
24 float planeGreen2[4] = {0.25, 0.60, 0.0, 0.0};
25 float planeGreen3[4] = {0.10, 0.25, 0.0, 0.0};
26 float colorgreen[4] = {0.0, 0.9, 0.1, 0.0};
27
28 float colorblack[4] = {0.2, 0.2, 0.2, 0.95};
29
30 float colorred[4] = {0.98, 0.17, 0.0, 0.7};
31 float colorred_50[4] = {0.49, 0.085, 0.0, 0.7}; /* colorred * 0.5 */
32 float colorred2[4] = {1.0, 0.0, 0.0, 0.0};
33 float colorred3[4] = {0.5, 0.08, 0.0, 0.7};
34
35 float colormaserblue[4] = {0.3, 0.7, 1.0, 0.75};
36 float colormaserblue2[4] = {0.0, 1.0, 1.0, 0.75};
37
38 float colorwhite[4] = {1.0, 1.0, 1.0, 0.2};
39 float colorwhite2[4] = {1.0, 1.0, 1.0, 0.4}; /* dying vapour */
40
41 float colorsnow[4] = {0.8, 0.8, 0.9, 0.4};
42 float colorsnow2[4] = {0.7, 0.7, 0.8, 0.4};
43
44 float colorgrey1[4] = {0.5, 0.5, 0.5, 0.8};
45 float colorgrey1_50[4] = {0.25, 0.25, 0.25, 0.4}; /* colorgrey * 0.5 */
46 float colorgrey2[4] = {0.7, 0.7, 0.7, 0.0};
47 float colorgrey3[4] = {0.6, 0.6, 0.6, 0.0};
48 float colorgrey3_50[4] = {0.3, 0.3, 0.3, 0.0}; /* colorgrey3 * 0.5 */
49 float colorgrey4[4] = {0.55, 0.55, 0.55, 0.0};
50
51 float colorbrown[4] = {0.75, 0.33, 0.0, 0.8};
52 float colorbeige[4] = {0.75, 0.75, 0.5, 0.7};
53
54 float colorblue[4] = {0.0, 0.0, 1.0, 0.6};
55 float colorblue2[4] = {0.0, 0.0, 0.7, 0.0};
56 float colorwater[4] = {0.0, 0.25, 0.5, 0.0};
57
58 float colorsnowvapour[4] = {0.3, 0.3, 1.0, 0.4};
59
60 float coloryellow[4] = {1.0, 1.0, 0.0, 0.0};
61 float colormaseryellow[4] = {1.0, 0.7, 0.0, 0.0};
62 float colororange[4] = {1.0, 0.7, 0.0, 0.0};
63
64 float healthGreen[4] = {0.21, 0.49, 0.0, 0.0};
65
66 float treeColor[4] = {0.03, 0.34, 0.025, 0};
67 float treeColor2[4] = {0.05, 0.4, 0.025, 0};
68
69 /*************/
70 /* objects */
71 /*************/
72
73 GLuint
74 plaintank, slagtank, masertank, slagmasertank,
75 launchertank, slaglaunchertank, helo, slagHelo,
76 bigRotor, smallRotor, propeller,
77
78 airplaneBody, fighterBody,
79
80 monsterleg, monsterHead,
81 monsterTail, monsterBody,
82 monsterSimpleHead, monsterSimpleTail,
83 flutterHead,
84
85 techsBody, techsHead, techsShadow,
86 techsSimpleBody, techsSimpleHead,
87
88 watershellObj, heroshellObj,
89
90 tankShadow, planeShadow, fighterShadow,
91
92 flutterShadow, flutterBody, flutterXMas,
93 flutterWing1, flutterWing2,
94
95 planeDotsObj, planeDotsObjD0,
96
97 shellObj, shell2Obj,
98
99 titleObj, titleObjOO, titleObjOOO,
100 lowDPlane, highDPlane, bigPlane,
101
102 roundTreeShadow,
103
104 boom1Obj, boom2Obj, boom3Obj, boom4Obj, boom5Obj,
105 boom6Obj, boom7Obj, boom8Obj, boom9Obj, boom10Obj,
106
107 boom1ObjD0, boom2ObjD0, boom3ObjD0, boom4ObjD0, boom5ObjD0,
108 boom6ObjD0, boom7ObjD0, boom8ObjD0, boom9ObjD0, boom10ObjD0,
109
110 strip1Obj, strip2Obj, strip3Obj,
111 strip1ObjD0, strip2ObjD0, strip3ObjD0,
112
113 powerTower,
114 genericWindows,
115
116 building1Obj, building2Obj, building7Obj, building9Obj, building9ObjOO,
117 building10Obj, building12Obj, building14Obj, building19Obj,
118 building20Obj, building21Obj, building31Obj, building32Obj,
119 building5Obj,
120 building1ObjD0, building2ObjD0, building5ObjD0, building12ObjD0,
121 building19ObjD0, building20ObjD0, building21ObjD0;
122
123 /***************************/
124 /* texture mapping stuff */
125 /***************************/
126
127 GLuint leftScreen, rightScreen;
128 GLuint treeWood, roadtex, officeLogo;
129
130 char picleft[32400], picright[32400]; /* 180 x 180 tmap arrays*/
131 /* only 128 x 128 in use now */
132 char officeLogoData[32400];
133
134 char treeWoodData[5000];
135 char roadtexData[5000];
136
137
138 struct road roadsOnPlane[MAXROADSONPLANE];
139
140 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
141
doTexStuff(char * dataPath,char * fileName,int width,int height,char * TheArray,GLuint * theObj,int interpolation,int repeat)142 void doTexStuff(char * dataPath, char * fileName, int width, int height,
143 char * TheArray, GLuint * theObj, int interpolation, int repeat)
144 {
145 register int x, y;
146 char fullPath[MAXPATH];
147 int arrayLoc;
148 FILE * imageFile;
149
150 strcpy(fullPath, dataPath);
151 strcat(fullPath, fileName);
152 imageFile = fopen(fullPath, "r");
153
154 if (imageFile == NULL)
155 showError("Cannot find texture file in data directory");
156 else
157 {
158 for (y = 0; y < height; y++)
159 for (x = 0; x < width; x++)
160 {
161 arrayLoc = (height-1-y) * width + (width-1-x);
162 TheArray[arrayLoc] = (char) fgetc(imageFile);
163 }
164
165 *theObj = glGenLists(1);
166 glNewList(*theObj, GL_COMPILE);
167
168 glTexImage2D(GL_TEXTURE_2D, 0, 1, width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, (const GLvoid *) TheArray);
169
170 if (repeat)
171 {
172 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
173 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
174 }
175 else
176 {
177 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
178 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
179 }
180
181 if (interpolation)
182 {
183 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
184 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
185 }
186 else
187 {
188 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
189 glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
190 }
191
192 glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
193
194 glEndList();
195
196 fclose(imageFile);
197 }
198 }
199
200 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
201 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
202 /* create the objects to be used in the game */
203 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
204
makeObjects(char * dataPath)205 void makeObjects(char * dataPath)
206 {
207 GLfloat lineWidthNow;
208
209 /********************/
210 /* load in textures */
211 /********************/
212
213 doTexStuff(dataPath, "TEXTURES/screenleft.tex", 128, 128, picleft, &leftScreen, 0, 0);
214 doTexStuff(dataPath, "TEXTURES/screenright.tex", 128, 128, picright, &rightScreen, 0, 0);
215
216 doTexStuff(dataPath, "TEXTURES/treewood.tex", 64, 64, treeWoodData, &treeWood, 1, 0);
217 doTexStuff(dataPath, "TEXTURES/road.tex", 64, 64, roadtexData, &roadtex, 1, 0);
218
219 /* doTexStuff(dataPath,"TEXTURES/logo.tex", 128, 128, officeLogoData, &officeLogo, 0, 0);
220 */
221
222 /********************/
223 /* make the objects */
224 /********************/
225
226 plaintank = makeTank();
227 slagtank = makeSlagTank();
228 masertank = makeMaserTank();
229 slagmasertank = makeSlagMaserTank();
230 launchertank = makeLauncherTank();
231 slaglaunchertank = makeSlagLauncherTank();
232 helo = makeHelo();
233 slagHelo = makeSlagHelo();
234 bigRotor = makeBigRotor();
235 smallRotor = makeSmallRotor();
236 propeller = makePropeller();
237
238 monsterleg = makeLeg();
239 monsterHead = makeHead();
240 monsterSimpleHead = makeSimpleHead();
241 monsterSimpleTail = makeSimpleTail();
242 monsterTail = makeTail();
243 monsterBody = makeBody();
244 flutterHead = makeFlutterHead();
245 techsBody = makeTechsBody();
246 techsHead = makeTechsHead();
247 techsSimpleBody = makeTechsSimpleBody();
248 techsSimpleHead = makeTechsSimpleHead();
249 techsShadow = makeTechsShadow();
250
251 tankShadow = makeTankShadow();
252 planeShadow = makePlaneShadow();
253 fighterShadow = makeFighterShadow();
254
255 shellObj = glGenLists(1);
256 shell2Obj = makeshell2();
257 heroshellObj = makeHeroShell();
258 watershellObj = makeWaterShell();
259
260 titleObj = makeTitles(1);
261 titleObjOO = makeTitles(0);
262 titleObjOOO = makeTitles(-1);
263
264 planeDotsObj = makePlaneDots(1);
265 planeDotsObjD0 = makePlaneDots(0);
266
267 powerTower = makePowerTower();
268 genericWindows = makeGenericWindows();
269
270 strip1Obj = makeStrip1(1);
271 strip2Obj = makeStrip2(1);
272 strip3Obj = makeStrip3(1);
273 strip1ObjD0 = makeStrip1(0);
274 strip2ObjD0 = makeStrip2(0);
275 strip3ObjD0 = makeStrip3(0);
276
277 building1Obj = makebuilding1(1);
278 building1ObjD0 = makebuilding1(0);
279 building2Obj = makebuilding2(1);
280 building2ObjD0 = makebuilding2(0);
281 building5Obj = makebuilding5(1);
282 building5ObjD0 = makebuilding5(0);
283 building7Obj = makebuilding7();
284 building9Obj = makebuilding9(0);
285 building9ObjOO = makebuilding9(1);
286
287 glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
288 building10Obj = makebuilding10();
289 glLineWidth(lineWidthNow);
290
291 building12Obj = makebuilding12(1);
292 building12ObjD0 = makebuilding12(0);
293 building14Obj = makebuilding14();
294 building19Obj = makebuilding19(1);
295 building19ObjD0 = makebuilding19(0);
296 building20Obj = makebuilding20(1);
297 building20ObjD0 = makebuilding20(0);
298 building21Obj = makebuilding21(1);
299 building21ObjD0 = makebuilding21(0);
300 building31Obj = makebuilding31();
301 building32Obj = makebuilding32();
302
303 lowDPlane = makeLowDPlane();
304 highDPlane = makeHighDPlane();
305 bigPlane = makeBigPlane();
306
307 airplaneBody = makeAirplaneBody();
308 fighterBody = makeFighterBody();
309 flutterShadow = makeFlutterShadow();
310 flutterXMas = makeFlutterXMas();
311 flutterBody = makeFlutterBody();
312 flutterWing1 = makeFlutterWing1();
313 flutterWing2 = makeFlutterWing2();
314
315 roundTreeShadow = makeRoundTreeShadow();
316
317 makeBooms();
318
319 initFonts();
320 }
321
322 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
323 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
324 /* draw a rectangular shadow on the ground */
325 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
326
shadow(float x,float z,float wx,float wz)327 void shadow (float x, float z, float wx, float wz)
328 {
329 float v[3];
330 v[1] = SHADOWS;
331
332 glBegin(GL_QUADS);
333 v[0] = x+wx; v[2] = z+wz;
334 glVertex3fv(v);
335
336 v[2] = z-wz;
337 glVertex3fv(v);
338
339 v[0] = x-wx;
340 glVertex3fv(v);
341
342 v[2] = z+wz;
343 glVertex3fv(v);
344 glEnd();
345 }
346
347 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
348 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
349 /* draw a hunter */
350 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
351
makeCHH(int dam)352 void makeCHH(int dam)
353 {
354 if (dam > 16)
355 makercube(-0.15, -0.05, -0.2, 0.07, 0.07, 0.1, colorblue);
356 else
357 makeitd(0, colorblue, -0.15, -0.05, -0.2, 0.07, 0.07, 0.1);
358
359 if (dam > 12)
360 makercube(0.15, -0.05, -0.2, 0.07, 0.07, .1, colorblue);
361 else
362 makeitd(1, colorblue, 0.15, -0.05, -0.2, 0.07, 0.07, .1);
363
364 if (dam > 8)
365 makercube(0.0, -0.05, 0.1, 0.2, 0.05, 0.1, colorgrey1);
366 else
367 makeitd(0, colorgrey1, 0.0, -0.05, 0.1, 0.2, 0.05, 0.1);
368
369 if (dam > 4)
370 makercube(0.0, -0.05, -0.2, 0.1, 0.05, 0.2, colorgrey1);
371 else
372 makeitd(1, colorgrey1, 0.0, -0.05, -0.2, 0.1, 0.05, 0.2);
373
374 if (dam > 0)
375 makeitPyr(3, colorgrey2, 0.0, +0.05, 0.1, 0.2, 0.05, 0.1);
376 else
377 makeitPyr(3, colorgrey1, 0.0, +0.05, 0.1, 0.2, 0.05, 0.1);
378
379 makercube( 0.05, -0.1, 0.15, 0.02, 0.01, 0.02, colorwhite);
380 makercube(-0.05, -0.1, 0.15, 0.02, 0.01, 0.02, colorwhite);
381 makercube( 0.05, -0.1, -0.35, 0.02, 0.01, 0.02, colorwhite);
382 makercube(-0.05, -0.1, -0.35, 0.02, 0.01, 0.02, colorwhite);
383 }
384
385
386 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
387 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
388 /* draw a helicopter */
389 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
390
drawHelo(float percent,int slag)391 void drawHelo(float percent, int slag)
392 {
393 GLint shadeNow;
394
395 glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
396
397 /*************/
398 /* draw body */
399 /*************/
400
401 glShadeModel(GL_FLAT);
402
403 if (!slag)
404 glCallList(helo);
405 else
406 glCallList(slagHelo);
407
408 glShadeModel(shadeNow);
409
410 /***************/
411 /* draw rotors */
412 /***************/
413
414 glPushMatrix();
415 glRotatef(-percent, 0, 1, 0);
416 glCallList(bigRotor);
417 glPopMatrix();
418
419 /********************/
420 /* draw tail rotor */
421 /********************/
422
423 glPushMatrix();
424 glTranslatef(0.04, 0, 0.375);
425 glRotatef( -percent, 1, 0, 0);
426 glCallList(smallRotor);
427 glPopMatrix();
428 }
429
430
431 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
432 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
433 /* draw a bomber */
434 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
435
drawAirplane(int counter)436 void drawAirplane(int counter)
437 {
438 float percent;
439
440 percent = counter * 10.0;
441
442 glCallList(airplaneBody);
443
444 /*******************/
445 /* draw propellers */
446 /*******************/
447
448 glPushMatrix();
449 glTranslatef(-0.09, -0.014, -0.07);
450 glRotatef( -percent, 0, 0, 1);
451 glCallList(propeller);
452 glPopMatrix();
453
454 glPushMatrix();
455 glTranslatef(+0.09, -0.014, -0.07);
456 glRotatef( -percent, 0, 0, 1);
457 glCallList(propeller);
458 glPopMatrix();
459
460 }
461
462 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
463 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
464 /* draw a fighter */
465 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
466
drawFighter(void)467 void drawFighter(void)
468 {
469 glCallList(fighterBody);
470 }
471
472
473
474 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
475 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
476 /* draw Googelon */
477 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
478
drawMonster(struct monsterInfo monster,int counter,int itsChristmas,int detail)479 void drawMonster(struct monsterInfo monster, int counter,
480 int itsChristmas, int detail)
481 {
482 float v[4];
483
484 /*********************/
485 /* googelon's shadow */
486 /*********************/
487
488 static float googShadow1[3] = {0.1, SHADOWS, -0.5};
489 static float googShadow2[3] = {0.0, SHADOWS, -0.7};
490 static float googShadow3[3] = {-0.1, SHADOWS, -0.5};
491
492 glPushMatrix();
493
494 glRotatef(.1*monster.headHorzRotate, 0, 1, 0);
495
496 /********/
497 /* head */
498 /********/
499
500 glPushMatrix();
501 glRotatef(.1*monster.headVertRotate, 1, 0, 0);
502
503 glCallList(monsterHead);
504
505 if (itsChristmas)
506 {
507 glPushMatrix();
508 glScalef(1.2, .5, 1.2);
509 glTranslatef(0.0, PLANEY+1.7, 0.0);
510 glColor3fv(colorwhite);
511 v[0] = v[1] = v[2] = 0;
512 v[3] = .14;
513 andysphdraw(v, 4);
514 glPopMatrix();
515 glPushMatrix();
516 glTranslatef(-0.15, PLANEY+1.55, -0.15);
517 glScalef(0.15, 0.2, 0.15);
518 drawClosedCone(colorred, colorred, 1);
519 glPopMatrix();
520
521 glPushMatrix();
522 glTranslatef(-0.09, PLANEY+1.75, 0.04);
523 glRotatef(.1*(1100), 1, 0, 0);
524 glRotatef(.1*(450), 0, 0, 1);
525 glScalef(.04, .11, .1);
526 drawClosedCone(colorred, colorred, 1);
527 glPopMatrix();
528
529 glColor3fv(colorwhite);
530 v[0] = -0.15;
531 v[1] = PLANEY+1.6;
532 v[2] = 0.1;
533 v[3] = 0.05;
534 andysphdraw(v, 4);
535 }
536
537 glPopMatrix();
538
539 /********/
540 /* body */
541 /********/
542
543 glCallList(monsterBody);
544
545 /***********************/
546 /* legs, feet and toes */
547 /***********************/
548
549 glPushMatrix();
550 glTranslatef(0.2, monster.rot1, monster.rot2);
551 glCallList(monsterleg);
552 glTranslatef(-0.4, -2*monster.rot1, -2*monster.rot2);
553 glCallList(monsterleg);
554 glPopMatrix();
555
556 if ((!monster.monsterIsDead) && (detail > 0))
557 {
558 glColor4fv(colorblack);
559
560 shadow (0.0, 0.0, 0.2, 0.2);
561 shadow (0.2, monster.rot2, 0.1, 0.15);
562 shadow (-0.2, -monster.rot2, 0.1, 0.15);
563 }
564
565 /********/
566 /* tail */
567 /********/
568
569 glRotatef(sin(counter * 0.15915)*10, 0, 1, 0); /* 1/(2 * pi) */
570
571 glCallList(monsterTail);
572
573 if (itsChristmas)
574 {
575 glPushMatrix();
576 glTranslatef(-0.15, PLANEY+0.85, -0.45);
577 glScalef(0.15, 0.15, 0.15);
578 drawClosedCone(colorbeige, colorbrown, 1);
579 glPopMatrix();
580
581 glPushMatrix();
582 glTranslatef(0.0, PLANEY+0.5, -0.3);
583 glScalef(1, 1.5, 1);
584 glColor3fv(colorbeige);
585 v[0] = v[1] = v[2] = 0;
586 v[3] = 0.2;
587 andysphdraw(v, 4);
588 glPopMatrix();
589 }
590
591 if ((!monster.monsterIsDead) && (detail > 0))
592 {
593 glColor4fv(colorblack);
594
595 shadow (0.0, -0.25, 0.1, 0.25);
596
597 glColor3fv(colorblack);
598
599 glBegin(GL_TRIANGLES);
600 glVertex3fv(googShadow1);
601 glVertex3fv(googShadow2);
602 glVertex3fv(googShadow3);
603 glEnd();
604 }
605
606 glPopMatrix();
607 }
608
609 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
610 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
611 /* draw SIMPLIFIED Googelon (to save time in monsterview) */
612 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
613
drawSimpleMonster(struct monsterInfo monster,int counter,int itsChristmas,int detail)614 void drawSimpleMonster(struct monsterInfo monster, int counter,
615 int itsChristmas, int detail)
616 {
617 float v[4];
618
619 /*********************/
620 /* googelon's shadow */
621 /*********************/
622
623 glPushMatrix();
624
625 glRotatef(.1*monster.headHorzRotate, 0, 1, 0);
626
627 /********/
628 /* head */
629 /********/
630
631 glPushMatrix();
632 glRotatef(.1*monster.headVertRotate, 1, 0, 0);
633
634 glCallList(monsterSimpleHead);
635
636 if (itsChristmas)
637 {
638 glPushMatrix();
639 glScalef(1.2, .5, 1.2);
640 glTranslatef(0.0, PLANEY+1.7, 0.0);
641 glColor3fv(colorwhite);
642 v[0] = v[1] = v[2] = 0;
643 v[3] = .14;
644 andysphdraw(v, 4);
645 glPopMatrix();
646 glPushMatrix();
647 glTranslatef(-0.15, PLANEY+1.55, -0.15);
648 glScalef(0.15, 0.2, 0.15);
649 drawClosedCone(colorred, colorred, 1);
650 glPopMatrix();
651
652 glPushMatrix();
653 glTranslatef(-0.09, PLANEY+1.75, 0.04);
654 glRotatef(.1*(1100), 1, 0, 0);
655 glRotatef(.1*(450), 0, 0, 1);
656 glScalef(.04, .11, .1);
657 drawClosedCone(colorred, colorred, 1);
658 glPopMatrix();
659
660 glColor3fv(colorwhite);
661 v[0] = -0.15;
662 v[1] = PLANEY+1.6;
663 v[2] = 0.1;
664 v[3] = 0.05;
665 andysphdraw(v, 4);
666 }
667
668 glPopMatrix();
669
670 /********/
671 /* body */
672 /********/
673
674 makercubeTopBack(0.0, PLANEY+0.5, 0.0, 0.2, 0.3, 0.2, colorred);
675 makercubeTopBack(0.0, PLANEY+0.9, 0.0, 0.15, 0.2, 0.15, colorred);
676
677 /***********************/
678 /* legs, feet and toes */
679 /***********************/
680
681 glPushMatrix();
682 glTranslatef(0.2, monster.rot1, monster.rot2);
683
684 makercubeTopBack( 0.0, PLANEY+0.2, 0.0, 0.1, 0.2, 0.1, colorred);
685 makercubeTopBack( 0.0, PLANEY+0.06, 0.17, 0.1, 0.06, 0.08, colorred);
686
687 glTranslatef(-0.4, -2*monster.rot1, -2*monster.rot2);
688
689 makercubeTopBack( 0.0, PLANEY+0.2, 0.0, 0.1, 0.2, 0.1, colorred);
690 makercubeTopBack( 0.0, PLANEY+0.06, 0.17, 0.1, 0.06, 0.08, colorred);
691
692 glPopMatrix();
693
694 if ((!monster.monsterIsDead) && (detail > 0))
695 {
696 glColor4fv(colorblack);
697
698 shadow (0.0, 0.0, 0.2, 0.2);
699 shadow (0.2, monster.rot2, 0.1, 0.15);
700 shadow (-0.2, -monster.rot2, 0.1, 0.15);
701 }
702
703 /********/
704 /* tail */
705 /********/
706
707 glRotatef(sin(counter * 0.15915)*10, 0, 1, 0); /* 1/(2 * pi) */
708
709 glCallList(monsterSimpleTail);
710
711 if (itsChristmas)
712 {
713 glPushMatrix();
714 glTranslatef(-0.15, PLANEY+0.85, -0.45);
715 glScalef(0.15, 0.15, 0.15);
716 drawClosedCone(colorbeige, colorbrown, 1);
717 glPopMatrix();
718
719 glPushMatrix();
720 glTranslatef(0.0, PLANEY+0.5, -0.3);
721 glScalef(1, 1.5, 1);
722 glColor3fv(colorbeige);
723 v[0] = v[1] = v[2] = 0;
724 v[3] = 0.2;
725 andysphdraw(v, 4);
726 glPopMatrix();
727 }
728
729
730 glPopMatrix();
731 }
732
733 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
734 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
735 /* Draw the Vapour */
736 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
737
drawVapour(struct monsterInfo monster,int itsChristmas,int detail)738 void drawVapour(struct monsterInfo monster, int itsChristmas, int detail)
739 {
740 register int i;
741 glPushMatrix();
742
743 if (detail > 0)
744 glEnable(GL_BLEND);
745
746 glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
747
748 colorwhite2[0] = 1;
749 colorwhite2[1] = 1;
750 colorwhite2[2] = 1;
751
752 if (monster.monsterIsDead)
753 {
754 if (detail == -1)
755 {
756 colorwhite2[0] = 1 - monster.deadCount * 0.022;
757 colorwhite2[1] = 1 - monster.deadCount * 0.022;
758 colorwhite2[2] = 1 - monster.deadCount * 0.022;
759 }
760
761 colorwhite2[3] = 1 - monster.deadCount * 0.022;
762 glColor4fv(colorwhite2);
763 }
764 else if (itsChristmas)
765 glColor4fv(colorsnowvapour);
766 else
767 glColor4fv(colorwhite);
768
769 if (detail == 0)
770 for(i = 0; i < (int) (MAXTRIBUTES/1.5); i++)
771 andysphdraw(monster.a[i], 0);
772 else
773 for(i=0; i<MAXTRIBUTES; i++)
774 andysphdraw(monster.a[i], 0);
775
776 glDisable(GL_BLEND);
777
778 glPopMatrix();
779 }
780
781
782
783 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
784 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
785 /* draw Flutter */
786 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
787
drawFlutter(struct monsterInfo monster,int counter,int itsChristmas,float offsetX,int thaView,int detail)788 void drawFlutter(struct monsterInfo monster, int counter,
789 int itsChristmas, float offsetX, int thaView, int detail)
790 {
791 float rotAmt;
792
793 rotAmt = sin(counter * 0.3183) * 15;
794
795
796 glPushMatrix();
797 glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
798
799 /* shadow */
800
801 if (!monster.monsterIsDead)
802 {
803 glPushAttrib(GL_DEPTH_BUFFER_BIT);
804 glPushAttrib(GL_COLOR_BUFFER_BIT);
805
806 if (thaView == MONSTERVIEW)
807 {
808 if (detail > 0)
809 glEnable(GL_BLEND);
810 glDisable(GL_DEPTH_TEST);
811 }
812
813 glCallList(flutterShadow);
814
815 glPopAttrib();
816 glPopAttrib();
817 }
818
819
820
821 glPushMatrix();
822 glRotatef(offsetX * 10, 0, 0, 1);
823
824 if (itsChristmas)
825 glCallList(flutterXMas);
826
827 glPushMatrix();
828 glRotatef(monster.headVertRotate * 0.05, 1, 0, 0);
829
830 glCallList(flutterHead);
831 glPopMatrix();
832
833 glCallList(flutterBody);
834
835 glTranslatef(0, PLANEY+1.15, 0);
836
837 glPushMatrix();
838 glRotatef( rotAmt, 0, 0, 1); /* 1/(2 * pi) */
839 glCallList(flutterWing1);
840 glPopMatrix();
841
842 glPushMatrix();
843 glRotatef( - rotAmt, 0, 0, 1); /* 1/(2 * pi) */
844 glCallList(flutterWing2);
845 glPopMatrix();
846
847
848 glPopMatrix();
849
850 glPopMatrix();
851
852 }
853
854
855
856 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
857 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
858 /* draw Techs */
859 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
860
drawTechs(struct monsterInfo monster,int detail)861 void drawTechs(struct monsterInfo monster, int detail)
862 {
863 glPushMatrix();
864
865 glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
866
867 if (monster.deadCount < 45)
868 {
869 glPushMatrix();
870 glRotatef(0.1 * monster.headVertRotate, 1, 0, 0);
871 glCallList(techsHead);
872 glPopMatrix();
873
874 glCallList(techsBody);
875 }
876
877 if ((!monster.monsterIsDead) && (detail > 0))
878 {
879 glCallList(techsShadow);
880 }
881
882 glPopMatrix();
883
884 if (monster.deadCount >= 45)
885 {
886 glPushMatrix();
887 glTranslatef(monster.timeDead * 0.05 + 0.2, -monster.timeDead * 0.05, monster.timeDead * 0.05);
888 glRotatef(monster.timeDead*10, 1, 0, 0);
889 glRotatef(monster.timeDead*15, 0, 1, 0);
890 makercube(0.0, 0, 0, 0.03, 0.25, 0.2, colorgrey2);
891 makercube(0.011, 0, 0, 0.02, 0.2, 0.15, colorblack);
892 glPopMatrix();
893
894 glPushMatrix();
895 glTranslatef(-monster.timeDead * 0.05 - 0.2, monster.timeDead * 0.05, monster.timeDead * 0.05);
896 glRotatef(monster.timeDead*10, 1, 0, 0);
897 glRotatef(monster.timeDead*15, 0, 1, 0);
898 makercube( 0.0, 0, 0, 0.03, 0.25, 0.2, colorgrey2);
899 makercube(-0.011, 0, 0, 0.02, 0.2, 0.15, colorblack);
900 glPopMatrix();
901 }
902 }
903
904
905 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
906 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
907 /* draw SIMPLE Techs */
908 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
909
drawSimpleTechs(struct monsterInfo monster,int detail)910 void drawSimpleTechs(struct monsterInfo monster, int detail)
911 {
912 glPushMatrix();
913
914 glRotatef(0.1 * monster.headHorzRotate, 0, 1, 0);
915
916 if (monster.deadCount < 45)
917 {
918 glPushMatrix();
919 glRotatef(0.1 * monster.headVertRotate, 1, 0, 0);
920 glCallList(techsSimpleHead);
921 glPopMatrix();
922
923 glCallList(techsSimpleBody);
924 }
925
926 if ((!monster.monsterIsDead) && (detail > 0))
927 {
928 glCallList(techsShadow);
929 }
930
931 glPopMatrix();
932
933 }
934
935
936 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
937 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
938 /* draw the energy typhoon hero */
939 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
940
drawHeroDude(int power,int counter,int mcount,int dCount,int detail)941 void drawHeroDude(int power, int counter,
942 int mcount, int dCount, int detail)
943 {
944 float spheredat[4];
945 int ang;
946 int amount, amount2;
947 float dam;
948 float c1[4], c2[4], c3[4], c4[4], c5[4];
949 int sph;
950
951 if (detail >= 2)
952 sph = 4;
953 else
954 sph = 3;
955
956 c1[3] = c2[3] = c3[3] = c4[3] = c5[3] = 1;
957 dam = dCount * 0.075;
958
959 c2[0] = (colorwhite[0] + dam) >= 1 ? 1 : (colorwhite[0] + dam);
960 c2[1] = (colorwhite[1] + dam) >= 1 ? 1 : (colorwhite[1] + dam);
961 c2[2] = (colorwhite[2] + dam) >= 1 ? 1 : (colorwhite[2] + dam);
962
963 c1[0] = (colorwater[0] + dam) >= 1 ? 1 : (colorwater[0] + dam);
964 c1[1] = (colorwater[1] + dam) >= 1 ? 1 : (colorwater[1] + dam);
965 c1[2] = (colorwater[2] + dam) >= 1 ? 1 : (colorwater[2] + dam);
966
967 c3[0] = (colorblack[0] + dam) >= 1 ? 1 : (colorblack[0] + dam);
968 c3[1] = (colorblack[1] + dam) >= 1 ? 1 : (colorblack[1] + dam);
969 c3[2] = (colorblack[2] + dam) >= 1 ? 1 : (colorblack[2] + dam);
970
971 c4[0] = (colorgrey2[0] + dam) >= 1 ? 1 : (colorgrey2[0] + dam);
972 c4[1] = (colorgrey2[1] + dam) >= 1 ? 1 : (colorgrey2[1] + dam);
973 c4[2] = (colorgrey2[2] + dam) >= 1 ? 1 : (colorgrey2[2] + dam);
974
975 c5[0] = (colorwater[0] + dam) >= 1 ? 1 : (colorwater[0] + dam);
976 c5[1] = (colorwater[1] + dam) >= 1 ? 1 : (colorwater[1] + dam);
977 c5[2] = (colorwater[2] + dam) >= 1 ? 1 : (colorwater[2] + dam);
978
979 /********/
980 /* head */
981 /********/
982
983 glPushMatrix();
984 glScalef(0.55, 1, 0.55);
985 glColor4fv(c4);
986 spheredat[0] = 0;
987 spheredat[1] = PLANEY+1.21;
988 spheredat[2] = 0;
989 spheredat[3] = 0.12;
990 andysphdraw(spheredat, sph);
991
992 if (power > 8)
993 makercube(.06, PLANEY+1.25, .075, 0.03, 0.015, 0.035, c3);
994 else
995 makeitd(1, c3, .06, PLANEY+1.25, .075, 0.03, 0.015, 0.035);
996
997 if (power > 5)
998 makercube(-.06, PLANEY+1.25, .075, 0.03, 0.015, 0.035, c3);
999 else
1000 makeitd(0, c3, -.06, PLANEY+1.25, .075, 0.03, 0.015, 0.035);
1001
1002 if (power > 3)
1003 makercube(0, PLANEY+1.16, .075, 0.03, 0.014, 0.035, c4);
1004 else
1005 makeitd(1, c4, 0, PLANEY+1.16, .075, 0.03, 0.014, 0.035);
1006 glColor4fv(c5);
1007 spheredat[2] = -0.01;
1008 andysphdraw(spheredat, sph);
1009 glPopMatrix();
1010
1011
1012 /********/
1013 /* neck */
1014 /********/
1015
1016 if (power > 10)
1017 makercube(0, PLANEY+1.075, 0, 0.025, 0.025, 0.025, c2);
1018 else
1019 makeitd(1, c2, 0, PLANEY+1.075, 0, 0.025, 0.025, 0.025);
1020
1021 /********/
1022 /* body */
1023 /********/
1024
1025 if (power > 15)
1026 makercube(0, PLANEY+0.95, 0, 0.075, 0.1, 0.055, c1);
1027 else
1028 makeitd(0, c1, 0, PLANEY+0.95, 0, 0.075, 0.1, 0.055);
1029
1030 if (power > 20)
1031 makercube(0, PLANEY+0.75, 0, 0.075, 0.1, 0.055, c2);
1032 else
1033 makeitd(0, c2, 0, PLANEY+0.75, 0, 0.075, 0.1, 0.055);
1034
1035 if (power > 25)
1036 makercube(0, PLANEY+1.01, 0.055, 0.02, 0.05, 0.01, c2);
1037 else
1038 makeitd(1, c2, 0, PLANEY+1.01, 0.055, 0.02, 0.05, 0.01);
1039
1040 /*************/
1041 /* shoulders */
1042 /*************/
1043
1044 if (power > 30)
1045 makercube(0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05, c2);
1046 else
1047 makeitd(0, c2, 0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05);
1048
1049 if (power > 35)
1050 makercube(-0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05, c2);
1051 else
1052 makeitd(1, c2, -0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05);
1053
1054 /********/
1055 /* arms */
1056 /********/
1057
1058 if (mcount > 30)
1059 amount = (40 - mcount) * 9;
1060 else if (mcount > 10)
1061 amount = 90;
1062 else
1063 amount = mcount * 9;
1064
1065 ang = (int) amount * 10;
1066
1067 glPushMatrix();
1068 glRotatef(.1*(-ang), 1, 0, 0);
1069
1070 if (power > 40)
1071 makercube(0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025, c1);
1072 else
1073 makeitd(1, c1, 0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025);
1074
1075 glPushMatrix();
1076 glTranslatef(0.13, PLANEY+0.75, 0);
1077
1078 if (power > 45)
1079 makercube(0, -0.09, 0, 0.024, 0.11, 0.024, c2);
1080 else
1081 makeitd(0, c2, 0, -0.09, 0, 0.024, 0.11, 0.024);
1082
1083 if (power > 50)
1084 makercube(0, -0.19, 0, 0.03, 0.03, 0.028, c1);
1085 else
1086 makeitd(1, c1, 0, -0.19, 0, 0.03, 0.03, 0.028);
1087 glPopMatrix();
1088 glPopMatrix();
1089
1090 glPushMatrix();
1091 glRotatef(.1*(-ang), 1, 0, 0);
1092
1093 if (power > 55)
1094 makercube(-0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025, c1);
1095 else
1096 makeitd(0, c1, -0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025);
1097
1098 glPushMatrix();
1099 glTranslatef(-0.13, PLANEY+0.75, 0);
1100
1101 if (power > 60)
1102 makercube(0, -0.09, 0, 0.024, 0.11, 0.024, c2);
1103 else
1104 makeitd(0, c2, 0, -0.09, 0, 0.024, 0.11, 0.024);
1105
1106 if (power > 65)
1107 makercube(0, -0.19, 0, 0.03, 0.03, 0.028, c1);
1108 else
1109 makeitd(1, c1, 0, -0.19, 0, 0.03, 0.03, 0.028);
1110 glPopMatrix();
1111 glPopMatrix();
1112
1113 /********/
1114 /* legs */
1115 /********/
1116
1117 amount = (counter * 100) % 2400;
1118 if (amount < 1200)
1119 amount2 = 300 + amount;
1120 else
1121 amount2 = 900 + amount;
1122
1123 ang = (int) (cos(BIG_DEG_TO_RAD * amount2) * RAD_TO_SMALL_DEG * 2.5);
1124
1125 glPushMatrix();
1126 glTranslatef(0.04, PLANEY+0.65, 0);
1127 glRotatef(.1*(ang ), 1, 0, 0);
1128
1129 if (power > 70)
1130 makercube(0, -0.12, 0, 0.035, 0.13, 0.03, c2);
1131 else
1132 makeitd(0, c2, 0, -0.12, 0, 0.035, 0.13, 0.03);
1133
1134 if (power > 75)
1135 makercube(0, -.35, 0, 0.024, 0.2, 0.029, c1);
1136 else
1137 makeitd(1, c1, 0, -.35, 0, 0.024, 0.2, 0.029);
1138
1139 if (power > 80)
1140 makercube(0, -.59, +0.025, 0.026, 0.04, 0.075, c2);
1141 else
1142 makeitd(0, c2, 0, -.59, +0.025, 0.026, 0.04, 0.075);
1143 glPopMatrix();
1144
1145 glPushMatrix();
1146 glTranslatef(-0.04, PLANEY+0.65, 0);
1147 glRotatef(.1*(-ang), 1, 0, 0);
1148
1149 if (power > 85)
1150 makercube(0, -0.12, 0, 0.035, 0.13, 0.03, c2);
1151 else
1152 makeitd(1, c2, 0, -0.12, 0, 0.035, 0.13, 0.03);
1153
1154 if (power > 90)
1155 makercube(0, -.35, 0, 0.024, 0.2, 0.029, c1);
1156 else
1157 makeitd(0, c1, 0, -.35, 0, 0.024, 0.2, 0.029);
1158
1159 if (power > 95)
1160 makercube(0, -.59, +0.025, 0.026, 0.04, 0.075, c2);
1161 else
1162 makeitd(1, c2, 0, -.59, +0.025, 0.026, 0.04, 0.075);
1163 glPopMatrix();
1164
1165 }
1166
1167 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1168 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1169 /* draw the energy beam hero */
1170 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1171
drawHeroDude2(int power,int counter,int mcount,int dCount,int detail)1172 void drawHeroDude2(int power, int counter,
1173 int mcount, int dCount, int detail)
1174 {
1175 float spheredat[4];
1176 int ang;
1177 int amount, amount2;
1178 float dam;
1179 float c1[4], c2[4], c3[4], c4[4], c5[4];
1180 int sph;
1181
1182
1183 if (detail >= 2)
1184 sph=4;
1185 else
1186 sph=3 ;
1187
1188
1189 c1[3] = c2[3] = c3[3] = c4[3] = c5[3] = 1;
1190 dam = dCount * 0.075;
1191
1192 c1[0] = (colorwhite[0] + dam) >= 1 ? 1 : (colorwhite[0] + dam);
1193 c1[1] = (colorwhite[1] + dam) >= 1 ? 1 : (colorwhite[1] + dam);
1194 c1[2] = (colorwhite[2] + dam) >= 1 ? 1 : (colorwhite[2] + dam);
1195
1196 c2[0] = (colorred[0] + dam) >= 1 ? 1 : (colorred[0] + dam);
1197 c2[1] = (colorred[1] + dam) >= 1 ? 1 : (colorred[1] + dam);
1198 c2[2] = (colorred[2] + dam) >= 1 ? 1 : (colorred[2] + dam);
1199
1200 c3[0] = (colorblack[0] + dam) >= 1 ? 1 : (colorblack[0] + dam);
1201 c3[1] = (colorblack[1] + dam) >= 1 ? 1 : (colorblack[1] + dam);
1202 c3[2] = (colorblack[2] + dam) >= 1 ? 1 : (colorblack[2] + dam);
1203
1204 c4[0] = (colorgrey2[0] + dam) >= 1 ? 1 : (colorgrey2[0] + dam);
1205 c4[1] = (colorgrey2[1] + dam) >= 1 ? 1 : (colorgrey2[1] + dam);
1206 c4[2] = (colorgrey2[2] + dam) >= 1 ? 1 : (colorgrey2[2] + dam);
1207
1208 c5[0] = (colorred3[0] + dam) >= 1 ? 1 : (colorred3[0] + dam);
1209 c5[1] = (colorred3[1] + dam) >= 1 ? 1 : (colorred3[1] + dam);
1210 c5[2] = (colorred3[2] + dam) >= 1 ? 1 : (colorred3[2] + dam);
1211
1212 /********/
1213 /* head */
1214 /********/
1215
1216 glPushMatrix();
1217 glScalef(0.55, 1, 0.55);
1218 glColor4fv(c4);
1219 spheredat[0] = 0;
1220 spheredat[1] = PLANEY+1.21;
1221 spheredat[2] = 0;
1222 spheredat[3] = 0.12;
1223 andysphdraw(spheredat, sph);
1224
1225 if (power > 8)
1226 makercube(.06, PLANEY+1.25, .075, 0.03, 0.015, 0.035, c3);
1227 else
1228 makeitd(1, c3, .06, PLANEY+1.25, .075, 0.03, 0.015, 0.035);
1229
1230 if (power > 5)
1231 makercube(-.06, PLANEY+1.25, .075, 0.03, 0.015, 0.035, c3);
1232 else
1233 makeitd(0, c3, -.06, PLANEY+1.25, .075, 0.03, 0.015, 0.035);
1234
1235 if (power > 3)
1236 makercube(0, PLANEY+1.16, .075, 0.03, 0.014, 0.035, c4);
1237 else
1238 makeitd(1, c4, 0, PLANEY+1.16, .075, 0.03, 0.014, 0.035);
1239 glColor4fv(c5);
1240 spheredat[2] = -0.01;
1241 andysphdraw(spheredat, sph);
1242 glPopMatrix();
1243
1244 /********/
1245 /* neck */
1246 /********/
1247
1248 if (power > 10)
1249 makercube(0, PLANEY+1.075, 0, 0.025, 0.025, 0.025, c2);
1250 else
1251 makeitd(1, c2, 0, PLANEY+1.075, 0, 0.025, 0.025, 0.025);
1252
1253 /********/
1254 /* body */
1255 /********/
1256
1257 if (power > 15)
1258 makercube(0, PLANEY+0.95, 0, 0.075, 0.1, 0.055, c1);
1259 else
1260 makeitd(0, c1, 0, PLANEY+0.95, 0, 0.075, 0.1, 0.055);
1261
1262 if (power > 20)
1263 makercube(0, PLANEY+0.75, 0, 0.075, 0.1, 0.055, c2);
1264 else
1265 makeitd(0, c2, 0, PLANEY+0.75, 0, 0.075, 0.1, 0.055);
1266
1267 if (power > 25)
1268 makercube(0, PLANEY+1.01, 0.055, 0.02, 0.05, 0.01, c2);
1269 else
1270 makeitd(1, c2, 0, PLANEY+1.01, 0.055, 0.02, 0.05, 0.01);
1271
1272 /*************/
1273 /* shoulders */
1274 /*************/
1275
1276 if (power > 30)
1277 makercube(0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05, c2);
1278 else
1279 makeitd(0, c2, 0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05);
1280
1281 if (power > 35)
1282 makercube(-0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05, c2);
1283 else
1284 makeitd(1, c2, -0.075, PLANEY+1.0, 0, 0.075, 0.051, 0.05);
1285
1286 /********/
1287 /* arms */
1288 /********/
1289
1290 if (mcount > 30)
1291 amount = (40 - mcount) * 9;
1292 else if (mcount > 10)
1293 amount = 90;
1294 else
1295 amount = mcount * 9;
1296
1297 ang = (int) amount * 10;
1298
1299 if (power > 40)
1300 makercube(0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025, c1);
1301 else
1302 makeitd(1, c1, 0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025);
1303
1304 glPushMatrix();
1305 glTranslatef(0.13, PLANEY+0.75, 0);
1306
1307 if (power > 45)
1308 makercube(0, -0.09, 0, 0.024, 0.11, 0.024, c2);
1309 else
1310 makeitd(0, c2, 0, -0.09, 0, 0.024, 0.11, 0.024);
1311
1312 if (power > 50)
1313 makercube(0, -0.19, 0, 0.03, 0.03, 0.028, c1);
1314 else
1315 makeitd(1, c1, 0, -0.19, 0, 0.03, 0.03, 0.028);
1316 glPopMatrix();
1317
1318
1319 glPushMatrix();
1320 glRotatef(.1*(-ang/2 ), 1, 0, 0);
1321
1322 if (power > 55)
1323 makercube(-0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025, c1);
1324 else
1325 makeitd(0, c1, -0.13, PLANEY+0.875, 0, 0.025, 0.125, 0.025);
1326
1327 glPushMatrix();
1328 glTranslatef(-0.13, PLANEY+0.75, 0);
1329 glRotatef(.1*(ang ), 0, 0, 1);
1330
1331 if (power > 60)
1332 makercube(0, -0.09, 0, 0.024, 0.11, 0.024, c2);
1333 else
1334 makeitd(0, c2, 0, -0.09, 0, 0.024, 0.11, 0.024);
1335
1336 if (power > 65)
1337 makercube(0, -0.19, 0, 0.03, 0.03, 0.028, c1);
1338 else
1339 makeitd(1, c1, 0, -0.19, 0, 0.03, 0.03, 0.028);
1340 glPopMatrix();
1341 glPopMatrix();
1342
1343 /********/
1344 /* legs */
1345 /********/
1346
1347 amount = (counter *100) % 2400;
1348 if (amount < 1200)
1349 amount2 = 300 + amount;
1350 else
1351 amount2 = 900 + amount;
1352
1353 ang = (int) (cos(BIG_DEG_TO_RAD * amount2) * RAD_TO_SMALL_DEG * 2.5);
1354
1355 glPushMatrix();
1356 glTranslatef(0.04, PLANEY+0.65, 0);
1357 glRotatef(.1*(ang ), 1, 0, 0);
1358
1359 if (power > 70)
1360 makercube(0, -0.12, 0, 0.035, 0.13, 0.03, c2);
1361 else
1362 makeitd(0, c2, 0, -0.12, 0, 0.035, 0.13, 0.03);
1363
1364 if (power > 75)
1365 makercube(0, -.35, 0, 0.024, 0.2, 0.029, c1);
1366 else
1367 makeitd(1, c1, 0, -.35, 0, 0.024, 0.2, 0.029);
1368
1369 if (power > 80)
1370 makercube(0, -.59, +0.025, 0.026, 0.04, 0.075, c2);
1371 else
1372 makeitd(0, c2, 0, -.59, +0.025, 0.026, 0.04, 0.075);
1373 glPopMatrix();
1374
1375 glPushMatrix();
1376 glTranslatef(-0.04, PLANEY+0.65, 0);
1377 glRotatef(.1*(-ang), 1, 0, 0);
1378
1379 if (power > 85)
1380 makercube(0, -0.12, 0, 0.035, 0.13, 0.03, c2);
1381 else
1382 makeitd(1, c2, 0, -0.12, 0, 0.035, 0.13, 0.03);
1383
1384 if (power > 90)
1385 makercube(0, -.35, 0, 0.024, 0.2, 0.029, c1);
1386 else
1387 makeitd(0, c1, 0, -.35, 0, 0.024, 0.2, 0.029);
1388
1389 if (power > 95)
1390 makercube(0, -.59, +0.025, 0.026, 0.04, 0.075, c2);
1391 else
1392 makeitd(1, c2, 0, -.59, +0.025, 0.026, 0.04, 0.075);
1393 glPopMatrix();
1394
1395 }
1396
1397 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1398 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1399 /* draw MechaGoogelon */
1400 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1401
1402
drawMechaMonster(int dam,int counter,int detail)1403 void drawMechaMonster(int dam, int counter, int detail)
1404 {
1405 if (dam > 48)
1406 makercube(0.2, PLANEY+0.7, 0, 0.05, 0.05, 0.15, colorblue);
1407 else
1408 makeitd(1, colorblue, 0.2, PLANEY+0.7, 0, 0.05, 0.05, 0.15);
1409
1410 if (dam > 45)
1411 makercube(-0.2, PLANEY+0.7, 0, 0.05, 0.05, 0.15, colorblue);
1412 else
1413 makeitd(0, colorblue, -0.2, PLANEY+0.7, 0, 0.05, 0.05, 0.15);
1414
1415 /**************************/
1416 /* legs, feet of one side */
1417 /**************************/
1418
1419 if (dam > 43)
1420 makercube(0.2, PLANEY+0.2, 0, 0.12, 0.2, 0.1, colorgrey2);
1421 else
1422 makeitd(0, colorgrey2, 0.2, PLANEY+0.2, 0, 0.12, 0.2, 0.1);
1423
1424 if (dam > 40)
1425 makercube(0.2, PLANEY+0.06, 0.1, 0.1, 0.06, 0.15, colorwhite);
1426 else
1427 makeitd(1, colorwhite, 0.2, PLANEY+0.06, 0.1, 0.1, 0.06, 0.15);
1428
1429 /****************************/
1430 /* legs, feet of other side */
1431 /****************************/
1432
1433 if (dam > 38)
1434 makercube(-0.2, PLANEY+0.2, 0, 0.12, 0.2, 0.1, colorgrey2);
1435 else
1436 makeitd(1, colorgrey2, -0.2, PLANEY+0.2, 0, 0.12, 0.2, 0.1);
1437
1438 if (dam > 35)
1439 makercube(-0.2, PLANEY+0.06, 0.1, 0.1, 0.06, 0.15, colorwhite);
1440 else
1441 makeitd(0, colorwhite, -0.2, PLANEY+0.06, 0.1, 0.1, 0.06, 0.15);
1442
1443 /********/
1444 /* tail */
1445 /********/
1446
1447 if (dam > 30)
1448 {
1449 makercube(0, PLANEY+0.2, -0.2, 0.1, 0.15, 0.2, colorwhite);
1450 makercube(0, PLANEY+0.1, -0.4, 0.08, 0.1, 0.2, colorgrey2);
1451 }
1452 else
1453 {
1454 makeitd(0, colorwhite, 0, PLANEY+0.2, -0.2, 0.1, 0.15, 0.2);
1455 makeitd(1, colorgrey2, 0, PLANEY+0.1, -0.4, 0.08, 0.1, 0.2);
1456 }
1457
1458 glColor4fv(colorblack);
1459
1460 if (detail > 0)
1461 {
1462 shadow (0, -0.2, 0.1, 0.2);
1463 shadow (0, -0.4, 0.08, 0.2);
1464 }
1465
1466 /********/
1467 /* head */
1468 /********/
1469
1470 if (dam > 26)
1471 makercube(0, PLANEY + 1.15, 0, 0.25, 0.15, 0.12, colorwhite);
1472 else
1473 makeitd(0, colorwhite, 0, PLANEY + 1.15, 0, 0.25, 0.15, 0.12);
1474
1475 makeitPyr(2, colorwhite, 0, PLANEY + 1.15, -.24, 0.25, 0.15, 0.12);
1476
1477 if (dam > 22)
1478 makercube(0, PLANEY + 1.15, -0.24, 0.13, 0.08, 0.1, colorgrey2);
1479 else
1480 makeitd(1, colorgrey2, 0, PLANEY + 1.15, -0.24, 0.13, 0.08, 0.1);
1481
1482 /*******/
1483 /* eye */
1484 /*******/
1485
1486 if (dam > 18)
1487 makercube(0, PLANEY + 1.20, 0.1, 0.15, 0.06, 0.05, colorblack);
1488 else
1489 makeitd(1, colorblack, 0, PLANEY + 1.20, 0.1, 0.15, 0.06, 0.05);
1490
1491 if (dam > 14)
1492 makercube(sin((counter % 20) * 0.314) * 0.14, PLANEY + 1.20, 0.14, 0.04, 0.04, 0.04, colorred);
1493 else
1494 makeitd(0, colorred, sin((counter % 20) * 0.314) * 0.14, PLANEY + 1.20, 0.14, 0.04, 0.04, 0.04);
1495
1496 /********/
1497 /* body */
1498 /********/
1499
1500 if (dam > 10)
1501 makercube(0, PLANEY + 0.9, 0, 0.1, 0.2, 0.1, colorgrey2);
1502 else
1503 makeitd(0, colorgrey2, 0, PLANEY + 0.9, 0, 0.1, 0.2, 0.1);
1504
1505
1506 if (dam > 5)
1507 makercube(0, PLANEY + 0.5, 0.2, 0.1, 0.15, 0.05, colorgrey1);
1508 else
1509 makeitd(1, colorgrey1, 0, PLANEY + 0.5, 0.2, 0.1, 0.15, 0.05);
1510
1511
1512 if (dam > 0)
1513 makercube(0, PLANEY + 0.5, 0, 0.2, 0.3, 0.2, colorwhite);
1514 else
1515 makeitd(0, colorwhite, 0, PLANEY + 0.5, 0, 0.2, 0.3, 0.2);
1516
1517 glColor4fv(colorblack);
1518
1519 if (detail > 0)
1520 shadow (0, 0, 0.2, 0.2);
1521 }
1522
1523 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1524 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1525 /* draw a window on the negative z side of a building */
1526 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1527
wzminus(float x,float y,float z,float wx,float wy)1528 void wzminus(float x, float y, float z, float wx, float wy)
1529 {
1530 float v[3];
1531
1532 v[2] = z;
1533
1534 glBegin(GL_QUADS);
1535 v[0] = x-wx; v[1] = y-wy;
1536 glVertex3fv(v);
1537
1538 v[1] = y+wy;
1539 glVertex3fv(v);
1540
1541 v[0] = x+wx;
1542 glVertex3fv(v);
1543
1544 v[1] = y-wy;
1545 glVertex3fv(v);
1546 glEnd();
1547 }
1548
1549 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1550 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1551 /* draw a window on the positive z side of a building */
1552 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1553
wzplus(float x,float y,float z,float wx,float wy)1554 void wzplus(float x, float y, float z, float wx, float wy)
1555 {
1556 float v[3];
1557
1558 v[2] = z;
1559
1560 glBegin(GL_QUADS);
1561 v[0] = x+wx; v[1] = y-wy;
1562 glVertex3fv(v);
1563
1564 v[1] = y+wy;
1565 glVertex3fv(v);
1566
1567 v[0] = x-wx;
1568 glVertex3fv(v);
1569
1570 v[1] = y-wy;
1571 glVertex3fv(v);
1572 glEnd();
1573 }
1574
1575 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1576 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1577 /* draw a window on the positive x side of a building */
1578 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1579
wxplus(float x,float y,float z,float wy,float wz)1580 void wxplus(float x, float y, float z, float wy, float wz)
1581 {
1582 float v[3];
1583
1584 v[0] = x;
1585
1586 glBegin(GL_QUADS);
1587 v[1] = y+wy; v[2] = z-wz;
1588 glVertex3fv(v);
1589
1590 v[2] = z+wz;
1591 glVertex3fv(v);
1592
1593 v[1] = y-wy;
1594 glVertex3fv(v);
1595
1596 v[2] = z-wz;
1597 glVertex3fv(v);
1598 glEnd();
1599 }
1600
1601 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1602 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1603 /* draw a window on the negative x side of a building */
1604 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1605
wxminus(float x,float y,float z,float wy,float wz)1606 void wxminus(float x, float y, float z, float wy, float wz)
1607 {
1608 float v[3];
1609
1610 v[0] = x;
1611
1612 glBegin(GL_QUADS);
1613 v[1] = y-wy; v[2] = z-wz;
1614 glVertex3fv(v);
1615
1616 v[2] = z+wz;
1617 glVertex3fv(v);
1618
1619 v[1] = y+wy;
1620 glVertex3fv(v);
1621
1622 v[2] = z-wz;
1623 glVertex3fv(v);
1624 glEnd();
1625 }
1626
1627
1628 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1629 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1630 /* draw generic square building */
1631 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1632
drawBuilding0(float * colour,int detail)1633 void drawBuilding0(float * colour, int detail)
1634 {
1635 makercubenobtm(0.0, 0.4, 0.0, 0.3, 0.4, 0.3, colour);
1636 if (detail > 0)
1637 glCallList(genericWindows);
1638 }
1639
1640
1641 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1642 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1643 /* draw generic fast food resteraunt */
1644 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1645
drawBuilding6(int counter,float * c1,float * c2,int detail)1646 void drawBuilding6(int counter, float * c1, float * c2, int detail)
1647 {
1648 makercubenobtmnotop( 0, .2, 0, .3, .2, .35, c1);
1649 makeitPyr(1, c2, 0, .5, 0, .35, .1, .45);
1650
1651 makercubenobtm( .38, .25, 0.1, .01, .25, .015, colorgrey2);
1652
1653 glPushMatrix();
1654 glTranslatef(.38, .6, 0.1);
1655 glRotatef((counter*15) % 360, 0, 1, 0);
1656 makercube(0.0, 0.0, 0.0, 0.01, 0.1, 0.14, c2);
1657 makercube(0.0, 0.0, 0.0, 0.013, 0.07, 0.11, c1);
1658 glPopMatrix();
1659
1660 /* windows */
1661
1662 if (detail > 0)
1663 {
1664 glColor3fv(colorblack);
1665
1666 wxplus(0.303, 0.15, -0.15, 0.15, 0.05);
1667
1668 wxplus(0.303, 0.2, 0.15, 0.075, 0.075);
1669
1670 wzminus(-0.15, 0.2, -0.352, 0.075, 0.075);
1671 wzplus( -0.15, 0.2, 0.352, 0.075, 0.075);
1672 wzplus( 0.15, 0.2, 0.352, 0.075, 0.075);
1673 wzminus( 0.15, 0.2, -0.352, 0.075, 0.075);
1674 }
1675 }
1676
1677
1678 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1679 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1680 /* draw warehouse / hanger */
1681 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1682
drawBuilding8(float * c1,float * c2,int detail)1683 void drawBuilding8(float * c1, float * c2, int detail)
1684 {
1685 makercubenobtmnotop(0, .2, 0, .35, .2, .3, c1);
1686 makeitPyr(4, c2, 0, .5, 0, .35, .1, .3);
1687
1688 /* windows */
1689
1690 if (detail > 0)
1691 {
1692 glColor3fv(colorblack);
1693
1694 wzminus(0.0, 0.15, -0.303, 0.25, 0.15);
1695 wzplus( 0.0, 0.15, 0.303, 0.25, 0.15);
1696 }
1697 }
1698
1699 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1700 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1701 /* draw cooling towers */
1702 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1703
drawCoolingTower(int detail)1704 void drawCoolingTower(int detail)
1705 {
1706 GLUquadricObj *qobj;
1707
1708 glPushMatrix();
1709 glTranslatef(-0.3, 0.5, -0.3);
1710 glScalef(0.3, 0.5, 0.3);
1711
1712 drawClosedCylinder(colorgrey3, colorwhite, 0, detail);
1713
1714 glPopMatrix();
1715
1716 if (detail >= 0)
1717 {
1718 glPushMatrix();
1719 glColor3fv(colorblack);
1720 glTranslatef(0.0, 0.9, 0.0);
1721 glRotatef(-90, 1, 0, 0);
1722
1723 qobj = gluNewQuadric();
1724 gluDisk( qobj, 0., 0.28, 32, 1);
1725 gluDeleteQuadric(qobj);
1726
1727 glPopMatrix();
1728 }
1729 }
1730
1731 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1732 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1733 /* draw factory smokestacks */
1734 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1735
drawBuilding11(int detail)1736 void drawBuilding11(int detail)
1737 {
1738 makercubenobtm( 0, .05, 0, .3, .05, .3, colorgrey1);
1739
1740 glPushMatrix();
1741 glTranslatef(-.25, .8, -.1);
1742 glScalef(.1, .8, .1);
1743 drawClosedCylinder(colorgrey2, colorgrey3, 0, detail);
1744 glPopMatrix();
1745
1746 glPushMatrix();
1747 glTranslatef(.05, .8, -.1);
1748 glScalef(.1, .8, .1);
1749 drawClosedCylinder(colorgrey2, colorgrey3, 0, detail);
1750 glPopMatrix();
1751 }
1752
1753
1754 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1755 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1756 /* draw strip-mall store */
1757 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1758
drawBuilding15(float * buildingColour,float * awningColour,int detail)1759 void drawBuilding15(float * buildingColour, float * awningColour, int detail)
1760 {
1761 makeitPyr(13, awningColour, +.1, .54, 0, .3, .25, .297);
1762
1763 makercubenobtm( -.1, .4, 0, .3, .4, .3, buildingColour);
1764
1765 if (detail > 0)
1766 {
1767 glColor3fv(colorblack);
1768
1769 wxplus(0.203, .15, -.15, .15, .05);
1770 wxminus(-0.403, .15, -.15, .15, .05);
1771
1772 wxplus(0.203, .15, .10, .08, .12);
1773 }
1774 }
1775
1776
1777 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1778 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1779 /* draw office building */
1780 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1781
drawBuilding22(float * color)1782 void drawBuilding22(float * color)
1783 {
1784 makercubenobtm(0, .75, 0, .3, .75, .3, color);
1785 makercubenobtmnotop(0, .4, 0, .307, .1, .307, colorblack);
1786 makercubenobtmnotop(0, .8, 0, .307, .1, .307, colorblack);
1787 makercubenobtmnotop(0, 1.2, 0, .307, .1, .307, colorblack);
1788 }
1789
1790 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1791 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1792 /* draw smaller office building */
1793 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1794
drawBuilding34(float * color)1795 void drawBuilding34(float * color)
1796 {
1797 makercubenobtm(0, .3, 0, .3, .3, .3, color);
1798 makercubenobtmnotop(0, .4, 0, .307, .1, .307, colorblack);
1799 }
1800
1801 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1802 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1803 /* draw small office building */
1804 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1805
drawBuilding36(float * color)1806 void drawBuilding36(float * color)
1807 {
1808 makercubenobtm(0, .5, 0, .3, .5, .3, color);
1809 makercubenobtmnotop(0, .4, 0, .307, .1, .307, colorblack);
1810 makercubenobtmnotop(0, .8, 0, .307, .1, .307, colorblack);
1811 }
1812
1813 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1814 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1815 /* draw office building with sign */
1816 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1817
drawBuilding37(float * color,int detail)1818 void drawBuilding37(float * color, int detail)
1819 {
1820 static float tv1[2] = {0,1};
1821 static float tv2[2] = {1,1};
1822 static float tv3[2] = {1,0};
1823 static float tv4[2] = {0,0};
1824
1825 static float vec1[3]={0,1,0};
1826 static float vec2[3]={1,1,0};
1827 static float vec3[3]={1,0,0};
1828 static float vec4[3]={0,0,0};
1829
1830 makercubenobtm(0, .75, 0, .3, .75, .3, color);
1831 makercubenobtmnotop(0, .4, 0, .307, .1, .307, colorblack);
1832 makercubenobtmnotop(0, .8, 0, .307, .1, .307, colorblack);
1833 makercubenobtmnotop(0, 1.2, -0.01, .307, .1, .307, colorblack);
1834
1835 glPushMatrix();
1836 glColor4fv(colorwhite);
1837
1838 if ((detail >= 2) && (officeLogoData != NULL))
1839 {
1840 glCallList(officeLogo);
1841 glEnable(GL_TEXTURE_2D);
1842 }
1843
1844 glTranslatef(0.25, 1.1, 0.31);
1845 glScalef(0.5, 0.3, 0.01);
1846
1847 glRotatef(180, 0, 1, 0);
1848
1849 glBegin(GL_QUADS);
1850
1851 if ((detail >= 2) && (picleft != NULL))
1852 {
1853 glTexCoord2fv(tv1);
1854 glVertex3fv(vec1);
1855
1856 glTexCoord2fv(tv2);
1857 glVertex3fv(vec2);
1858
1859 glTexCoord2fv(tv3);
1860 glVertex3fv(vec3);
1861
1862 glTexCoord2fv(tv4);
1863 glVertex3fv(vec4);
1864 }
1865 else
1866 {
1867 glVertex3fv(vec1);
1868 glVertex3fv(vec2);
1869 glVertex3fv(vec3);
1870 glVertex3fv(vec4);
1871 }
1872
1873 glEnd();
1874
1875 glDisable(GL_TEXTURE_2D);
1876
1877 glPopMatrix();
1878 }
1879
1880 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1881 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1882 /* draw satellite dish */
1883 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1884
drawBuilding25()1885 void drawBuilding25()
1886 {
1887 long backNow;
1888 GLUquadricObj *qobj;
1889
1890 /******************/
1891 /* satellite dish */
1892 /******************/
1893
1894 float satSphere[4] = {0, 0.4, 0, 0.075};
1895
1896 float sat0[3] = { 0.0, 0.35, 0.0};
1897 float sat1[3] = { 0.0, 0.0, 0.35};
1898 float sat2[3] = { 0.0, -0.35, 0.0};
1899 float sat3[3] = { 0.35, 0.0, 0.0};
1900 float sat4[3] = {-0.35, 0.0, 0.0};
1901
1902 GLfloat lineWidthNow;
1903 glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
1904
1905 backNow = glIsEnabled(GL_CULL_FACE);
1906
1907 /* shadow */
1908
1909 glColor3fv(colorblack);
1910
1911 glPushMatrix();
1912 glTranslatef(0, 0, 0);
1913 glRotatef(-90, 1, 0, 0);
1914
1915 qobj = gluNewQuadric();
1916 gluDisk( qobj, 0., 0.3, 32, 1);
1917 gluDeleteQuadric(qobj);
1918
1919 glPopMatrix();
1920
1921 /* support post */
1922
1923 makercubenobtm( 0, .2, 0, .05, .2, .05, colorwhite);
1924
1925
1926 glColor3fv(colorgrey2);
1927 andysphdraw(satSphere, 4);
1928
1929 /* if line widths are integral Mesa chokes in a large window */
1930 glLineWidth(3.01);
1931 glColor3fv(colorwhite);
1932
1933 glPushMatrix();
1934 glDisable(GL_CULL_FACE);
1935
1936 glTranslatef(0, .4, 0);
1937 glRotatef(-45, 1, 0, 0);
1938
1939 qobj = gluNewQuadric();
1940 gluDisk( qobj, 0., 0.35, 32, 1);
1941 gluDeleteQuadric(qobj);
1942
1943 glPopMatrix();
1944
1945 if (backNow)
1946 glEnable(GL_CULL_FACE);
1947 else
1948 glDisable(GL_CULL_FACE);
1949
1950 glPushMatrix();
1951
1952 glTranslatef(0, .4, 0);
1953 glRotatef(-45, 1, 0, 0);
1954
1955 glColor3fv(colorgrey1);
1956
1957 glBegin(GL_LINE_STRIP);
1958 glVertex3fv(sat0);
1959 glVertex3fv(sat1);
1960 glVertex3fv(sat2);
1961 glEnd();
1962
1963 glBegin(GL_LINE_STRIP);
1964 glVertex3fv(sat3);
1965 glVertex3fv(sat1);
1966 glVertex3fv(sat4);
1967 glEnd();
1968 glPopMatrix();
1969
1970 glLineWidth(lineWidthNow);
1971 }
1972
1973 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1974 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1975 /* draw drive in theatre screen */
1976 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
1977
drawBuilding26(int rorl,int detail)1978 void drawBuilding26(int rorl, int detail)
1979 {
1980 /***************************/
1981 /* theatre screen supports */
1982 /***************************/
1983
1984 float screen0[3] = {-0.39, 0.01, -0.28};
1985 float screen1[3] = {-0.39, 0.01, 0.28};
1986 float screen2[3] = { 0.39, 0.01, 0.28};
1987 float screen3[3] = { 0.39, 0.01, -0.28};
1988 float screen4[3] = {-0.39, 0.79, 0.28};
1989 float screen5[3] = { 0.39, 0.79, 0.28};
1990 float screen6[3] = { 0.39, 0.01, -0.28};
1991
1992
1993 static float vec1[3]={0,1,0};
1994 static float vec2[3]={1,1,0};
1995 static float vec3[3]={1,0,0};
1996 static float vec4[3]={0,0,0};
1997
1998 static float tv1[2] = {0,1};
1999 static float tv2[2] = {1,1};
2000 static float tv3[2] = {1,0};
2001 static float tv4[2] = {0,0};
2002
2003 GLfloat lineWidthNow;
2004 glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
2005
2006 /* supports for the screen */
2007
2008 glColor4fv(colorgrey2);
2009 /* if line widths are integral Mesa chokes in a large window */
2010 glLineWidth(3.01);
2011
2012 glBegin(GL_LINE_LOOP);
2013 glVertex3fv(screen0);
2014 glVertex3fv(screen1);
2015 glVertex3fv(screen2);
2016 glVertex3fv(screen3);
2017 glEnd();
2018
2019 glBegin(GL_LINE_LOOP);
2020 glVertex3fv(screen0);
2021 glVertex3fv(screen4);
2022 glVertex3fv(screen5);
2023 glVertex3fv(screen6);
2024 glEnd();
2025
2026
2027 /* back of the screen */
2028 makercubenobtm( 0, 0.42, 0.28, 0.4,0.42, 0.01, colorwhite);
2029
2030 if ((detail >= 2) && (picleft != NULL) && (picright != NULL))
2031 {
2032 glPushMatrix();
2033 glColor4fv(colorwhite);
2034
2035
2036 if (rorl == 0)
2037 glCallList(leftScreen);
2038 else
2039 glCallList(rightScreen);
2040
2041 glEnable(GL_TEXTURE_2D);
2042
2043
2044 glTranslatef(0.4, 0, 0.3);
2045 glScalef(0.8, 0.8, 0.01);
2046
2047 glRotatef(180, 0, 1, 0);
2048
2049 glBegin(GL_QUADS);
2050
2051 glTexCoord2fv(tv1);
2052 glVertex3fv(vec1);
2053
2054 glTexCoord2fv(tv2);
2055 glVertex3fv(vec2);
2056
2057 glTexCoord2fv(tv3);
2058 glVertex3fv(vec3);
2059
2060 glTexCoord2fv(tv4);
2061 glVertex3fv(vec4);
2062
2063 glEnd();
2064
2065 glDisable(GL_TEXTURE_2D);
2066
2067
2068 glPopMatrix();
2069 }
2070
2071 glLineWidth(lineWidthNow);
2072 }
2073
2074
2075 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2076 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2077 /* draw fountain */
2078 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2079
drawBuilding29(int itsChristmas,int detail)2080 void drawBuilding29(int itsChristmas, int detail)
2081 {
2082 makercubenobtm( 0, .05, 0, .3, .05, .3, colorwhite);
2083
2084 makercubenobtm( .25, .1, 0, .05, .1, .3, colorwhite);
2085 makercubenobtm( -.25, .1, 0, .05, .1, .3, colorwhite);
2086 makercubenobtm( 0, .1, .25, .3, .1, .05, colorwhite);
2087 makercubenobtm( 0, .1, -.25, .3, .1, .05, colorwhite);
2088
2089 makeitPyr(3, colorgrey1, 0, 0.3, 0, 0.1, 0.3, 0.1);
2090
2091 if (!itsChristmas)
2092 {
2093 if (detail > 0)
2094 glEnable(GL_BLEND);
2095 makercubenobtm( 0, .1, 0, .19, .11, .19, colormaserblue);
2096 glDisable(GL_BLEND);
2097 }
2098 }
2099
2100
2101 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2102 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2103 /* draw hero beam in effect */
2104 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2105
drawBuilding33(int count,int detail)2106 void drawBuilding33(int count, int detail)
2107 {
2108 float c[4], height;
2109
2110 c[0] = colorred[0];
2111 c[1] = colorred[1] + (count/40.0);
2112 c[2] = colorred[2];
2113 c[3] = 1 - (count/20.0);
2114
2115 height = .8 - 0.04*count;
2116
2117 if (detail > 0)
2118 glEnable(GL_BLEND);
2119
2120 glPushMatrix();
2121 glTranslatef(-.2, height, -.2);
2122 glScalef(.2, height, .2);
2123 drawClosedCylinder(c, c, 0, detail);
2124 glPopMatrix();
2125
2126 glDisable(GL_BLEND);
2127 }
2128
2129 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2130 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2131 /* draw power line tower */
2132 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2133
drawTower(int death,int death2)2134 void drawTower(int death, int death2)
2135 {
2136 float v1[3], v2[3], v3[3], v4[3];
2137 float v5[3], v6[3], v7[3], v8[3];
2138 float va[3], vb[3], vc[3], vd[3];
2139 float ve[3], vf[3], vg[3];
2140 float vh[3], vi[3], vj[3];
2141
2142 float amt, amt2;
2143 float samt2, samt, camt2;
2144 float melt1, melt2;
2145
2146
2147 amt = 2 * death * DEG_TO_RAD;
2148 amt2 = death2 * DEG_TO_RAD;
2149
2150 samt2 = sin(amt2);
2151 samt = sin(amt);
2152 camt2 = cos(amt);
2153
2154 melt1 = samt2 * 0.5*samt;
2155 melt2 = camt2 * 0.5*samt;
2156
2157 if (death > 0)
2158 glColor3fv(colorwhite);
2159 else
2160 glColor3fv(colorgrey1);
2161
2162 if (death == 0)
2163 v1[1] = v2[1] = v3[1] = v4[1] = 0.7;
2164 else
2165 v1[1] = v2[1] = v3[1] = v4[1] = 0.3 + 0.4 * camt2;
2166
2167 v1[0] = v4[0] = -0.06;
2168 v1[2] = v2[2] = 0.06;
2169 v2[0] = v3[0] = 0.06;
2170 v3[2] = v4[2] = - 0.06;
2171
2172 v5[0] = v8[0] = -0.3;
2173 v5[1] = v6[1] = v7[1] = v8[1] = 0.0;
2174 v5[2] = v6[2] = 0.3;
2175 v6[0] = v7[0] = 0.3;
2176 v7[2] = v8[2] = - 0.3;
2177
2178 if (death == 0)
2179 {
2180 va[1] = vb[1] = vc[1] = vd[1] = 1.5;
2181 va[0] = v1[0];
2182 va[2] = v1[2];
2183
2184 vb[0] = v2[0];
2185 vb[2] = v2[2];
2186
2187 vc[0] = v3[0];
2188 vc[2] = v3[2];
2189
2190 vd[0] = v4[0];
2191 vd[2] = v4[2];
2192 }
2193 else
2194 {
2195 va[1] = vb[1] = vc[1] = vd[1] = 1.5 * camt2;
2196 va[0] = v1[0]+ melt1;
2197 va[2] = v1[2]+ melt2;
2198
2199 vb[0] = v2[0]+ melt1;
2200 vb[2] = v2[2]+ melt2;
2201
2202 vc[0] = v3[0]+ melt1;
2203 vc[2] = v3[2]+ melt2;
2204
2205 vd[0] = v4[0]+ melt1;
2206 vd[2] = v4[2]+ melt2;
2207 }
2208
2209
2210 ve[1] = vf[1] = vc[1] - 0.2;
2211 ve[0] = vc[0];
2212 ve[2] = vc[2];
2213
2214 vf[0] = vd[0];
2215 vf[2] = vd[2];
2216
2217 vg[0] = (vc[0] + vd[0]) * 0.5;
2218 vg[1] = vc[1] - 0.1;
2219 vg[2] = vc[2] - .2;
2220
2221
2222 vh[0] = va[0];
2223 vh[1] = vi[1] = va[1] - 0.2;
2224 vh[2] = va[2];
2225
2226 vi[0] = vb[0];
2227 vi[2] = vb[2];
2228
2229 vj[0] = (va[0] + vb[0]) * 0.5;
2230 vj[1] = va[1] - 0.1;
2231 vj[2] = va[2] + .2;
2232
2233
2234 /* if line widths are integral Mesa chokes in a large window */
2235 glLineWidth(3.01);
2236
2237 /********/
2238 /* legs */
2239 /********/
2240
2241 glBegin(GL_LINE_LOOP);
2242 glVertex3fv(v1); glVertex3fv(v2); glVertex3fv(v3); glVertex3fv(v4);
2243 glEnd();
2244
2245 glBegin(GL_LINE_LOOP);
2246 glVertex3fv(v4); glVertex3fv(v5); glVertex3fv(v2); glVertex3fv(v7);
2247 glEnd();
2248
2249 glBegin(GL_LINE_LOOP);
2250 glVertex3fv(v1); glVertex3fv(v6); glVertex3fv(v3); glVertex3fv(v8);
2251 glEnd();
2252
2253
2254 /* if line widths are integral Mesa chokes in a large window */
2255 glLineWidth(2.01);
2256
2257 /*******/
2258 /* top */
2259 /*******/
2260
2261 glBegin(GL_LINE_LOOP);
2262 glVertex3fv(va); glVertex3fv(vb); glVertex3fv(vc); glVertex3fv(vd);
2263 glEnd();
2264
2265 /*************************/
2266 /* supports and verticals*/
2267 /*************************/
2268
2269 glBegin(GL_LINE_STRIP);
2270 glVertex3fv(v7); glVertex3fv(v3); glVertex3fv(vc); glVertex3fv(vg); glVertex3fv(ve);
2271 glEnd();
2272
2273 glBegin(GL_LINE_STRIP);
2274 glVertex3fv(v8); glVertex3fv(v4); glVertex3fv(vd); glVertex3fv(vg); glVertex3fv(vf);
2275 glEnd();
2276
2277 glBegin(GL_LINE_STRIP);
2278 glVertex3fv(v5); glVertex3fv(v1); glVertex3fv(va); glVertex3fv(vj); glVertex3fv(vh);
2279 glEnd();
2280
2281 glBegin(GL_LINE_STRIP);
2282 glVertex3fv(v6); glVertex3fv(v2); glVertex3fv(vb); glVertex3fv(vj); glVertex3fv(vi);
2283 glEnd();
2284
2285
2286 glBegin(GL_LINE_LOOP);
2287 glVertex3fv(ve); glVertex3fv(vf); glVertex3fv(vh); glVertex3fv(vi);
2288 glEnd();
2289
2290 }
2291
2292
2293
2294 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2295 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2296 /* draw the square playing field */
2297 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2298
drawBattlefield(struct road * roads,float xshift,float zshift,int detail,int itsChristmas,int view)2299 void drawBattlefield(struct road * roads, float xshift, float zshift,
2300 int detail, int itsChristmas, int view)
2301 {
2302 float theta, radius;
2303 float angle;
2304
2305 /******************************/
2306 /* 'where is the town' arrow */
2307 /******************************/
2308
2309 static float arrow[4][3] = {-0.2, PLANEY + 0.01, -1.0,
2310 -0.2, PLANEY + 0.01, 1.0,
2311 0.2, PLANEY + 0.01, 1.0,
2312 0.2, PLANEY + 0.01, -1.0};
2313
2314 static float arrowhead[3][3] = {0.0, PLANEY + 0.01, -1.75,
2315 -0.5, PLANEY + 0.01, -1.0,
2316 0.5, PLANEY + 0.01, -1.0};
2317
2318 if (itsChristmas)
2319 glColor3fv(colorsnow);
2320 else
2321 glColor3fv(planeGreen);
2322
2323
2324 if (view == MAPVIEW)
2325 glCallList(bigPlane);
2326 else if (detail <= 1)
2327 glCallList(lowDPlane);
2328 else
2329 glCallList(highDPlane);
2330
2331
2332 /***************/
2333 /* draw roads */
2334 /***************/
2335
2336 drawRoads(roads, xshift, zshift, itsChristmas, view, detail);
2337
2338
2339 radius = sqrt(xshift * xshift + zshift * zshift);
2340
2341 if (radius > 36)
2342 {
2343 /**********************/
2344 /* draw town pointer */
2345 /**********************/
2346
2347 if (zshift == 0)
2348 zshift = NEARZERO;
2349
2350 theta = atan(xshift / zshift);
2351
2352 if (zshift > 0)
2353 theta += PI;
2354
2355 angle = theta * RAD_TO_SMALL_DEG;
2356
2357 glPushMatrix();
2358 glRotatef(angle, 0, 1, 0);
2359
2360 glColor3fv(colorred);
2361
2362 glBegin(GL_QUADS);
2363 glVertex3fv(arrow[0]);
2364 glVertex3fv(arrow[1]);
2365 glVertex3fv(arrow[2]);
2366 glVertex3fv(arrow[3]);
2367 glEnd();
2368
2369 glBegin(GL_TRIANGLES);
2370 glVertex3fv(arrowhead[0]);
2371 glVertex3fv(arrowhead[1]);
2372 glVertex3fv(arrowhead[2]);
2373 glEnd();
2374 glPopMatrix();
2375 }
2376 }
2377
2378 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2379 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2380 /* draw square lake segment */
2381 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2382
drawLake0(int itsChristmas)2383 void drawLake0(int itsChristmas)
2384 {
2385 static float lake[4][3] = {-0.3, 0.0, -0.3,
2386 0.3, 0.0, -0.3,
2387 0.3, 0.0, 0.3,
2388 -0.3, 0.0, 0.3};
2389
2390 if (itsChristmas)
2391 glColor3fv(colorblue);
2392 else
2393 glColor3fv(colorwater);
2394
2395 glBegin(GL_QUADS);
2396 glVertex3fv(lake[3]);
2397 glVertex3fv(lake[2]);
2398 glVertex3fv(lake[1]);
2399 glVertex3fv(lake[0]);
2400 glEnd();
2401 }
2402
2403 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2404 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2405 /* draw triangular lake segment */
2406 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2407
drawLake1(int itsChristmas)2408 void drawLake1(int itsChristmas)
2409 {
2410 float lake2[3][3] = {-0.3, 0.0, -0.3,
2411 0.3, 0.0, -0.3,
2412 -0.3, 0.0, 0.3};
2413
2414 if (itsChristmas)
2415 glColor3fv(colorblue);
2416 else
2417 glColor3fv(colorwater);
2418
2419 glBegin(GL_TRIANGLES);
2420 glVertex3fv(lake2[2]);
2421 glVertex3fv(lake2[1]);
2422 glVertex3fv(lake2[0]);
2423 glEnd();
2424 }
2425
2426 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2427 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2428 /* draw central hill segment */
2429 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2430
drawHill0(int itsChristmas)2431 void drawHill0(int itsChristmas)
2432 {
2433 static float hill[4][3] = {-0.3, 0.6, -0.3,
2434 0.3, 0.6, -0.3,
2435 0.3, 0.6, 0.3,
2436 -0.3, 0.6, 0.3};
2437
2438
2439 if (itsChristmas)
2440 glColor3fv(colorsnow);
2441 else
2442 glColor3fv(planeGreen2);
2443
2444 glBegin(GL_QUADS);
2445 glVertex3fv(hill[3]);
2446 glVertex3fv(hill[2]);
2447 glVertex3fv(hill[1]);
2448 glVertex3fv(hill[0]);
2449 glEnd();
2450
2451 }
2452
2453 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2454 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2455 /* draw side of hill */
2456 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2457
drawHill1(int sidemod,int itsChristmas)2458 void drawHill1(int sidemod, int itsChristmas)
2459 {
2460 float c[4];
2461
2462 static float side[4][3] = {-0.3, 0.6, -0.3,
2463 0.3, 0.6, -0.3,
2464 0.3, 0.0, 0.3,
2465 -0.3, 0.0, 0.3};
2466
2467 if (itsChristmas)
2468 {
2469 c[0] = colorsnow2[0];
2470 c[1] = colorsnow2[1];
2471 c[2] = colorsnow2[2];
2472 }
2473 else
2474 {
2475 c[0] = planeGreen3[0];
2476 c[1] = planeGreen3[1];
2477 c[2] = planeGreen3[2];
2478 }
2479
2480 c[0] -= sidemod*0.04;
2481 c[1] -= sidemod*0.04;
2482 c[2] -= sidemod*0.04;
2483
2484 if (c[0] < 0)
2485 c[0] = 0;
2486 if (c[1] < 0)
2487 c[1] = 0;
2488 if (c[2] < 0)
2489 c[2] = 0;
2490
2491 glColor3fv(c);
2492
2493 glBegin(GL_QUADS);
2494 glVertex3fv(side[3]);
2495 glVertex3fv(side[2]);
2496 glVertex3fv(side[1]);
2497 glVertex3fv(side[0]);
2498 glEnd();
2499
2500 }
2501
2502 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2503 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2504 /* draw corner of hill */
2505 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2506
drawHill2(int sidemod,int itsChristmas)2507 void drawHill2(int sidemod, int itsChristmas)
2508 {
2509 float c[4];
2510
2511 static float corner[3][3] = {-0.3, 0.6, -0.3,
2512 0.3, 0.0, -0.3,
2513 -0.3, 0.0, 0.3};
2514
2515 if (itsChristmas)
2516 {
2517 c[0] = colorsnow2[0];
2518 c[1] = colorsnow2[1];
2519 c[2] = colorsnow2[2];
2520 }
2521 else
2522 {
2523 c[0] = planeGreen3[0];
2524 c[1] = planeGreen3[1];
2525 c[2] = planeGreen3[2];
2526 }
2527
2528 c[0] -= (sidemod*0.04 + 0.02);
2529 c[1] -= (sidemod*0.04 + 0.02);
2530 c[2] -= (sidemod*0.04 + 0.02);
2531
2532 if (c[0] < 0)
2533 c[0] = 0;
2534 if (c[1] < 0)
2535 c[1] = 0;
2536 if (c[2] < 0)
2537 c[2] = 0;
2538
2539 glColor3fv(c);
2540
2541 glBegin(GL_TRIANGLES);
2542 glVertex3fv(corner[2]);
2543 glVertex3fv(corner[1]);
2544 glVertex3fv(corner[0]);
2545 glEnd();
2546
2547 }
2548
2549 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2550 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2551 /* draw inside corner of hill */
2552 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2553
drawHill3(int sidemod,int itsChristmas)2554 void drawHill3(int sidemod, int itsChristmas)
2555 {
2556 float c[4];
2557
2558 static float insidecorner[4][3] = {-0.3, 0.6, -0.3,
2559 0.3, 0.6, -0.3,
2560 -0.3, 0.6, 0.3,
2561 0.3, 0.0, 0.3 };
2562
2563 if (itsChristmas)
2564 glColor3fv(colorsnow);
2565 else
2566 glColor3fv(planeGreen2);
2567
2568 glBegin(GL_TRIANGLES);
2569 glVertex3fv(insidecorner[2]);
2570 glVertex3fv(insidecorner[1]);
2571 glVertex3fv(insidecorner[0]);
2572 glEnd();
2573
2574 if (itsChristmas)
2575 {
2576 c[0] = colorsnow2[0];
2577 c[1] = colorsnow2[1];
2578 c[2] = colorsnow2[2];
2579 }
2580 else
2581 {
2582 c[0] = planeGreen3[0];
2583 c[1] = planeGreen3[1];
2584 c[2] = planeGreen3[2];
2585 }
2586
2587 c[0] -= (sidemod*0.04 + 0.02);
2588 c[1] -= (sidemod*0.04 + 0.02);
2589 c[2] -= (sidemod*0.04 + 0.02);
2590
2591 if (c[0] < 0)
2592 c[0] = 0;
2593 if (c[1] < 0)
2594 c[1] = 0;
2595 if (c[2] < 0)
2596 c[2] = 0;
2597
2598 glColor3fv(c);
2599
2600 glBegin(GL_TRIANGLES);
2601 glVertex3fv(insidecorner[2]);
2602 glVertex3fv(insidecorner[3]);
2603 glVertex3fv(insidecorner[1]);
2604 glEnd();
2605 }
2606
2607 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2608
drawWater(int shape,int itsChristmas)2609 void drawWater(int shape, int itsChristmas)
2610 {
2611 switch(shape){
2612 case 0: drawLake0(itsChristmas);
2613 break;
2614
2615 case 1: drawLake1(itsChristmas); /* |/ */
2616 break;
2617
2618 case 2: glRotatef(-90, 0, 1, 0); /* \| */
2619 drawLake1(itsChristmas);
2620 break;
2621
2622 case 3: glRotatef(-180, 0, 1, 0); /* /| */
2623 drawLake1(itsChristmas);
2624 break;
2625
2626 case 4: glRotatef(90, 0, 1, 0); /* |\ */
2627 drawLake1(itsChristmas);
2628 break;
2629 }
2630 }
2631
2632 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2633
drawHills(int shape,int itsChristmas)2634 void drawHills(int shape, int itsChristmas)
2635 {
2636 switch(shape){
2637 case 0: drawHill0(itsChristmas);
2638 break;
2639
2640 case 1: drawHill1(0, itsChristmas); /* up neg Z */
2641 break;
2642
2643 case 2: glRotatef(-90, 0, 1, 0); /* up pos x */
2644 drawHill1(1, itsChristmas);
2645 break;
2646
2647 case 3: glRotatef(-180, 0, 1, 0); /* up pos z */
2648 drawHill1(2, itsChristmas);
2649 break;
2650
2651 case 4: glRotatef(90, 0, 1, 0); /* up neg x */
2652 drawHill1(1, itsChristmas);
2653 break;
2654
2655
2656 case 5: drawHill2(0, itsChristmas); /* +x,+z corner */
2657 break;
2658
2659 case 6: glRotatef(-90, 0, 1, 0); /* up pos x */
2660 drawHill2(0, itsChristmas);
2661 break;
2662
2663 case 7: glRotatef(-180, 0, 1, 0); /* up pos z */
2664 drawHill2(1, itsChristmas);
2665 break;
2666
2667 case 8: glRotatef(90, 0, 1, 0); /* up neg x */
2668 drawHill2(1, itsChristmas);
2669 break;
2670
2671
2672 case 9: drawHill3(0, itsChristmas); /* up +x,-z */
2673 break;
2674
2675 case 10: glRotatef(-90, 0, 1, 0); /* up +x,+z */
2676 drawHill3(0, itsChristmas);
2677 break;
2678
2679 case 11: glRotatef(-180, 0, 1, 0); /* up pos z */
2680 drawHill3(1, itsChristmas);
2681 break;
2682
2683 case 12: glRotatef(90, 0, 1, 0); /* up neg x */
2684 drawHill3(1, itsChristmas);
2685 break;
2686
2687 }
2688 }
2689
2690
2691 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2692 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2693 /* draw all structures on plane (buildings,trees,hills,lakes) */
2694 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
2695
drawtrees(struct tree * allTreesOnPlane,int numTreesOnPlane,int counter,int detail,int itsChristmas,int view)2696 void drawtrees(struct tree * allTreesOnPlane, int numTreesOnPlane, int counter,
2697 int detail, int itsChristmas, int view)
2698 {
2699
2700 float spheredat[4];
2701 float x, y, z;
2702 register int treeCounter;
2703 int sph;
2704 GLfloat lineWidthNow;
2705 GLint shadeNow;
2706
2707 glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
2708
2709 if (detail >= 2)
2710 sph = 5;
2711 else if (detail == 1)
2712 sph = 4;
2713 else
2714 sph = 2;
2715
2716
2717 for (treeCounter=0; treeCounter < numTreesOnPlane; treeCounter++)
2718 {
2719 if (detail >= 2)
2720 glShadeModel(GL_SMOOTH);
2721 else
2722 glShadeModel(GL_FLAT);
2723
2724
2725 if (((fabs(allTreesOnPlane[treeCounter].x) <= PLANESIZE) && (fabs(allTreesOnPlane[treeCounter].z) <= PLANESIZE)) || (view == MAPVIEW))
2726 {
2727 x = allTreesOnPlane[treeCounter].x;
2728 y = allTreesOnPlane[treeCounter].y;
2729 z = allTreesOnPlane[treeCounter].z;
2730
2731 /**********************************/
2732 /* tree */
2733 /**********************************/
2734
2735 if (allTreesOnPlane[treeCounter].type == 0)
2736 {
2737 if ((allTreesOnPlane[treeCounter].treeshape == 0) || (itsChristmas))
2738 {
2739 /*************/
2740 /* pine tree */
2741 /*************/
2742
2743 if (detail >= 2)
2744 {
2745 glCallList(treeWood);
2746
2747 glEnable(GL_TEXTURE_2D);
2748 }
2749
2750
2751 makercubenobtmnotopTEX( x, y+0.2, z, 0.075, 0.2, 0.075, colorbrown);
2752 glDisable(GL_TEXTURE_2D);
2753
2754 /* regular pine tree colour is too dark in vector mode */
2755
2756 if (detail > -1)
2757 makeitPyr(1, treeColor, x, y+0.8, z, 0.2, 0.4, 0.2);
2758 else
2759 makeitPyr(1, treeColor2, x, y+0.8, z, 0.2, 0.4, 0.2);
2760
2761 glColor4fv(colorblack);
2762
2763 if (detail > 0)
2764 shadow(x, z, 0.2, 0.2);
2765
2766 if (itsChristmas)
2767 {
2768 makercube( x+0.09, y+0.9, z+0.09, 0.025, 0.025, 0.025, coloryellow);
2769 makercube( x-0.12, y+0.7, z+0.12, 0.025, 0.025, 0.025, colorred);
2770 makercube( x-0.1, y+0.9, z-0.1, 0.025, 0.025, 0.025, colormaserblue);
2771 makercube( x+0.12, y+0.7, z-0.12, 0.025, 0.025, 0.025, colororange);
2772 }
2773 }
2774 else
2775 /**************/
2776 /* round tree */
2777 /**************/
2778 {
2779 if (detail >= 2)
2780 {
2781 glCallList(treeWood);
2782
2783 glEnable(GL_TEXTURE_2D);
2784 }
2785
2786 makercubenobtmnotopTEX(x, y+0.4, z, 0.1, 0.4, 0.1, colorbrown);
2787 glDisable(GL_TEXTURE_2D);
2788
2789 glColor3fv(treeColor2);
2790 spheredat[0] = x;
2791 spheredat[1] = y+1;
2792 spheredat[2] = z;
2793 spheredat[3] = 0.3;
2794 andysphdraw(spheredat, sph);
2795
2796 if (detail > 0)
2797 {
2798 glPushMatrix();
2799 glColor3fv(colorblack);
2800 glTranslatef(x, SHADOWS, z);
2801 glCallList(roundTreeShadow);
2802 glPopMatrix();
2803 }
2804 }
2805 }
2806
2807 /**********************************/
2808 /* building */
2809 /**********************************/
2810
2811 if (allTreesOnPlane[treeCounter].type == 1)
2812 {
2813 glPushMatrix();
2814
2815 glTranslatef(x, y, z);
2816
2817 if (allTreesOnPlane[treeCounter].treeshape <= 17)
2818 switch(allTreesOnPlane[treeCounter].treeshape){
2819 case 0: drawBuilding0(colorwhite, detail);
2820 break;
2821 case 1: if (detail == 0)
2822 glCallList(building1ObjD0);
2823 else
2824 glCallList(building1Obj);
2825 break;
2826 case 2: if (detail == 0)
2827 glCallList(building2ObjD0);
2828 else
2829 glCallList(building2Obj);
2830 break;
2831 case 3: glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
2832 if (allTreesOnPlane[treeCounter].deathCount && allTreesOnPlane[treeCounter].death2)
2833 drawTower(allTreesOnPlane[treeCounter].deathCount, allTreesOnPlane[treeCounter].death2);
2834 else
2835 glCallList(powerTower);
2836 glLineWidth(lineWidthNow);
2837 break;
2838 case 4: glPushAttrib(GL_LIGHTING_BIT);
2839 if (detail <= 0)
2840 {
2841 glShadeModel(GL_FLAT);
2842 drawCoolingTower(detail);
2843 }
2844 else
2845 {
2846 glShadeModel(GL_SMOOTH);
2847 drawCoolingTower(detail); /* cooling tower */
2848 }
2849 glPopAttrib();
2850 break;
2851 case 5: if (detail == 0) /* home */
2852 glCallList(building5ObjD0);
2853 else
2854 glCallList(building5Obj);
2855 break;
2856 case 6: drawBuilding6(counter, colorred, coloryellow, detail); /* fast food */
2857 break;
2858 case 7: glCallList(building7Obj);
2859 break;
2860 case 8: drawBuilding8(colorbeige, colorbrown, detail);
2861 break;
2862 case 9: glPushAttrib(GL_LIGHTING_BIT);
2863 if (detail < 0)
2864 {
2865 glShadeModel(GL_FLAT);
2866 glCallList(building9ObjOO);
2867 }
2868 else if (detail == 0)
2869 {
2870 glShadeModel(GL_FLAT);
2871 glCallList(building9Obj);
2872 }
2873 else
2874 {
2875 glShadeModel(GL_SMOOTH);
2876 glCallList(building9Obj); /*water tower*/
2877 }
2878 glPopAttrib();
2879 break;
2880 case 10: glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
2881 glCallList(building10Obj);
2882 glLineWidth(lineWidthNow);
2883 break;
2884 case 11: glPushAttrib(GL_LIGHTING_BIT);
2885 if (detail <= 0)
2886 glShadeModel(GL_FLAT);
2887 else
2888 glShadeModel(GL_SMOOTH);
2889 drawBuilding11(detail); /* factory smokestacks*/
2890 glPopAttrib();
2891 break;
2892 case 12: if (detail == 0)
2893 glCallList(building12ObjD0);
2894 else
2895 glCallList(building12Obj);
2896 break;
2897 case 13: glRotatef(180, 0, 1, 0);
2898 if (detail == 0)
2899 glCallList(building5ObjD0);
2900 else
2901 glCallList(building5Obj);
2902 break;
2903 case 14: glCallList(building14Obj);
2904 break;
2905 case 15: glCallList(strip1Obj); /* strip mall */
2906 break;
2907 case 16: glCallList(strip2Obj); /* strip mall */
2908 break;
2909 case 17: glCallList(strip3Obj); /* strip mall */
2910 break;
2911 }
2912 else
2913 switch(allTreesOnPlane[treeCounter].treeshape){
2914 case 18: glRotatef(90, 0, 1, 0);
2915 drawBuilding0(colorgrey1, detail);
2916 break;
2917 case 19: if (detail == 0)
2918 glCallList(building19ObjD0);
2919 else
2920 glCallList(building19Obj);
2921 break;
2922 case 20: if (detail == 0)
2923 glCallList(building20ObjD0);
2924 else
2925 glCallList(building20Obj);
2926 break;
2927 case 21: if (detail == 0)
2928 glCallList(building21ObjD0);
2929 else
2930 glCallList(building21Obj);
2931 break;
2932 case 22: drawBuilding22(colorgrey1);
2933 break;
2934 case 23: drawBuilding22(colorgrey2);
2935 break;
2936 case 24: drawBuilding22(colorwhite);
2937 break;
2938 case 25: drawBuilding25();
2939 break;
2940 case 26: drawBuilding26(0, detail);
2941 break;
2942 case 27: drawBuilding26(1, detail);
2943 break;
2944 case 28: glRotatef(-90, 0, 1, 0);
2945 drawBuilding6(counter, colorgrey2, colorblue, detail);
2946 break;
2947 case 29: drawBuilding29(itsChristmas, detail);
2948 break;
2949 case 30: drawBuilding8(colorbeige, colorgrey2, detail);
2950 break;
2951 case 31: glCallList(building31Obj); /* maser battery */
2952 break;
2953 case 32: glCallList(building32Obj); /* helo pad */
2954 break;
2955 case 33: drawBuilding33(allTreesOnPlane[treeCounter].deathCount, detail); /* hero entrance */
2956 break;
2957 case 34: drawBuilding34(colorblue2); /* smallest office building */
2958 break;
2959 case 36: drawBuilding36(colorblue2); /* small office building */
2960 break;
2961 case 37: drawBuilding37(colorblue2, detail);
2962 break;
2963 default: showError("Bogus Building in Tree List! (drawtrees)");
2964 break;
2965 }
2966
2967 glPopMatrix();
2968 }
2969
2970 /**********************************/
2971 /* water */
2972 /**********************************/
2973
2974 if (allTreesOnPlane[treeCounter].type == 2)
2975 {
2976 glPushMatrix();
2977 glTranslatef(x, ROADS, z);
2978
2979 drawWater(allTreesOnPlane[treeCounter].treeshape, itsChristmas);
2980
2981 glPopMatrix();
2982 }
2983
2984 /**********************************/
2985 /* hills */
2986 /**********************************/
2987
2988 if (allTreesOnPlane[treeCounter].type == 3)
2989 {
2990 glPushMatrix();
2991 glTranslatef(x, PLANEY, z);
2992 drawHills(allTreesOnPlane[treeCounter].treeshape, itsChristmas);
2993 glPopMatrix();
2994 }
2995 }
2996 }
2997 glShadeModel(shadeNow);
2998 }
2999
3000
3001 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3002 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3003 /* draw all tanks currently dying */
3004 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3005
drawSlagTanks(struct tank * allSlags,int counter,int detail)3006 void drawSlagTanks(struct tank * allSlags, int counter, int detail)
3007 {
3008 int c;
3009 float angle2;
3010 struct tank * ttank;
3011
3012 for(ttank = allSlags->next;ttank != NULL;ttank = ttank->next)
3013 {
3014 if ((fabs(ttank->x) <= PLANESIZE) && (fabs(ttank->z) <= PLANESIZE))
3015 {
3016 angle2 = ttank->theta * RAD_TO_SMALL_DEG;
3017
3018 c = ttank->count;
3019
3020 glPushMatrix();
3021
3022 switch(ttank->type){
3023 case TANK: glTranslatef(ttank->x, ttank->y-0.015, ttank->z);
3024 glScalef(1+0.015*c, 1-0.015*c, 1+0.015*c);
3025 glRotatef(angle2, 0, 1, 0);
3026 glCallList(slagtank);
3027 break;
3028
3029 case LAUNCHER: glTranslatef(ttank->x, ttank->y-0.015, ttank->z);
3030 glScalef(1+0.015*c, 1-0.015*c, 1+0.015*c);
3031 glRotatef(angle2, 0, 1, 0);
3032 glCallList(slaglaunchertank);
3033 break;
3034
3035
3036 case MASERTANK: glTranslatef(ttank->x, ttank->y-0.015, ttank->z);
3037 glScalef(0.15+0.002*c, 0.15-0.004*c, 0.15+0.002*c);
3038 glRotatef(angle2, 0, 1, 0);
3039 glCallList(slagmasertank);
3040 break;
3041
3042 case HELO: glTranslatef(ttank->x, ttank->y, ttank->z);
3043 glRotatef(c*4.0, 1, 0, 0);
3044 glRotatef(c*1.5, 0, 0, 1);
3045 glRotatef(angle2+180+(c*10), 0, 1, 0);
3046 drawHelo((counter*9) % 360, 1);
3047 break;
3048
3049 case CHH: glTranslatef(ttank->x, ttank->y, ttank->z);
3050 glRotatef(c*4.0, 1, 0, 0);
3051 glRotatef(c*1.5, 0, 0, 1);
3052 glRotatef(angle2+(c*10), 0, 1, 0);
3053 makeCHH(0);
3054 break;
3055
3056 case MECHAG: glTranslatef(ttank->x, 0, ttank->z);
3057 glRotatef(angle2, 0, 1, 0);
3058 drawMechaMonster(0, counter, detail);
3059 break;
3060
3061 case HERO: glTranslatef(ttank->x, 0, ttank->z);
3062 glRotatef(angle2, 0, 1, 0);
3063 if (ttank->subtype == 0)
3064 drawHeroDude(0, ttank->walking, ttank->maserCount, c, detail);
3065 else
3066 drawHeroDude2(0, ttank->walking, ttank->maserCount, c, detail);
3067 break;
3068
3069 case AIRPLANE: glTranslatef(ttank->x, ttank->y, ttank->z);
3070 glRotatef(c*1.5, 0, 0, 1);
3071 glRotatef(angle2+180+(c*10), 0, 1, 0);
3072 glScalef(3, 3, 3);
3073 drawAirplane((counter*2) % 360);
3074 break;
3075
3076 case FIGHTER: glTranslatef(ttank->x, ttank->y, ttank->z);
3077 glRotatef(c*1.5, 0, 0, 1);
3078 glRotatef(angle2+180+(c*10), 0, 1, 0);
3079 glScalef(2, 2, 2);
3080 drawFighter();
3081 break;
3082
3083 default: showError("Bogus Vehicle in Tank List! (drawSlagTanks)");
3084 break;
3085 }
3086
3087 glPopMatrix();
3088 }
3089 }
3090 }
3091
3092 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3093 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3094 /* draw maser beams */
3095 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3096
drawMaser(float sourceX,float sourceY,float sourceZ,int shooter,float mX,float mZ,float mHeight,float mBottom,float r1,float r2,float r3,int width,int view,int detail)3097 void drawMaser(float sourceX, float sourceY, float sourceZ,
3098 int shooter, float mX, float mZ, float mHeight, float mBottom,
3099 float r1, float r2, float r3, int width, int view, int detail)
3100
3101 {
3102 float beamLoc1[3], beamLoc2[3];
3103 GLfloat lineWidthNow;
3104
3105 beamLoc1[0] = sourceX;
3106 beamLoc1[1] = sourceY;
3107 beamLoc1[2] = sourceZ;
3108
3109 beamLoc2[0] = mX + r1;
3110 beamLoc2[1] = 0.5 * (mHeight - mBottom) + mBottom + r2;
3111 beamLoc2[2] = mZ + r3;
3112
3113 glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
3114
3115 /* if line widths are integral Mesa chokes in a large window */
3116 if ((view == MONSTERVIEW) || (view == ARMYVIEW))
3117 glLineWidth(width * 0.0057);
3118 else
3119 glLineWidth(width * 0.0029);
3120
3121
3122 glColor3fv(colorwhite);
3123
3124 glBegin(GL_LINES);
3125 glVertex3fv(beamLoc1);
3126 glVertex3fv(beamLoc2);
3127
3128 glEnd();
3129
3130
3131 switch(shooter)
3132 {
3133 case MASERTANK: glColor3fv(colormaserblue);
3134 break;
3135
3136 case CHH: glColor3fv(colormaseryellow);
3137 break;
3138
3139 case MECHAG: glColor3fv(colorred);
3140 break;
3141
3142 default: showError("Invalid Vehicle Type (drawMaser)");
3143 break;
3144 }
3145
3146 if (detail != -1)
3147 glEnable(GL_BLEND);
3148
3149 /* if line widths are integral Mesa chokes in a large window */
3150 if ((view == MONSTERVIEW) || (view == ARMYVIEW))
3151 glLineWidth(width * 0.011);
3152 else
3153 glLineWidth(width * 0.0057);
3154
3155 glBegin(GL_LINES);
3156
3157 glVertex3fv(beamLoc1);
3158 glVertex3fv(beamLoc2);
3159 glEnd();
3160
3161 glDisable(GL_BLEND);
3162
3163 glLineWidth(lineWidthNow);
3164 }
3165
3166 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3167 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3168 /* draw all tanks on the battlefield */
3169 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3170
drawTanks(struct tank * allTanks,int counter,struct monsterInfo G,struct targetInfo * targs,int detail,int view,int wid)3171 void drawTanks(struct tank * allTanks, int counter, struct monsterInfo G,
3172 struct targetInfo * targs, int detail, int view, int wid)
3173
3174 {
3175 struct tank cTank;
3176 struct tank * temptank;
3177 float angle2;
3178 int monsterIsDead;
3179 float height, bottom;
3180 float xloc, zloc;
3181 float radToNearestTarget, rad;
3182 struct targetInfo * nearestTarget;
3183 struct monsterInfo * nearestMonster;
3184 struct targetInfo * temptarget;
3185
3186
3187 for(temptank = allTanks->next;temptank != NULL;temptank = temptank->next)
3188 {
3189 cTank = *temptank;
3190
3191 if (((fabs(cTank.x) <= PLANESIZE) && (fabs(cTank.z) <= PLANESIZE)) || (view == MAPVIEW))
3192 {
3193
3194
3195 /* need to find the nearest target */
3196
3197 radToNearestTarget = 10000;
3198 nearestTarget = NULL;
3199 for(temptarget = targs->next;temptarget != NULL;temptarget = temptarget->next)
3200 {
3201 rad = sqrt((cTank.x-temptarget->x) * (cTank.x-temptarget->x) + (cTank.z-temptarget->z) * (cTank.z-temptarget->z));
3202 if (rad < radToNearestTarget)
3203 {
3204 radToNearestTarget = rad;
3205 nearestTarget = temptarget;
3206 nearestMonster = &(temptarget->monster);
3207 }
3208 }
3209
3210 /* need to compute radius to player's monster */
3211
3212 rad = sqrt(cTank.x * cTank.x + cTank.z * cTank.z);
3213
3214 if (rad < radToNearestTarget)
3215 {
3216 radToNearestTarget = rad;
3217 nearestMonster = NULL;
3218 nearestTarget = NULL;
3219 }
3220
3221 if (nearestMonster == NULL)
3222 {
3223 monsterIsDead = G.monsterIsDead;
3224 height = G.height;
3225 bottom = G.bottom;
3226 xloc = 0;
3227 zloc = 0;
3228 }
3229 else
3230 {
3231 monsterIsDead = nearestMonster->monsterIsDead;
3232 height = nearestMonster->height;
3233 bottom = nearestMonster->bottom;
3234 xloc = nearestTarget->x;
3235 zloc = nearestTarget->z;
3236 }
3237
3238
3239 /**********************************/
3240 /* aim vehicle */
3241 /**********************************/
3242
3243 angle2 = cTank.theta * RAD_TO_SMALL_DEG;
3244
3245 /**********************************/
3246 /* draw vehicle */
3247 /**********************************/
3248
3249 glPushMatrix();
3250
3251 switch (cTank.type)
3252 {
3253 case TANK: glTranslatef(cTank.x, cTank.y, cTank.z);
3254 glRotatef(angle2, 0, 1, 0);
3255 glCallList(plaintank);
3256 break;
3257
3258 case LAUNCHER: glTranslatef(cTank.x, cTank.y, cTank.z);
3259 glRotatef(angle2, 0, 1, 0);
3260 glCallList(launchertank);
3261 break;
3262
3263 case MASERTANK: glTranslatef(cTank.x, cTank.y, cTank.z);
3264 glRotatef(angle2, 0, 1, 0);
3265 glScalef(0.15, 0.15, 0.15);
3266 glCallList(masertank);
3267 break;
3268
3269 case HELO: glTranslatef(cTank.x, cTank.y, cTank.z);
3270 glRotatef(angle2+180, 0, 1, 0);
3271 drawHelo((counter*9) % 360, 0);
3272 break;
3273
3274 case AIRPLANE: glTranslatef(cTank.x, cTank.y, cTank.z);
3275 glRotatef(angle2+180, 0, 1, 0);
3276 glScalef(3, 3, 3);
3277 drawAirplane((counter*2) % 360);
3278 break;
3279
3280 case FIGHTER: glTranslatef(cTank.x, cTank.y, cTank.z);
3281 glRotatef(angle2+180, 0, 1, 0);
3282 glScalef(2, 2, 2);
3283 drawFighter();
3284 break;
3285
3286 case CHH: glTranslatef(cTank.x, cTank.y, cTank.z);
3287 glRotatef(angle2, 0, 1, 0);
3288 makeCHH(cTank.damage);
3289 break;
3290
3291 case MECHAG: glTranslatef(cTank.x, 0, cTank.z);
3292 glRotatef(angle2, 0, 1, 0);
3293 drawMechaMonster(cTank.damage, counter, detail);
3294 break;
3295
3296 case HERO: glTranslatef(cTank.x, 0, cTank.z);
3297 glRotatef(angle2, 0, 1, 0);
3298 if (cTank.subtype == 0)
3299 drawHeroDude(cTank.damage, cTank.walking, cTank.maserCount, 0, detail);
3300 else
3301 drawHeroDude2(cTank.damage, cTank.walking, cTank.maserCount, 0, detail);
3302 break;
3303
3304 default: showError("Bogus Vehicle in Tank List! (drawTanks)");
3305 break;
3306 }
3307
3308 glPopMatrix();
3309
3310 if (detail > 0)
3311 {
3312
3313 /**********************************/
3314 /* draw shadow */
3315 /**********************************/
3316
3317 glPushMatrix();
3318 glTranslatef(cTank.x, 0, cTank.z);
3319 glRotatef(angle2, 0, 1, 0);
3320
3321 switch (cTank.type){
3322 case TANK:
3323 case LAUNCHER:
3324 case MASERTANK: glCallList(tankShadow);
3325 break;
3326
3327 case HELO: glColor4fv(colorblack);
3328 shadow (0, 0, 0.14, 0.18);
3329 shadow (0, -0.22, 0.04, 0.1);
3330 break;
3331
3332 case MECHAG: break;
3333
3334 case CHH: glColor4fv(colorblack);
3335 shadow (0, 0, 0.14, 0.22);
3336 break;
3337
3338 case HERO: glColor4fv(colorblack);
3339 shadow (0, 0, 0.12, 0.08);
3340 break;
3341
3342 case AIRPLANE: glCallList(planeShadow);
3343 break;
3344
3345 case FIGHTER: glCallList(fighterShadow);
3346 break;
3347
3348 default: showError("Bogus Vehicle in Tank List! (drawTanks)");
3349 break;
3350 }
3351 glPopMatrix();
3352 }
3353
3354 if ((cTank.maserCount > 0) && (cTank.rad <= cTank.range) && (cTank.rad >= 0.5) && (!monsterIsDead))
3355 {
3356 /**********************************/
3357 /* mechaGoogelon firing maser */
3358 /**********************************/
3359
3360 if (cTank.type == MECHAG)
3361 drawMaser(cTank.x, cTank.y + 0.8, cTank.z, cTank.type, xloc, zloc, height,
3362 bottom, cTank.rand1, cTank.rand2, cTank.rand3, wid, view, detail);
3363
3364 /**********************************/
3365 /* 009CHH firing maser */
3366 /**********************************/
3367
3368 if (cTank.type == CHH)
3369 drawMaser(cTank.x, cTank.y, cTank.z, cTank.type, xloc, zloc, height,
3370 bottom, cTank.rand1, cTank.rand2, cTank.rand3, wid, view, detail);
3371
3372 /**********************************/
3373 /* tank firing maser */
3374 /**********************************/
3375
3376 if (cTank.type == MASERTANK)
3377 drawMaser(cTank.x, cTank.y + 0.375, cTank.z, cTank.type, xloc, zloc, height,
3378 bottom, cTank.rand1, cTank.rand2, cTank.rand3, wid, view, detail);
3379
3380 /**********************************/
3381 /* hero firing its weapon */
3382 /**********************************/
3383
3384 if ((cTank.type == HERO) && (cTank.subtype == 1) && (cTank.maserCount > 10) && (cTank.maserCount < 30))
3385 if (nearestTarget)
3386 drawHeroWeapon(nearestTarget->x, nearestTarget->z, cTank.x, cTank.y + 0.275, cTank.z, colormaserblue, height, bottom);
3387 else
3388 drawHeroWeapon(0, 0, cTank.x, cTank.y + 0.275, cTank.z, colormaserblue, height, bottom);
3389
3390 }
3391 }
3392 }
3393 }
3394
3395
3396 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3397 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3398 /* draw hero energy beam */
3399 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3400
drawHeroWeapon(float targetx,float targetz,float x,float y,float z,float * color,float height,float bottom)3401 void drawHeroWeapon(float targetx, float targetz, float x, float y,
3402 float z, float * color, float height, float bottom)
3403 {
3404 float loc1[3], loc2[3];
3405 float rad, angle, r;
3406 float midPoint;
3407 GLboolean backNow;
3408
3409 GLint shadeNow;
3410
3411 glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
3412 backNow = glIsEnabled(GL_CULL_FACE);
3413
3414 rad = sqrt(x * x + z * z);
3415
3416 if (rad == 0)
3417 rad = NEARZERO;
3418
3419 r = 0.16 / rad;
3420
3421 if (z == 0)
3422 z = NEARZERO;
3423
3424 angle = atan(x / z);
3425
3426 if (z > 0)
3427 angle += PI;
3428
3429 angle += PI;
3430
3431 midPoint = 0.5 * (height - bottom) + bottom;
3432
3433 glShadeModel(GL_SMOOTH);
3434 glDisable(GL_CULL_FACE);
3435
3436 glBegin(GL_QUADS);
3437 glColor3fv(color);
3438 loc1[0] = (rad - 0.22) * sin(angle + r);
3439 loc1[1] = y;
3440 loc1[2] = (rad - 0.22) * cos(angle + r);
3441 glVertex3fv(loc1);
3442
3443 loc1[0] = (rad - 0.22) * sin(angle - r);
3444 loc1[2] = (rad - 0.22) * cos(angle - r);
3445 glVertex3fv(loc1);
3446
3447 glColor3fv(colorwhite);
3448 loc2[0] = targetx - 0.04;
3449 loc2[2] = targetz - 0.04;
3450 loc2[1] = midPoint;
3451 glVertex3fv(loc2);
3452
3453 loc2[0] = targetx + 0.04;
3454 loc2[2] = targetz + 0.04;
3455 glVertex3fv(loc2);
3456 glEnd();
3457
3458 /* make beam viewable from side */
3459
3460 glBegin(GL_QUADS);
3461 glColor3fv(color);
3462 loc1[0] = (rad - 0.22) * sin(angle);
3463 loc1[1] = y + 0.03;
3464 loc1[2] = (rad - 0.22) * cos(angle);
3465 glVertex3fv(loc1);
3466
3467 loc1[1] = y - 0.03;
3468 glVertex3fv(loc1);
3469
3470 glColor3fv(colorwhite);
3471 loc2[0] = targetx;
3472 loc2[2] = targetz;
3473 loc2[1] = midPoint - 0.02;
3474 glVertex3fv(loc2);
3475
3476 loc2[1] = midPoint + 0.02;
3477 glVertex3fv(loc2);
3478 glEnd();
3479
3480 if (backNow)
3481 glEnable(GL_CULL_FACE);
3482 else
3483 glDisable(GL_CULL_FACE);
3484
3485 glShadeModel(shadeNow);
3486 }
3487
3488 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3489
makeBooms()3490 void makeBooms()
3491 {
3492 int counter;
3493 GLuint O;
3494
3495 float spheredat[4];
3496 spheredat[0] = 0;
3497 spheredat[1] = 0;
3498 spheredat[2] = 0;
3499
3500 for(counter=1;counter<=10;counter++)
3501 {
3502 O = glGenLists(1);
3503 glNewList(O, GL_COMPILE);
3504
3505 spheredat[3] = 0.03 * counter;
3506
3507 andysphdraw(spheredat, 3);
3508
3509 glEndList();
3510
3511 switch(counter)
3512 {
3513 case 1: boom1Obj = O;
3514 break;
3515 case 2: boom2Obj = O;
3516 break;
3517 case 3: boom3Obj = O;
3518 break;
3519 case 4: boom4Obj = O;
3520 break;
3521 case 5: boom5Obj = O;
3522 break;
3523 case 6: boom6Obj = O;
3524 break;
3525 case 7: boom7Obj = O;
3526 break;
3527 case 8: boom8Obj = O;
3528 break;
3529 case 9: boom9Obj = O;
3530 break;
3531 case 10: boom10Obj = O;
3532 break;
3533 }
3534
3535 /* Build smaller booms for detail level 0 */
3536
3537 O = glGenLists(1);
3538 glNewList(O, GL_COMPILE);
3539
3540 spheredat[3] = 0.02 * counter;
3541
3542 andysphdraw(spheredat, 1);
3543
3544 glEndList();
3545
3546 switch(counter)
3547 {
3548 case 1: boom1ObjD0 = O;
3549 break;
3550 case 2: boom2ObjD0 = O;
3551 break;
3552 case 3: boom3ObjD0 = O;
3553 break;
3554 case 4: boom4ObjD0 = O;
3555 break;
3556 case 5: boom5ObjD0 = O;
3557 break;
3558 case 6: boom6ObjD0 = O;
3559 break;
3560 case 7: boom7ObjD0 = O;
3561 break;
3562 case 8: boom8ObjD0 = O;
3563 break;
3564 case 9: boom9ObjD0 = O;
3565 break;
3566 case 10: boom10ObjD0 = O;
3567 break;
3568 }
3569 }
3570 }
3571
3572
3573 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3574 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3575 /* draw explosions */
3576 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3577
drawBooms(struct boom * boomers,int detail)3578 void drawBooms(struct boom * boomers, int detail)
3579 {
3580 struct boom * tempboom;
3581 struct boom b;
3582
3583 if (detail >= 2)
3584 glEnable(GL_BLEND);
3585
3586 glColor3fv(coloryellow);
3587
3588 for(tempboom = boomers->next;tempboom != NULL;tempboom = tempboom->next)
3589 {
3590 b = *tempboom;
3591
3592 if (detail >= 2)
3593 {
3594 coloryellow[3] = (11 - b.count) * 0.1;
3595 glColor4fv(coloryellow);
3596 }
3597
3598 glPushMatrix();
3599 glTranslatef(b.x, b.y, b.z);
3600
3601 if (detail == 0) {
3602 /* Draw smaller 'flickering' explosions (Johan) */
3603
3604 switch(b.count) {
3605 case 1: glCallList(boom1ObjD0);
3606 break;
3607 case 3: glCallList(boom3ObjD0);
3608 break;
3609 case 5: glCallList(boom5ObjD0);
3610 break;
3611 case 7: glCallList(boom7ObjD0);
3612 break;
3613 case 9: glCallList(boom9ObjD0);
3614 break;
3615 }
3616
3617 } else {
3618
3619 switch(b.count) {
3620 case 1: glCallList(boom1Obj);
3621 break;
3622 case 2: glCallList(boom2Obj);
3623 break;
3624 case 3: glCallList(boom3Obj);
3625 break;
3626 case 4: glCallList(boom4Obj);
3627 break;
3628 case 5: glCallList(boom5Obj);
3629 break;
3630 case 6: glCallList(boom6Obj);
3631 break;
3632 case 7: glCallList(boom7Obj);
3633 break;
3634 case 8: glCallList(boom8Obj);
3635 break;
3636 case 9: glCallList(boom9Obj);
3637 break;
3638 case 10: glCallList(boom10Obj);
3639 break;
3640 }
3641 }
3642 glPopMatrix();
3643 }
3644
3645 if (detail >= 2)
3646 glDisable(GL_BLEND);
3647 }
3648
3649 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3650 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3651 /* draw googelon/Flutter's energy beam */
3652 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3653
drawBeam(float x,float z,int horz,int vert,int monsterName,int detail)3654 void drawBeam(float x, float z, int horz, int vert, int monsterName,
3655 int detail)
3656 {
3657 float loc1[3], loc2[3], loc3[3];
3658 float c[4] = {0, 0, 0, 0};
3659 float * col;
3660 float R;
3661 register int i, nlines;
3662 GLfloat lineWidthNow;
3663
3664 GLint shadeNow;
3665
3666 glGetIntegerv(GL_SHADE_MODEL, &shadeNow);
3667
3668 glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
3669
3670 if (monsterName == FLUTTER)
3671 col = colororange;
3672 else
3673 col = colorblue;
3674
3675
3676 /**********************************/
3677 /* draw beam */
3678 /**********************************/
3679
3680 /* if line widths are integral Mesa chokes in a large window */
3681 glLineWidth(5.01);
3682
3683 if (vert < 175)
3684 R = 4;
3685 else
3686 R = 1.2 / (cos((900 - vert) * BIG_DEG_TO_RAD));
3687
3688 if (R < 0)
3689 R = 0;
3690 if (R > 4)
3691 R = 4;
3692
3693 if (vert < 0)
3694 loc3[1] = PLANEY + 1.2 + R * sin(fabs(vert * BIG_DEG_TO_RAD));
3695 else
3696 loc3[1] = PLANEY + 1.2 - R * sin(fabs(vert * BIG_DEG_TO_RAD));
3697
3698 loc1[0] = x;
3699 loc1[2] = z;
3700 loc1[1] = PLANEY + 1.2;
3701
3702 /* this doesnt really work ... beam has xz value of 4 no matter what y is (> plane)
3703 * so beam will be longer than 4 as it gets higher up in the sky
3704 */
3705
3706 loc3[0] = x+R * -cos((900 + horz) * BIG_DEG_TO_RAD);
3707 loc3[2] = z+R * sin((900 + horz) * BIG_DEG_TO_RAD);
3708
3709 if (loc3[1] < PLANEY)
3710 loc3[1] = PLANEY;
3711
3712 if (monsterName == FLUTTER)
3713 c[0] = 0.95;
3714 else
3715 c[2] = 0.95;
3716
3717 switch (detail)
3718 {
3719 case -1:
3720 case 0: nlines = 4;
3721 break;
3722
3723 case 1: nlines = 25;
3724 glShadeModel(GL_SMOOTH);
3725 break;
3726
3727 case 2: nlines = 40;
3728 glShadeModel(GL_SMOOTH);
3729 break;
3730 }
3731
3732
3733 for (i = 0; i < nlines; i++)
3734 {
3735 loc2[0] = loc3[0] + randy(0.04);
3736 loc2[1] = loc3[1] + randy(0.04);
3737 loc2[2] = loc3[2] + randy(0.04);
3738
3739 c[1] = 0.5 + randy(0.5);
3740
3741 glBegin(GL_LINES);
3742 glColor3fv(c);
3743 glVertex3fv(loc2);
3744 glColor3fv(col);
3745 glVertex3fv(loc1);
3746 glEnd();
3747 }
3748
3749 glShadeModel(shadeNow);
3750
3751 if (detail > 0)
3752 {
3753 /**********************************/
3754 /* shadow of beam */
3755 /**********************************/
3756
3757 glColor3fv(colorblack);
3758 loc1[1] = SHADOWS;
3759 loc3[1] = SHADOWS;
3760
3761 glBegin(GL_LINES);
3762 glVertex3fv(loc1);
3763 glVertex3fv(loc3);
3764 glEnd();
3765 }
3766
3767 glLineWidth(lineWidthNow);
3768 }
3769
3770
3771 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3772 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3773 /* draw roads on the battlefield */
3774 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
3775
drawRoads(struct road * roads,float xshift,float zshift,int itsChristmas,int view,int detail)3776 void drawRoads(struct road * roads, float xshift, float zshift,
3777 int itsChristmas, int view, int detail)
3778 {
3779 register int i;
3780 float displaySize;
3781 float square[4][3];
3782 float v1[3];
3783 float v2[3];
3784 float v3[3];
3785 float v4[3];
3786 float xplus, xminus, zplus, zminus;
3787 int ropCounter;
3788
3789 static float tv1[2] = {0,1};
3790 static float tv2[2] = {1,1};
3791 static float tv3[2] = {1,0};
3792 static float tv4[2] = {0,0};
3793
3794 float c, d;
3795 float cprime, dprime;
3796
3797 float xlinemin, xlinemax, zlinemin, zlinemax;
3798 float xlinemin2, xlinemax2, zlinemin2, zlinemax2;
3799
3800 GLfloat lineWidthNow;
3801 glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
3802
3803 xplus = xshift + 0.252;
3804 xminus = xshift - 0.252;
3805 zplus = zshift + 0.252;
3806 zminus = zshift - 0.252;
3807
3808 v1[1] = v2[1] = v3[1] = v4[1] = ROADS + 0.001;
3809
3810
3811
3812 /***********************************/
3813 /* Draw 'motion' dots on the plane */
3814 /***********************************/
3815
3816 if (view != MAPVIEW)
3817 {
3818 c = xshift - (int) xshift;
3819 d = zshift - (int) zshift;
3820
3821 if (itsChristmas)
3822 glColor3fv(colorblack);
3823 else
3824 glColor3fv(coloryellow);
3825
3826 if (c > 0)
3827 cprime = c-1;
3828 else
3829 cprime = c;
3830
3831 if (d > 0)
3832 dprime = d-1;
3833 else
3834 dprime = d;
3835
3836 /* if line widths are integral Mesa chokes in a large window */
3837 glLineWidth(1.01);
3838
3839 glPushMatrix();
3840 glTranslatef(cprime, 0, dprime);
3841 if (detail == 0)
3842 glCallList(planeDotsObjD0);
3843 else
3844 glCallList(planeDotsObj);
3845 glPopMatrix();
3846 }
3847
3848
3849 if (view == MAPVIEW)
3850 displaySize = 50;
3851 else
3852 displaySize = PLANESIZE+0.25;
3853
3854
3855 if (roads == NULL)
3856 return;
3857
3858 /***********************************/
3859 /* find all the roads on the plane */
3860 /***********************************/
3861
3862 ropCounter = 0;
3863 for(i=0;roads[i].type != NULLROAD;i++)
3864 {
3865 if ((fabs(roads[i].x+xshift) <= displaySize) && (fabs(roads[i].y+zshift) <= displaySize))
3866 {
3867 roadsOnPlane[ropCounter] = roads[i];
3868 ropCounter++;
3869
3870 if (ropCounter >= MAXROADSONPLANE)
3871 ropCounter = MAXROADSONPLANE - 1;
3872 }
3873 }
3874
3875
3876 square[0][1] = square[1][1] = square[2][1] = square[3][1] = ROADS;
3877
3878 /********************/
3879 /* Draw black roads */
3880 /********************/
3881
3882 if (ropCounter > 0)
3883 {
3884 glColor3fv(colorblack);
3885
3886 if (detail >= 2)
3887 {
3888 glColor3fv(colorwhite);
3889 glCallList(roadtex);
3890 glEnable(GL_TEXTURE_2D);
3891 }
3892
3893
3894 glBegin(GL_QUADS);
3895
3896
3897 for(i=0; i < ropCounter; i++)
3898 {
3899 if (roadsOnPlane[i].type < 3)
3900 {
3901 square[0][0] = square[3][0] = roadsOnPlane[i].x+xplus;
3902 square[1][0] = square[2][0] = roadsOnPlane[i].x+xminus;
3903
3904 square[0][2] = square[1][2] = roadsOnPlane[i].y+zplus;
3905 square[2][2] = square[3][2] = roadsOnPlane[i].y+zminus;
3906
3907 if (detail <2)
3908 {
3909 glVertex3fv(square[3]);
3910 glVertex3fv(square[2]);
3911 glVertex3fv(square[1]);
3912 glVertex3fv(square[0]);
3913 }
3914 else
3915 {
3916 glTexCoord2fv(tv1);
3917 glVertex3fv(square[3]);
3918 glTexCoord2fv(tv4);
3919 glVertex3fv(square[2]);
3920 glTexCoord2fv(tv3);
3921 glVertex3fv(square[1]);
3922 glTexCoord2fv(tv2);
3923 glVertex3fv(square[0]);
3924 }
3925 }
3926 }
3927 glEnd();
3928
3929 glDisable(GL_TEXTURE_2D);
3930
3931 }
3932
3933 /*******************/
3934 /* Draw grey roads */
3935 /*******************/
3936
3937 if (ropCounter > 0)
3938 {
3939 glColor3fv(colorgrey4);
3940
3941 glBegin(GL_QUADS);
3942
3943 for(i=0; i < ropCounter; i++)
3944 {
3945 if (roadsOnPlane[i].type >= 3)
3946 {
3947 square[0][0] = square[3][0] = roadsOnPlane[i].x+xplus;
3948 square[1][0] = square[2][0] = roadsOnPlane[i].x+xminus;
3949
3950 square[0][2] = square[1][2] = roadsOnPlane[i].y+zplus;
3951 square[2][2] = square[3][2] = roadsOnPlane[i].y+zminus;
3952
3953 glVertex3fv(square[3]);
3954 glVertex3fv(square[2]);
3955 glVertex3fv(square[1]);
3956 glVertex3fv(square[0]);
3957 }
3958 }
3959 glEnd();
3960 }
3961
3962 if (detail != 0)
3963 {
3964 /**************************/
3965 /* draw they yellow lines */
3966 /**************************/
3967
3968 xlinemin = xshift-ROADLINELENGTH;
3969 xlinemax = xshift+ROADLINELENGTH;
3970 zlinemin = zshift-ROADLINETHICKNESS;
3971 zlinemax = zshift+ROADLINETHICKNESS;
3972
3973 xlinemin2 = xshift-ROADLINETHICKNESS;
3974 xlinemax2 = xshift+ROADLINETHICKNESS;
3975 zlinemin2 = zshift-ROADLINELENGTH;
3976 zlinemax2 = zshift+ROADLINELENGTH;
3977
3978 glColor3fv(coloryellow);
3979
3980 glBegin(GL_QUADS);
3981
3982 for(i=0; i < ropCounter; i++)
3983 {
3984 if(roadsOnPlane[i].type == 0)
3985 {
3986 v1[0] = v4[0] = roadsOnPlane[i].x + xlinemin;
3987 v2[0] = v3[0] = roadsOnPlane[i].x + xlinemax;
3988
3989 v2[2] = v1[2] = roadsOnPlane[i].y + zlinemin;
3990 v3[2] = v4[2] = roadsOnPlane[i].y + zlinemax;
3991
3992 glVertex3fv(v1);
3993 glVertex3fv(v4);
3994 glVertex3fv(v3);
3995 glVertex3fv(v2);
3996 }
3997
3998 else if(roadsOnPlane[i].type == 1)
3999 {
4000 v1[2] = v4[2] = roadsOnPlane[i].y + zlinemin2;
4001 v2[2] = v3[2] = roadsOnPlane[i].y + zlinemax2;
4002
4003 v2[0] = v1[0] = roadsOnPlane[i].x + xlinemin2;
4004 v3[0] = v4[0] = roadsOnPlane[i].x + xlinemax2;
4005
4006 glVertex3fv(v1);
4007 glVertex3fv(v2);
4008 glVertex3fv(v3);
4009 glVertex3fv(v4);
4010
4011 }
4012 else if(roadsOnPlane[i].type == 2)
4013 {
4014 v1[2] = v4[2] = roadsOnPlane[i].y + zlinemin;
4015 v2[2] = v3[2] = roadsOnPlane[i].y + zlinemax;
4016
4017 v2[0] = v1[0] = roadsOnPlane[i].x + xlinemin2;
4018 v3[0] = v4[0] = roadsOnPlane[i].x + xlinemax2;
4019
4020 glVertex3fv(v1);
4021 glVertex3fv(v2);
4022 glVertex3fv(v3);
4023 glVertex3fv(v4);
4024
4025 }
4026 }
4027
4028 glEnd();
4029 }
4030
4031 glLineWidth(lineWidthNow);
4032 }
4033
4034 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
4035 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
4036 /* draw projectiles in flight */
4037 /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
4038
drawProjectiles(struct projectile * allProjs,int counter,struct fireType * fires,int fireCounter,int itsChristmas,int detail)4039 void drawProjectiles(struct projectile * allProjs, int counter,
4040 struct fireType * fires, int fireCounter,
4041 int itsChristmas, int detail)
4042 {
4043 struct projectile *temp;
4044 float col[4] = {1.0, 0, 0, 0};
4045 float v[3], v2[3];
4046 float x, y, z;
4047 float floatRatio;
4048 register int i;
4049 register int rotRatio;
4050 int beamCounter;
4051
4052 static float beamhitx[MAXBEAMS], beamhitz[MAXBEAMS];
4053
4054 GLfloat lineWidthNow;
4055 glGetFloatv(GL_LINE_WIDTH, &lineWidthNow);
4056
4057 /***********************************/
4058 /* make standard projectile object */
4059 /***********************************/
4060
4061 rotRatio = (counter*100) % 3600;
4062
4063 floatRatio = rotRatio * 0.1;
4064
4065 glDeleteLists( shellObj, 1);
4066 glNewList(shellObj, GL_COMPILE);
4067
4068 if (detail <= 0)
4069 makerrotcubexyflat(0.035, 0.035, 0.035, rotRatio, colorwhite);
4070 else
4071 makerrotcubexy(0.05, 0.05, 0.05, rotRatio, colorwhite);
4072
4073 if (itsChristmas)
4074 {
4075 makerrotcubexy(0.01, 0.051, 0.051, rotRatio, colorred);
4076 makerrotcubexy(0.051, 0.051, 0.01, rotRatio, colorred);
4077 }
4078 glEndList();
4079
4080 beamCounter = 0;
4081 for (temp = allProjs->next;temp != NULL;temp = temp->next)
4082 if ((fabs(temp->x) <= PLANESIZE) && (fabs(temp->z) <= PLANESIZE))
4083 {
4084 x = temp->x;
4085 y = temp->y;
4086 z = temp->z;
4087
4088 /**********************************/
4089 /* draw bomb */
4090 /**********************************/
4091
4092 switch(temp->type){
4093 case PROJTANK:
4094 case PROJROCKET:glPushMatrix(); /* white cube shells */
4095 glTranslatef(x, y, z);
4096 glCallList(shellObj);
4097 glPopMatrix();
4098 if (detail > 0)
4099 {
4100 glColor4fv(colorblack);
4101 shadow (x, z, 0.05, 0.05);
4102 }
4103 break;
4104
4105 case PROJTECHS: glPushMatrix(); /* techs shell */
4106 glTranslatef(x, y, z);
4107 glRotatef(floatRatio, 1, 0, 0);
4108 glRotatef(floatRatio, 0, 1, 0);
4109 glCallList(shell2Obj);
4110 glPopMatrix();
4111 if (detail > 0)
4112 {
4113 glColor4fv(colorblack);
4114 shadow (x, z, 0.05, 0.05);
4115 }
4116 break;
4117
4118 case PROJFIRE: break; /* flames */
4119
4120 case PROJSCAR: beamhitx[beamCounter] = x; /* monster beam scar */
4121 beamhitz[beamCounter] = z;
4122 beamCounter += 1;
4123 if (beamCounter >= MAXBEAMS)
4124 beamCounter -= 1;
4125 break;
4126
4127 case PROJWATER: glPushMatrix(); /* water */
4128 glTranslatef(x, y, z);
4129 glCallList(watershellObj);
4130 glPopMatrix();
4131 break;
4132
4133 case PROJHERO: glPushMatrix();
4134 glTranslatef(x, y, z);
4135 glRotatef(floatRatio, 1, 0, 0);
4136 glRotatef(floatRatio, 0, 1, 0);
4137 glCallList(heroshellObj);
4138 glPopMatrix();
4139 if (detail > 0)
4140 {
4141 glColor4fv(colorblack);
4142 shadow (x, z, 0.05, 0.05);
4143 }
4144 break;
4145
4146 default: showError("Bogus Projectile in Projectile List! (drawProjectiles)");
4147 break;
4148 }
4149 }
4150
4151
4152 /**********************************/
4153 /* draw fires */
4154 /**********************************/
4155
4156 for (i=0;i<fireCounter;i++)
4157 {
4158 col[1] = fires[i].col;
4159 if ((fabs(fires[i].x) <= PLANESIZE) && (fabs(fires[i].z) <= PLANESIZE))
4160 makeitPyr(12, col, fires[i].x, PLANEY+fires[i].height, fires[i].z,
4161 fires[i].xwid, fires[i].height, fires[i].zwid);
4162 }
4163
4164 /**********************************/
4165 /* draw scar from monster beam */
4166 /**********************************/
4167
4168 glColor3fv(colorblack);
4169
4170 /* if line widths are integral Mesa chokes in a large window */
4171 glLineWidth(2.01);
4172
4173 v[1] = v2[1] = SHADOWS;
4174
4175 v2[0] = beamhitx[0];
4176 v2[2] = beamhitz[0];
4177
4178 for(i=1; i<beamCounter; i++)
4179 {
4180 v[0] = beamhitx[i];
4181 v[2] = beamhitz[i];
4182
4183 if ((fabs(v[0] - v2[0]) < 0.3) && (fabs(v[2] - v2[2]) < 0.3))
4184 {
4185 glBegin(GL_LINES);
4186 glVertex3fv(v);
4187 glVertex3fv(v2);
4188 glEnd();
4189 }
4190
4191 v2[0] = v[0];
4192 v2[2] = v[2];
4193 }
4194
4195 glLineWidth(lineWidthNow);
4196 }
4197
4198
4199 /*
4200 #define J_SPACE 32
4201 #define J_DASH 34
4202
4203 #define J_1 50
4204 #define J_2 51
4205 #define J_3 52
4206 #define J_4 53
4207 #define J_5 54
4208 #define J_6 55
4209 #define J_7 56
4210 #define J_8 57
4211 #define J_9 58
4212
4213
4214 #define J_H_A 65
4215
4216 #define J_K_A 145
4217 #define J_K_I 146
4218 #define J_K_U 147
4219 #define J_K_E 148
4220 #define J_K_O 149
4221
4222 #define J_K_KA 150
4223 #define J_K_KI 151
4224 #define J_K_KU 152
4225 #define J_K_KE 153
4226 #define J_K_KO 154
4227
4228 #define J_K_SA 155
4229 #define J_K_SI 156
4230 #define J_K_SU 157
4231 #define J_K_SE 158
4232 #define J_K_SO 159
4233
4234 #define J_K_TA 160
4235 #define J_K_TI 161
4236 #define J_K_TU 162
4237 #define J_K_TE 163
4238 #define J_K_TO 164
4239
4240 #define J_K_NA 165
4241 #define J_K_NI 166
4242 #define J_K_NU 167
4243 #define J_K_NE 168
4244 #define J_K_NO 169
4245
4246 #define J_K_HA 170
4247 #define J_K_HI 171
4248 #define J_K_HU 172
4249 #define J_K_HE 173
4250 #define J_K_HO 174
4251
4252 #define J_K_MA 175
4253 #define J_K_MI 176
4254 #define J_K_MU 177
4255 #define J_K_ME 178
4256 #define J_K_MO 179
4257
4258 #define J_K_YA 180
4259 #define J_K_YU 182
4260 #define J_K_YO 184
4261
4262 #define J_K_RA 185
4263 #define J_K_RI 186
4264 #define J_K_RU 187
4265 #define J_K_RE 188
4266 #define J_K_RO 189
4267
4268 #define J_K_GA 200
4269 #define J_K_GI 201
4270 #define J_K_GU 202
4271 #define J_K_GE 203
4272 #define J_K_GO 204
4273
4274 #define J_K_ZA 205
4275 #define J_K_ZI 206
4276 #define J_K_ZU 207
4277 #define J_K_ZE 208
4278 #define J_K_ZO 209
4279
4280 #define J_K_DA 210
4281 #define J_K_DE 213
4282 #define J_K_DO 214
4283
4284 #define J_K_BA 215
4285 #define J_K_BI 216
4286 #define J_K_BU 217
4287 #define J_K_BE 218
4288 #define J_K_BO 219
4289
4290 #define J_K_PA 220
4291 #define J_K_PI 221
4292 #define J_K_PU 222
4293 #define J_K_PE 223
4294 #define J_K_PO 224
4295
4296
4297 char energyJapanese[] = {J_K_E, J_K_NE, J_K_RU, J_K_GI, 0};
4298 char googelonJapanese[] = {J_K_GU, J_K_GE, J_K_RO, J_SPACE, J_6, 0};
4299 char techsJapanese[] = {J_K_TE, J_K_TU, J_K_KU, J_K_SU, J_SPACE, J_7, 0};
4300 char flutterJapanese[] = {J_K_HU, J_K_RA, J_K_TU, J_K_TA, J_SPACE, J_9, 0};
4301 char vapourJapanese[] = {J_K_ZA, J_DASH, J_K_BE, J_DASH, J_K_PA, J_DASH, J_SPACE, J_8, 0};
4302 */
4303
4304