hardef.c

Go to the documentation of this file.
00001 
00002 /*
00003     Copyright (C) 2005 Michael K. McCarty & Fritz Bronner
00004 
00005     This program is free software; you can redistribute it and/or modify
00006     it under the terms of the GNU General Public License as published by
00007     the Free Software Foundation; either version 2 of the License, or
00008     (at your option) any later version.
00009 
00010     This program is distributed in the hope that it will be useful,
00011     but WITHOUT ANY WARRANTY; without even the implied warranty of
00012     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013     GNU General Public License for more details.
00014 
00015     You should have received a copy of the GNU General Public License
00016     along with this program; if not, write to the Free Software
00017     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00018 */
00019  // Interplay's BUZZ ALDRIN's RACE into SPACE
00020 //
00021 // Formerly -=> LiftOff : Race to the Moon :: IBM version MCGA
00022 // Copyright 1991 by Strategic Visions, Inc.
00023 // Designed by Fritz Bronner
00024 // Programmed by Michael K McCarty
00025 //
00026 // Museum Main Files
00027 
00028 #include "Buzz_inc.h"
00029 #include "externs.h"
00030 
00031 extern GXHEADER but;
00032 extern char Option, MAIL;
00033 
00034 void
00035 DrawHardef(char plr)
00036 {
00037     int i;
00038 
00039     FadeOut(2, pal, 10, 0, 0);
00040 
00041     Load_CIA_BUT();
00042     gxClearDisplay(0, 0);
00043     Load_RD_BUT(plr);
00044 
00045     ShBox(0, 0, 319, 199);
00046     IOBox(242, 3, 315, 19);
00047     InBox(3, 22, 316, 167);
00048     InBox(3, 3, 30, 19);
00049 
00050     ShBox(0, 160, 319, 199);
00051     IOBox(5, 162, 77, 197);
00052     IOBox(81, 162, 158, 197);
00053     IOBox(162, 162, 239, 197);
00054     IOBox(243, 162, 315, 197);
00055     GradRect(4, 23, 315, 159, 0);
00056     for (i = 4; i < 316; i += 2)
00057     {
00058         grPutPixel(i, 57, 11);
00059         grPutPixel(i, 91, 11);
00060         grPutPixel(i, 125, 11);
00061     }
00062     grSetColor(9);
00063     DispNum(5, 55, 15);
00064     DispNum(5, 89, 10);
00065     DispNum(5, 123, 5);
00066     gxVirtualDisplay(&but, 0, 0, 8, 165, 74, 194, 0);   // Unmanned
00067     gxVirtualDisplay(&but, 68, 0, 84, 165, 155, 194, 0);    // Rocket
00068     gxVirtualDisplay(&but, 141, 0, 165, 165, 236, 194, 0);  // Manned
00069     gxVirtualDisplay(&but, 214, 0, 246, 165, 312, 194, 0);  // Misc
00070     grSetColor(1);
00071     DispBig(40, 5, "EFFICIENCY", 1, -1);
00072     FlagSm(plr, 4, 4);
00073     grSetColor(1);
00074     PrintAt(258, 13, "CONTINUE");
00075     RectFill(149, 2, 157, 10, 9);
00076     RectFill(149, 2, 156, 9, 8);
00077     grSetColor(9);
00078     PrintAt(163, 8, "ATTEMPTS");
00079     RectFill(149, 12, 157, 20, 6);
00080     RectFill(149, 12, 156, 19, 5);
00081     grSetColor(6);
00082     PrintAt(163, 18, "SUCCESS");
00083     FadeIn(2, pal, 10, 0, 0);
00084 
00085     return;
00086 }
00087 
00088 void
00089 ShowHard(char plr)
00090 {
00091     int i, place = -1;
00092     char Cnt = 0;               // switch between screens
00093 
00094     DrawHardef(plr);
00095     strcpy(IDT, "i034");
00096     strcpy(IKEY, "k034");
00097     WaitForMouseUp();
00098     while (1)
00099     {
00100         key = 0;
00101         GetMouse();
00102         if (mousebuttons > 0 || key > 0)    /* Game Play */
00103         {
00104             if (((x >= 7 && y >= 164 && x <= 75 && y <= 195
00105                         && mousebuttons > 0) || key == 'U') && place != 0)
00106             {
00107                 InBox(7, 164, 75, 195);
00108                 WaitForMouseUp();
00109                 OutBox(7, 164, 75, 195);
00110                 ReButs(place, 0);
00111                 place = 0;
00112                 if (Cnt == 0)
00113                     HInfo(plr, place, 0);
00114                 else
00115                     PInfo(plr, place);
00116                 /* UnManned */
00117             }
00118             else if ((x >= 3 && y >= 3 && x <= 30 && y <= 19
00119                     && mousebuttons > 0) || key == 'T')
00120             {
00121 
00122                 FadeOut(2, pal, 10, 0, 0);
00123                 RectFill(33, 1, 239, 21, 3);
00124                 RectFill(4, 23, 315, 159, 0);
00125                 GradRect(4, 23, 315, 159, 0);
00126                 for (i = 4; i < 316; i += 2)
00127                 {
00128                     grPutPixel(i, 57, 11);
00129                     grPutPixel(i, 91, 11);
00130                     grPutPixel(i, 125, 11);
00131                 }
00132                 if (Cnt == 0)
00133                 {
00134                     grSetColor(1);
00135                     DispBig(40, 5, "PRESTIGE POINTS", 1, -1);
00136                     Cnt = 1;
00137                     PInfo(plr, place);
00138                 }
00139                 else
00140                 {
00141                     grSetColor(1);
00142                     DispBig(40, 5, "EFFICIENCY", 1, -1);
00143                     RectFill(149, 2, 157, 10, 9);
00144                     RectFill(149, 2, 156, 9, 8);
00145                     grSetColor(9);
00146                     PrintAt(163, 8, "ATTEMPTS:");
00147                     RectFill(149, 12, 157, 20, 6);
00148                     RectFill(149, 12, 156, 19, 5);
00149                     grSetColor(6);
00150                     PrintAt(163, 18, "SUCCESS");
00151                     Cnt = 0;
00152                     HInfo(plr, place, 0);
00153                 }
00154                 FadeIn(2, pal, 10, 0, 0);
00155 
00156             }
00157             else if (((x >= 83 && y >= 164 && x <= 156 && y <= 195
00158                         && mousebuttons > 0) || key == 'R') && place != 1)
00159             {
00160                 InBox(83, 164, 156, 195);
00161                 WaitForMouseUp();
00162                 OutBox(83, 164, 156, 195);
00163                 ReButs(place, 1);
00164                 place = 1;
00165                 if (Cnt == 0)
00166                     HInfo(plr, place, 0);
00167                 else
00168                     PInfo(plr, place);
00169                 /* Rocket */
00170             }
00171             else if (((x >= 164 && y >= 164 && x <= 237 && y <= 195
00172                         && mousebuttons > 0) || key == 'C') && place != 2)
00173             {
00174                 InBox(164, 164, 237, 195);
00175                 WaitForMouseUp();
00176                 OutBox(164, 164, 237, 195);
00177                 /* MANNED */
00178                 ReButs(place, 2);
00179                 place = 2;
00180                 if (Cnt == 0)
00181                     HInfo(plr, place, 0);
00182                 else
00183                     PInfo(plr, place);
00184             }
00185             else if (((x >= 245 && y >= 164 && x <= 313 && y <= 195
00186                         && mousebuttons > 0) || key == 'M') && place != 3)
00187             {
00188                 InBox(245, 164, 313, 195);
00189                 WaitForMouseUp();
00190                 OutBox(245, 164, 313, 195);
00191                 ReButs(place, 3);
00192                 place = 3;
00193                 if (Cnt == 0)
00194                     HInfo(plr, place, 0);
00195                 else
00196                     PInfo(plr, place);
00197                 /* MISC */
00198             }
00199             else if ((x >= 244 && y >= 5 && x <= 314 && y <= 17)
00200                 || key == K_ENTER)
00201             {
00202                 InBox(244, 5, 314, 17);
00203                 WaitForMouseUp();
00204                 OutBox(244, 5, 314, 17);
00205                 Del_RD_BUT();
00206                 return;            /* Done */
00207             };
00208         }
00209     };
00210 }
00211 
00212 void
00213 HDispIt(int x1, int y1, int x2, int y2, int s, int t)
00214 {
00215     GXHEADER local, local2;
00216     int i, w, h;
00217     unsigned char *src, *dest;
00218 
00219     w = x2 - x1 + 1;
00220     h = y2 - y1 + 1;
00221     GV(&local, w, h);
00222     GV(&local2, w, h);
00223     gxClearVirtual(&local, 0);
00224     gxClearVirtual(&local2, 0);
00225     gxGetImage(&local2, s, t, s + w - 1, t + h - 1, 0);
00226     gxVirtualVirtual(&vhptr, x1, y1, x2, y2, &local, 0, 0, gxSET);
00227     src = local.vptr;
00228     dest = local2.vptr;
00229     for (i = 0; i < w * h; i++)
00230     {
00231         if (*src != 0x00)
00232             *dest = *src;
00233         dest++;
00234         src++;
00235     }
00236 
00237     gxPutImage(&local2, gxSET, s, t, 0);
00238 
00239     DV(&local);
00240     DV(&local2);
00241     return;
00242 }
00243 
00244 void
00245 PInfo(char plr, char loc)
00246 {
00247     char j, Pt[4][7], stge;
00248     int i, tot, sfu;
00249     float ScaleAmt = 0.0;
00250 
00251     GradRect(4, 23, 315, 159, 0);
00252     for (i = 4; i < 316; i += 2)
00253     {
00254         grPutPixel(i, 57, 11);
00255         grPutPixel(i, 91, 11);
00256         grPutPixel(i, 125, 11);
00257     }
00258     for (i = 0; i < 4; i++)
00259         for (j = 0; j < 7; j++)
00260             Pt[i][j] = 0;
00261     for (i = 0; i < Data->P[plr].PastMis; i++)
00262     {
00263         if (Data->P[plr].History[i].Prestige > 0)
00264         {
00265             stge = 0;
00266             stge = Data->P[plr].History[i].Prestige;
00267             j = 0;
00268             if (Data->P[plr].History[i].Hard[j][0] > -1)
00269                 Pt[2][Data->P[plr].History[i].Hard[j][0]] += stge;
00270             if (Data->P[plr].History[i].Hard[j][1] > -1)
00271                 Pt[3][Data->P[plr].History[i].Hard[j][1]] += stge;
00272             if (Data->P[plr].History[i].Hard[j][2] > -1)
00273                 Pt[2][Data->P[plr].History[i].Hard[j][2]] += stge;
00274             if (Data->P[plr].History[i].Hard[j][3] > -1)
00275             {
00276                 if (Data->P[plr].History[i].Hard[j][3] < 4)
00277                     Pt[0][Data->P[plr].History[i].Hard[j][3]] += stge;
00278                 else
00279                     Pt[3][4] += stge;
00280             }
00281             if (Data->P[plr].History[i].Hard[j][4] > 0)
00282             {
00283                 if (Data->P[plr].History[i].Hard[j][4] < 5)
00284                     Pt[1][Data->P[plr].History[i].Hard[j][4] - 1] += stge;
00285                 else
00286                 {
00287                     Pt[1][Data->P[plr].History[i].Hard[j][4] - 5] += stge;
00288                     Pt[1][4] += stge;
00289                 }
00290             }                      // end-if
00291         }                          //end-if
00292     };                             // end-if
00293 
00294     //EVA suit klugge
00295     Pt[3][3] += Data->Prestige[26].Points[plr];
00296 
00297     // make sure there are no negative vals in Pt
00298     for (i = 0; i < 4; i++)
00299         for (j = 0; j < 7; j++)
00300             Pt[i][j] = maxx(Pt[i][j], 0);
00301     tot = 0;
00302 
00303     switch (loc)
00304     {
00305         case 0:
00306             if (Pt[2][5] >= Pt[2][6])
00307                 tot = Pt[2][5];
00308             else
00309                 tot = Pt[2][6];
00310             for (i = 0; i < 3; i++)
00311                 if (tot <= Pt[0][i])
00312                     tot = Pt[0][i];
00313             break;
00314         case 1:
00315             for (i = 0; i < 4; i++)
00316                 if (tot <= Pt[1][i])
00317                     tot = Pt[1][i];
00318             break;
00319         case 2:
00320             for (i = 0; i < 5; i++)
00321                 if (tot <= Pt[2][i])
00322                     tot = Pt[2][i];
00323             break;
00324         case 3:
00325             if (Pt[3][3] >= Pt[3][4])
00326                 tot = Pt[3][3];
00327             else
00328                 tot = Pt[3][4];
00329             if (tot <= Pt[1][4])
00330                 tot = Pt[1][4];
00331             if (tot <= Pt[3][0])
00332                 tot = Pt[3][0];
00333             if (tot <= Pt[3][1])
00334                 tot = Pt[3][1];
00335             if (tot <= Pt[3][2] && plr == 1)
00336                 tot = Pt[3][2];
00337             break;
00338         default:
00339             break;
00340     }
00341     if (tot < 20)
00342         ScaleAmt = 5.0;
00343     else if (tot < 40)
00344         ScaleAmt = 10.0;
00345     else if (tot < 60)
00346         ScaleAmt = 15.0;
00347     else if (tot < 80)
00348         ScaleAmt = 20.0;
00349     else if (tot < 100)
00350         ScaleAmt = 25.0;
00351     else if (tot < 120)
00352         ScaleAmt = 30.0;
00353     else if (tot < 140)
00354         ScaleAmt = 35.0;
00355     else if (tot < 160)
00356         ScaleAmt = 40.0;
00357     else if (tot < 200)
00358         ScaleAmt = 50.0;
00359 
00360     grSetColor(9);
00361     DispNum(5, 55, ScaleAmt * 3.0);
00362     DispNum(5, 89, ScaleAmt * 2.0);
00363     DispNum(5, 123, ScaleAmt);
00364     ScaleAmt = 25.0 / ScaleAmt;
00365     switch (loc)
00366     {
00367         case 1:
00368             for (i = 0; i < 4; i++)
00369             {
00370                 sfu = -1;
00371                 if (Data->P[plr].Rocket[i].Num >= 0)
00372                     sfu = ScaleAmt * Pt[1][i];
00373                 switch (i)
00374                 {
00375                     case 0:
00376                         if (sfu > 0)
00377                         {
00378                             RectFill(22, 159 - sfu * 136 / 100, 60, 159, 6);
00379                             RectFill(22, 159 - sfu * 136 / 100, 59, 158, 5);
00380                         };
00381                         if (plr == 0 && sfu > 0)
00382                             HDispIt(101, 1, 115, 57, 15, 104);
00383                         else if (sfu > 0)
00384                             HDispIt(129, 1, 149, 85, 15, 75);
00385                         break;
00386                     case 1:
00387                         if (sfu > 0)
00388                         {
00389                             RectFill(86, 159 - sfu * 136 / 100, 124, 159, 6);
00390                             RectFill(86, 159 - sfu * 136 / 100, 123, 158, 5);
00391                         }
00392                         if (plr == 0 && sfu > 0)
00393                             HDispIt(115, 0, 124, 68, 82, 92);
00394                         else if (sfu > 0)
00395                             HDispIt(151, 1, 170, 95, 82, 65);
00396                         break;
00397                     case 2:
00398                         if (sfu > 0)
00399                         {
00400                             RectFill(175, 159 - sfu * 136 / 100, 213, 159,
00401                                 6);
00402                             RectFill(175, 159 - sfu * 136 / 100, 212, 158,
00403                                 5);
00404                         };
00405                         if (plr == 0 && sfu > 0)
00406                             HDispIt(172, 1, 209, 133, 146, 27);
00407                         else if (sfu > 0)
00408                             HDispIt(211, 1, 243, 133, 148, 27);
00409                         break;
00410                     case 3:
00411                         if (sfu > 0)
00412                         {
00413                             RectFill(260, 159 - sfu * 136 / 100, 298, 159,
00414                                 6);
00415                             RectFill(260, 159 - sfu * 136 / 100, 297, 158,
00416                                 5);
00417                         };
00418                         if (plr == 0 && sfu > 0)
00419                             HDispIt(245, 1, 285, 137, 231, 23);
00420                         else if (sfu > 0)
00421                             HDispIt(287, 1, 318, 132, 231, 28);
00422                         break;
00423                     default:
00424                         break;
00425                 }                  // end switch
00426             };                     // end case 1 'rockets'
00427             break;
00428         case 0:
00429             sfu = -1;
00430             if (Data->P[plr].Manned[6].Num >= 0)
00431                 sfu = ScaleAmt * Pt[2][6];
00432             if (sfu > 0)
00433             {
00434                 RectFill(25, 159 - sfu * 136 / 100, 63, 159, 6);
00435                 RectFill(25, 159 - sfu * 136 / 100, 62, 158, 5);
00436             };
00437             if (plr == 0 && sfu > 0)
00438                 HDispIt(60, 153, 88, 176, 7, 133);
00439             else if (sfu > 0)
00440                 HDispIt(90, 151, 119, 176, 7, 131);
00441             sfu = -1;
00442             if (Data->P[plr].Manned[5].Num >= 0)
00443                 sfu = ScaleAmt * Pt[2][5];
00444             if (sfu > 0)
00445             {
00446                 RectFill(101, 159 - sfu * 136 / 100, 139, 159, 6);
00447                 RectFill(101, 159 - sfu * 136 / 100, 138, 158, 5);
00448             }
00449             if (plr == 0 && sfu > 0)
00450                 HDispIt(1, 153, 29, 182, 83, 126);
00451             else if (sfu > 0)
00452                 HDispIt(31, 153, 56, 182, 83, 126);
00453             for (i = 0; i < 3; i++)
00454             {
00455                 sfu = -1;
00456                 if (Data->P[plr].Probe[i].Num >= 0)
00457                     sfu = ScaleAmt * Pt[0][i];
00458                 switch (i)
00459                 {
00460                     case 0:
00461                         if (sfu > 0)
00462                         {
00463                             RectFill(152, 159 - sfu * 136 / 100, 190, 159,
00464                                 6);
00465                             RectFill(152, 159 - sfu * 136 / 100, 189, 158,
00466                                 5);
00467                         };
00468                         if (plr == 0 && sfu > 0)
00469                             HDispIt(58, 180, 71, 196, 147, 138);
00470                         else if (sfu > 0)
00471                             HDispIt(73, 180, 89, 195, 147, 139);
00472                         break;
00473                     case 1:
00474                         if (sfu > 0)
00475                         {
00476                             RectFill(212, 159 - sfu * 136 / 100, 250, 159,
00477                                 6);
00478                             RectFill(212, 159 - sfu * 136 / 100, 249, 158,
00479                                 5);
00480                         }
00481                         if (plr == 0 && sfu > 0)
00482                             HDispIt(91, 178, 115, 195, 198, 139);
00483                         else if (sfu > 0)
00484                             HDispIt(153, 142, 176, 166, 198, 132);
00485                         break;
00486                     case 2:
00487                         if (sfu > 0)
00488                         {
00489                             RectFill(272, 159 - sfu * 136 / 100, 310, 159,
00490                                 6);
00491                             RectFill(272, 159 - sfu * 136 / 100, 309, 158,
00492                                 5);
00493                         }
00494                         if (plr == 0 && sfu > 0)
00495                             HDispIt(121, 142, 151, 166, 253, 132);
00496                         else if (sfu > 0)
00497                             HDispIt(178, 142, 201, 160, 253, 138);
00498                         break;
00499                     default:
00500                         break;
00501                 }                  // end switch
00502             }                      // end case 2 'misc programs + lm'
00503             break;
00504         case 2:
00505             for (i = 0; i < 5; i++)
00506             {
00507                 sfu = -1;
00508                 if (Data->P[plr].Manned[i].Num >= 0)
00509                     sfu = ScaleAmt * Pt[2][i];
00510                 switch (i)
00511                 {
00512                     case 0:
00513                         if (sfu > 0)
00514                         {
00515                             RectFill(16, 159 - sfu * 136 / 100, 54, 159, 6);
00516                             RectFill(16, 159 - sfu * 136 / 100, 53, 158, 5);
00517                         };
00518                         if (plr == 0 && sfu > 0)
00519                             HDispIt(12, 91, 25, 116, 12, 137);
00520                         else if (sfu > 0)
00521                             HDispIt(0, 56, 26, 89, 14, 123);
00522                         break;
00523                     case 1:
00524                         if (sfu > 0)
00525                         {
00526                             RectFill(77, 159 - sfu * 136 / 100, 115, 159, 6);
00527                             RectFill(77, 159 - sfu * 136 / 100, 114, 158, 5);
00528                         };
00529                         if (plr == 0 && sfu > 0)
00530                             HDispIt(27, 98, 49, 127, 66, 127);
00531                         else if (sfu > 0)
00532                             HDispIt(28, 62, 49, 96, 66, 122);
00533                         break;
00534                     case 2:
00535                         if (sfu > 0)
00536                         {
00537                             RectFill(142, 159 - sfu * 136 / 100, 180, 159,
00538                                 6);
00539                             RectFill(142, 159 - sfu * 136 / 100, 179, 158,
00540                                 5);
00541                         };
00542                         if (plr == 0 && sfu > 0)
00543                             DispIt(95, 77, 117, 127, 130, 106);
00544                         else if (sfu > 0)
00545                             HDispIt(119, 97, 170, 140, 122, 113);
00546                         break;
00547                     case 3:
00548                         if (sfu > 0)
00549                         {
00550                             RectFill(198, 159 - sfu * 136 / 100, 236, 159,
00551                                 6);
00552                             RectFill(198, 159 - sfu * 136 / 100, 235, 158,
00553                                 5);
00554                         };
00555                         if (plr == 0 && sfu > 0)
00556                             HDispIt(3, 1, 16, 54, 191, 103);
00557                         else if (sfu > 0)
00558                             HDispIt(18, 1, 32, 48, 191, 109);
00559                         break;
00560                     case 4:
00561                         if (sfu > 0)
00562                         {
00563                             RectFill(266, 159 - sfu * 136 / 100, 304, 159,
00564                                 6);
00565                             RectFill(266, 159 - sfu * 136 / 100, 303, 158,
00566                                 5);
00567                         };
00568                         if (plr == 0 && sfu > 0)
00569                             HDispIt(34, 1, 65, 60, 248, 97);
00570                         else if (sfu > 0)
00571                             HDispIt(67, 1, 100, 60, 248, 97);
00572                         break;
00573                     default:
00574                         break;
00575                 }                  // end switch
00576             }                      // end case 2 'manned' programs
00577             break;
00578         case 3:
00579             sfu = -1;
00580             if (Data->P[plr].Misc[3].Num >= 0)
00581                 sfu = ScaleAmt * Pt[3][3];
00582             if (sfu > 0)
00583             {
00584                 RectFill(19, 159 - sfu * 136 / 100, 57, 159, 6);
00585                 RectFill(19, 159 - sfu * 136 / 100, 56, 158, 5);
00586             }
00587             if (plr == 0 && sfu > 0)
00588                 HDispIt(68, 65, 76, 75, 17, 145);
00589             else if (sfu > 0)
00590                 HDispIt(78, 65, 86, 75, 17, 145);
00591             sfu = -1;
00592             if (Data->P[plr].Misc[4].Num >= 0)
00593                 sfu = ScaleAmt * Pt[3][4];
00594             if (sfu > 0)
00595             {
00596                 RectFill(72, 159 - sfu * 136 / 100, 110, 159, 6);
00597                 RectFill(72, 159 - sfu * 136 / 100, 109, 158, 5);
00598             }
00599             if (plr == 0 && sfu > 0)
00600                 HDispIt(88, 62, 100, 75, 64, 143);
00601             else if (sfu > 0)
00602                 HDispIt(102, 66, 114, 75, 64, 147);
00603             sfu = -1;
00604             if (Data->P[plr].Rocket[4].Num >= 0)
00605                 sfu = ScaleAmt * Pt[1][4];
00606             if (sfu > 0)
00607             {
00608                 RectFill(118, 159 - sfu * 136 / 100, 156, 159, 6);
00609                 RectFill(118, 159 - sfu * 136 / 100, 155, 158, 5);
00610             }
00611             if (plr == 0 && sfu > 0)
00612                 HDispIt(1, 120, 14, 151, 113, 125);
00613             else if (sfu > 0)
00614                 HDispIt(16, 130, 31, 151, 113, 135);
00615             sfu = -1;
00616             if (Data->P[plr].Misc[0].Num >= 0)
00617                 sfu = ScaleAmt * Pt[3][0];
00618             if (sfu > 0)
00619             {
00620                 RectFill(173, 159 - sfu * 136 / 100, 211, 159, 6);
00621                 RectFill(173, 159 - sfu * 136 / 100, 210, 158, 5);
00622             }
00623             if (plr == 0 && sfu > 0)
00624                 HDispIt(33, 140, 47, 151, 165, 145);
00625             else if (sfu > 0)
00626                 HDispIt(49, 138, 61, 151, 165, 143);
00627             sfu = -1;
00628             if (Data->P[plr].Misc[1].Num >= 0)
00629                 sfu = ScaleAmt * Pt[3][1];
00630             if (sfu > 0)
00631             {
00632                 RectFill(226, 159 - sfu * 136 / 100, 254, 159, 6);
00633                 RectFill(226, 159 - sfu * 136 / 100, 253, 158, 5);
00634             }
00635             if (plr == 0 && sfu > 0)
00636                 HDispIt(63, 131, 75, 151, 219, 136);
00637             else if (sfu > 0)
00638                 HDispIt(77, 129, 88, 151, 219, 134);
00639             sfu = -1;
00640 
00641             if (Data->P[1].Misc[2].Num >= 0)
00642                 sfu = ScaleAmt * Pt[3][2];
00643             if (sfu > 0 && plr == 1)
00644             {
00645                 RectFill(275, 159 - sfu * 136 / 100, 313, 159, 6);
00646                 RectFill(275, 159 - sfu * 136 / 100, 312, 158, 5);
00647             }
00648             if (sfu > 0 && plr == 1)
00649                 HDispIt(51, 77, 93, 127, 270, 106);
00650             break;
00651         default:
00652             break;
00653     }
00654 
00655     return;
00656 }
00657 
00658 void
00659 HInfo(char plr, char loc, char w)
00660 {
00661     int i, sfu, sfs, tot;
00662     float ov, un, ScaleAmt = 0.0;
00663 
00664     if (w == 0)
00665     {
00666         GradRect(4, 23, 315, 159, 0);
00667         for (i = 4; i < 316; i += 2)
00668         {
00669             grPutPixel(i, 57, 11);
00670             grPutPixel(i, 91, 11);
00671             grPutPixel(i, 125, 11);
00672         }
00673         // determine scale x5
00674         tot = 0;
00675         switch (loc)
00676         {
00677             case 0:
00678                 if (Data->P[plr].Manned[5].Steps >=
00679                     Data->P[plr].Manned[6].Steps)
00680                     tot = Data->P[plr].Manned[5].Steps;
00681                 else
00682                     tot = Data->P[plr].Manned[6].Steps;
00683                 for (i = 0; i < 3; i++)
00684                     if (tot <= Data->P[plr].Probe[i].Steps)
00685                         tot = Data->P[plr].Probe[i].Steps;
00686                 break;
00687             case 1:
00688                 for (i = 0; i < 4; i++)
00689                     if (tot <= Data->P[plr].Rocket[i].Steps)
00690                         tot = Data->P[plr].Rocket[i].Steps;
00691                 break;
00692             case 2:
00693                 for (i = 0; i < 5; i++)
00694                     if (tot <= Data->P[plr].Manned[i].Steps)
00695                         tot = Data->P[plr].Manned[i].Steps;
00696                 break;
00697             case 3:
00698                 if (Data->P[plr].Misc[3].Steps >= Data->P[plr].Misc[4].Steps)
00699                     tot = Data->P[plr].Misc[3].Steps;
00700                 else
00701                     tot = Data->P[plr].Misc[4].Steps;
00702                 if (tot <= Data->P[plr].Rocket[4].Steps)
00703                     tot = Data->P[plr].Rocket[4].Steps;
00704                 if (tot <= Data->P[plr].Misc[0].Steps)
00705                     tot = Data->P[plr].Misc[0].Steps;
00706                 if (tot <= Data->P[plr].Misc[1].Steps)
00707                     tot = Data->P[plr].Misc[1].Steps;
00708                 if (tot <= Data->P[plr].Misc[2].Steps && plr == 1)
00709                     tot = Data->P[plr].Misc[2].Steps;
00710                 break;
00711             default:
00712                 break;
00713         }
00714 
00715         if (tot < 20)
00716             ScaleAmt = 5.0;
00717         else if (tot < 40)
00718             ScaleAmt = 10.0;
00719         else if (tot < 60)
00720             ScaleAmt = 15.0;
00721         else if (tot < 80)
00722             ScaleAmt = 20.0;
00723         else if (tot < 100)
00724             ScaleAmt = 25.0;
00725         else if (tot < 120)
00726             ScaleAmt = 30.0;
00727 
00728         grSetColor(9);
00729         DispNum(5, 55, ScaleAmt * 3.0);
00730         DispNum(5, 89, ScaleAmt * 2.0);
00731         DispNum(5, 123, ScaleAmt);
00732     }
00733     ScaleAmt = 25.0 / ScaleAmt;
00734     grSetColor(1);
00735     switch (loc)
00736     {
00737         case 1:                //PrintAt(137,150,"ROCKETS");
00738             for (i = 0; i < 4; i++)
00739             {
00740                 sfu = -1;
00741                 sfs = -1;
00742                 if (Data->P[plr].Rocket[i].Num >= 0)
00743                 {
00744                     sfu = ScaleAmt * Data->P[plr].Rocket[i].Steps;
00745                     if (sfu > 0)
00746                     {
00747                         ov = Data->P[plr].Rocket[i].Steps -
00748                             Data->P[plr].Rocket[i].Failures;
00749                         un = Data->P[plr].Rocket[i].Steps;
00750                         sfs = sfu * (ov / un);
00751                     }
00752                 }
00753                 switch (i)
00754                 {
00755                     case 0:
00756                         if (sfu > 0)
00757                         {
00758                             RectFill(22, 159 - sfu * 136 / 100, 60, 159, 9);
00759                             RectFill(22, 159 - sfu * 136 / 100, 59, 158, 8);
00760                         };
00761                         if (sfs > 0)
00762                         {
00763                             RectFill(22, 159 - sfs * 136 / 100, 55, 159, 6);
00764                             RectFill(22, 159 - sfs * 136 / 100, 54, 158, 5);
00765                         };
00766                         if (plr == 0 && sfu > 0)
00767                             HDispIt(101, 1, 115, 57, 15, 104);
00768                         else if (sfu > 0)
00769                             HDispIt(129, 1, 149, 85, 15, 75);
00770                         break;
00771                     case 1:
00772                         if (sfu > 0)
00773                         {
00774                             RectFill(86, 159 - sfu * 136 / 100, 124, 159, 9);
00775                             RectFill(86, 159 - sfu * 136 / 100, 123, 158, 8);
00776                         }
00777                         if (sfs > 0)
00778                         {
00779                             RectFill(86, 159 - sfs * 136 / 100, 119, 159, 6);
00780                             RectFill(86, 159 - sfs * 136 / 100, 118, 158, 5);
00781                         }
00782                         if (plr == 0 && sfu > 0)
00783                             HDispIt(115, 0, 124, 68, 82, 92);
00784                         else if (sfu > 0)
00785                             HDispIt(151, 1, 170, 95, 82, 65);
00786                         break;
00787                     case 2:
00788                         if (sfu > 0)
00789                         {
00790                             RectFill(175, 159 - sfu * 136 / 100, 213, 159,
00791                                 9);
00792                             RectFill(175, 159 - sfu * 136 / 100, 212, 158,
00793                                 8);
00794                         };
00795                         if (sfs > 0)
00796                         {
00797                             RectFill(175, 159 - sfs * 136 / 100, 208, 159,
00798                                 6);
00799                             RectFill(175, 159 - sfs * 136 / 100, 207, 158,
00800                                 5);
00801                         };
00802                         if (plr == 0 && sfu > 0)
00803                             HDispIt(172, 1, 209, 133, 146, 27);
00804                         else if (sfu > 0)
00805                             HDispIt(211, 1, 243, 133, 148, 27);
00806                         break;
00807                     case 3:
00808                         if (sfu > 0)
00809                         {
00810                             RectFill(260, 159 - sfu * 136 / 100, 298, 159,
00811                                 9);
00812                             RectFill(260, 159 - sfu * 136 / 100, 297, 158,
00813                                 8);
00814                         };
00815                         if (sfs > 0)
00816                         {
00817                             RectFill(260, 159 - sfs * 136 / 100, 293, 159,
00818                                 6);
00819                             RectFill(260, 159 - sfs * 136 / 100, 292, 158,
00820                                 5);
00821                         };
00822                         if (plr == 0 && sfu > 0)
00823                             HDispIt(245, 1, 285, 137, 231, 23);
00824                         else if (sfu > 0)
00825                             HDispIt(287, 1, 318, 132, 231, 28);
00826                         break;
00827                     default:
00828                         break;
00829                 }                  // end switch
00830             };                     // end case 1 'rockets'
00831             break;
00832         case 2:                //PrintAt(137,150,"CAPSULES");
00833             for (i = 0; i < 5; i++)
00834             {
00835                 sfu = -1;
00836                 sfs = -1;
00837                 if (Data->P[plr].Manned[i].Num >= 0)
00838                 {
00839                     sfu = ScaleAmt * Data->P[plr].Manned[i].Steps;
00840                     if (sfu > 0)
00841                     {
00842                         ov = Data->P[plr].Manned[i].Steps -
00843                             Data->P[plr].Manned[i].Failures;
00844                         un = Data->P[plr].Manned[i].Steps;
00845                         sfs = sfu * (ov / un);
00846                     }
00847                 }
00848                 switch (i)
00849                 {
00850                     case 0:
00851                         if (sfu > 0)
00852                         {
00853                             RectFill(16, 159 - sfu * 136 / 100, 54, 159, 9);
00854                             RectFill(16, 159 - sfu * 136 / 100, 53, 158, 8);
00855                         };
00856                         if (sfs > 0)
00857                         {
00858                             RectFill(16, 159 - sfs * 136 / 100, 49, 159, 6);
00859                             RectFill(16, 159 - sfs * 136 / 100, 48, 158, 5);
00860                         };
00861                         if (plr == 0 && sfu > 0)
00862                             HDispIt(12, 91, 25, 116, 12, 137);
00863                         else if (sfu > 0)
00864                             HDispIt(0, 56, 26, 89, 14, 123);
00865                         break;
00866                     case 1:
00867                         if (sfu > 0)
00868                         {
00869                             RectFill(77, 159 - sfu * 136 / 100, 115, 159, 9);
00870                             RectFill(77, 159 - sfu * 136 / 100, 114, 158, 8);
00871                         };
00872                         if (sfs > 0)
00873                         {
00874                             RectFill(77, 159 - sfs * 136 / 100, 110, 159, 6);
00875                             RectFill(77, 159 - sfs * 136 / 100, 109, 158, 5);
00876                         };
00877                         if (plr == 0 && sfu > 0)
00878                             HDispIt(27, 98, 49, 127, 66, 127);
00879                         else if (sfu > 0)
00880                             HDispIt(28, 62, 49, 96, 66, 122);
00881                         break;
00882                     case 2:
00883                         if (sfu > 0)
00884                         {
00885                             RectFill(142, 159 - sfu * 136 / 100, 180, 159,
00886                                 9);
00887                             RectFill(142, 159 - sfu * 136 / 100, 179, 158,
00888                                 8);
00889                         };
00890                         if (sfs > 0)
00891                         {
00892                             RectFill(142, 159 - sfs * 136 / 100, 175, 159,
00893                                 6);
00894                             RectFill(142, 159 - sfs * 136 / 100, 174, 158,
00895                                 5);
00896                         };
00897                         if (plr == 0 && sfu > 0)
00898                             DispIt(95, 77, 117, 127, 130, 106);
00899                         else if (sfu > 0)
00900                             HDispIt(119, 97, 170, 140, 122, 113);
00901                         break;
00902                     case 3:
00903                         if (sfu > 0)
00904                         {
00905                             RectFill(198, 159 - sfu * 136 / 100, 236, 159,
00906                                 9);
00907                             RectFill(198, 159 - sfu * 136 / 100, 235, 158,
00908                                 8);
00909                         };
00910                         if (sfs > 0)
00911                         {
00912                             RectFill(198, 159 - sfs * 136 / 100, 231, 159,
00913                                 6);
00914                             RectFill(198, 159 - sfs * 136 / 100, 230, 158,
00915                                 5);
00916                         };
00917                         if (plr == 0 && sfu > 0)
00918                             HDispIt(3, 1, 16, 54, 191, 103);
00919                         else if (sfu > 0)
00920                             HDispIt(18, 1, 32, 48, 191, 109);
00921                         break;
00922                     case 4:
00923                         if (sfu > 0)
00924                         {
00925                             RectFill(266, 159 - sfu * 136 / 100, 304, 159,
00926                                 9);
00927                             RectFill(266, 159 - sfu * 136 / 100, 303, 158,
00928                                 8);
00929                         };
00930                         if (sfs > 0)
00931                         {
00932                             RectFill(266, 159 - sfs * 136 / 100, 299, 159,
00933                                 6);
00934                             RectFill(266, 159 - sfs * 136 / 100, 298, 158,
00935                                 5);
00936                         };
00937                         if (plr == 0 && sfu > 0)
00938                             HDispIt(34, 1, 65, 60, 248, 97);
00939                         else if (sfu > 0)
00940                             HDispIt(67, 1, 100, 60, 248, 97);
00941                         break;
00942                     default:
00943                         break;
00944                 }                  // end switch
00945             }                      // end case 2 'manned' programs
00946             break;
00947         case 0:                //PrintAt(100,150,"SATELLITES & LM'S");
00948             sfu = -1;
00949             sfs = -1;
00950             if (Data->P[plr].Manned[6].Num >= 0)
00951             {
00952                 sfu = ScaleAmt * Data->P[plr].Manned[6].Steps;
00953                 if (sfu > 0)
00954                 {
00955                     ov = Data->P[plr].Manned[6].Steps -
00956                         Data->P[plr].Manned[6].Failures;
00957                     un = Data->P[plr].Manned[6].Steps;
00958                     sfs = sfu * (ov / un);
00959                 }
00960             }
00961             if (sfu > 0)
00962             {
00963                 RectFill(25, 159 - sfu * 136 / 100, 63, 159, 9);
00964                 RectFill(25, 159 - sfu * 136 / 100, 62, 158, 8);
00965             };
00966             if (sfs > 0)
00967             {
00968                 RectFill(25, 159 - sfs * 136 / 100, 58, 159, 6);
00969                 RectFill(25, 159 - sfs * 136 / 100, 57, 158, 5);
00970             };
00971             if (plr == 0 && sfu > 0)
00972                 HDispIt(60, 153, 88, 176, 9, 132);
00973             else if (sfu > 0)
00974                 HDispIt(90, 151, 119, 176, 9, 132);
00975 
00976             sfu = -1;
00977             sfs = -1;
00978             if (Data->P[plr].Manned[5].Num >= 0)
00979             {
00980                 sfu = ScaleAmt * Data->P[plr].Manned[5].Steps;
00981                 if (sfu > 0)
00982                 {
00983                     ov = Data->P[plr].Manned[5].Steps -
00984                         Data->P[plr].Manned[5].Failures;
00985                     un = Data->P[plr].Manned[5].Steps;
00986                     sfs = sfu * (ov / un);
00987                 }
00988             }
00989             if (sfu > 0)
00990             {
00991                 RectFill(101, 159 - sfu * 136 / 100, 139, 159, 9);
00992                 RectFill(101, 159 - sfu * 136 / 100, 138, 158, 8);
00993             }
00994             if (sfs > 0)
00995             {
00996                 RectFill(101, 159 - sfs * 136 / 100, 134, 159, 6);
00997                 RectFill(101, 159 - sfs * 136 / 100, 133, 158, 5);
00998             }
00999             if (plr == 0 && sfu > 0)
01000                 HDispIt(1, 153, 29, 182, 83, 128);
01001             else if (sfu > 0)
01002                 HDispIt(31, 153, 56, 182, 83, 128);
01003 
01004             for (i = 0; i < 3; i++)
01005             {
01006                 sfu = -1;
01007                 sfs = -1;
01008                 if (Data->P[plr].Probe[i].Num >= 0)
01009                 {
01010                     sfu = ScaleAmt * Data->P[plr].Probe[i].Steps;
01011                     if (sfu > 0)
01012                     {
01013                         ov = Data->P[plr].Probe[i].Steps -
01014                             Data->P[plr].Probe[i].Failures;
01015                         un = Data->P[plr].Probe[i].Steps;
01016                         sfs = sfu * (ov / un);
01017                     }
01018                 }
01019                 switch (i)
01020                 {
01021                     case 0:
01022                         if (sfu > 0)
01023                         {
01024                             RectFill(152, 159 - sfu * 136 / 100, 190, 159,
01025                                 9);
01026                             RectFill(152, 159 - sfu * 136 / 100, 189, 158,
01027                                 8);
01028                         };
01029                         if (sfs > 0)
01030                         {
01031                             RectFill(152, 159 - sfs * 136 / 100, 185, 159,
01032                                 6);
01033                             RectFill(152, 159 - sfs * 136 / 100, 184, 158,
01034                                 5);
01035                         };
01036                         if (plr == 0 && sfu > 0)
01037                             HDispIt(58, 180, 71, 196, 147, 138);
01038                         else if (sfu > 0)
01039                             HDispIt(73, 180, 89, 195, 147, 139);
01040                         break;
01041                     case 1:
01042                         if (sfu > 0)
01043                         {
01044                             RectFill(212, 159 - sfu * 136 / 100, 250, 159,
01045                                 9);
01046                             RectFill(212, 159 - sfu * 136 / 100, 249, 158,
01047                                 8);
01048                         }
01049                         if (sfs > 0)
01050                         {
01051                             RectFill(212, 159 - sfs * 136 / 100, 245, 159,
01052                                 6);
01053                             RectFill(212, 159 - sfs * 136 / 100, 244, 158,
01054                                 5);
01055                         }
01056                         if (plr == 0 && sfu > 0)
01057                             HDispIt(91, 178, 115, 195, 198, 139);
01058                         else if (sfu > 0)
01059                             HDispIt(153, 142, 176, 166, 198, 132);
01060                         break;
01061                     case 2:
01062                         if (sfu > 0)
01063                         {
01064                             RectFill(272, 159 - sfu * 136 / 100, 310, 159,
01065                                 9);
01066                             RectFill(272, 159 - sfu * 136 / 100, 309, 158,
01067                                 8);
01068                         }
01069                         if (sfs > 0)
01070                         {
01071                             RectFill(272, 159 - sfs * 136 / 100, 305, 159,
01072                                 6);
01073                             RectFill(272, 159 - sfs * 136 / 100, 304, 158,
01074                                 5);
01075                         }
01076                         if (plr == 0 && sfu > 0)
01077                             HDispIt(121, 142, 151, 166, 253, 132);
01078                         else if (sfu > 0)
01079                             HDispIt(178, 142, 201, 160, 253, 138);
01080                         break;
01081                     default:
01082                         break;
01083                 }                  // end switch
01084             }                      // end case 2 'misc programs + lm'
01085             break;
01086         case 3:                //PrintAt(100,150,"ADDITIONAL PROGRAMS");
01087             sfu = -1;
01088             sfs = -1;
01089             if (Data->P[plr].Misc[3].Num >= 0)
01090             {
01091                 sfu = ScaleAmt * Data->P[plr].Misc[3].Steps;
01092                 if (sfu > 0)
01093                 {
01094                     ov = Data->P[plr].Misc[3].Steps -
01095                         Data->P[plr].Misc[3].Failures;
01096                     un = Data->P[plr].Misc[3].Steps;
01097                     sfs = sfu * (ov / un);
01098                 }
01099             }
01100             if (sfu > 0)
01101             {
01102                 RectFill(19, 159 - sfu * 136 / 100, 57, 159, 9);
01103                 RectFill(19, 159 - sfu * 136 / 100, 56, 158, 8);
01104             }
01105             if (sfs > 0)
01106             {
01107                 RectFill(19, 159 - sfs * 136 / 100, 52, 159, 6);
01108                 RectFill(19, 159 - sfs * 136 / 100, 51, 158, 5);
01109             }
01110             if (plr == 0 && sfu > 0)
01111                 HDispIt(68, 65, 76, 75, 17, 145);
01112             else if (sfu > 0)
01113                 HDispIt(78, 65, 86, 75, 17, 145);
01114 
01115             sfu = -1;
01116             sfs = -1;
01117             if (Data->P[plr].Misc[4].Num >= 0)
01118             {
01119                 sfu = ScaleAmt * Data->P[plr].Misc[4].Steps;
01120                 if (sfu > 0)
01121                 {
01122                     ov = Data->P[plr].Misc[4].Steps -
01123                         Data->P[plr].Misc[4].Failures;
01124                     un = Data->P[plr].Misc[4].Steps;
01125                     sfs = sfu * (ov / un);
01126                 }
01127             }
01128             if (sfu > 0)
01129             {
01130                 RectFill(72, 159 - sfu * 136 / 100, 110, 159, 9);
01131                 RectFill(72, 159 - sfu * 136 / 100, 109, 158, 8);
01132             }
01133             if (sfs > 0)
01134             {
01135                 RectFill(72, 159 - sfs * 136 / 100, 105, 159, 6);
01136                 RectFill(72, 159 - sfs * 136 / 100, 104, 158, 5);
01137             }
01138             if (plr == 0 && sfu > 0)
01139                 HDispIt(88, 62, 100, 75, 64, 143);
01140             else if (sfu > 0)
01141                 HDispIt(102, 66, 114, 75, 64, 147);
01142             sfu = -1;
01143             sfs = -1;
01144             if (Data->P[plr].Rocket[4].Num >= 0)
01145             {
01146                 sfu = ScaleAmt * Data->P[plr].Rocket[4].Steps;
01147                 if (sfu > 0)
01148                 {
01149                     ov = Data->P[plr].Rocket[4].Steps -
01150                         Data->P[plr].Rocket[4].Failures;
01151                     un = Data->P[plr].Rocket[4].Steps;
01152                     sfs = sfu * (ov / un);
01153                 }
01154             }
01155             if (sfu > 0)
01156             {
01157                 RectFill(118, 159 - sfu * 136 / 100, 156, 159, 9);
01158                 RectFill(118, 159 - sfu * 136 / 100, 155, 158, 8);
01159             }
01160             if (sfs > 0)
01161             {
01162                 RectFill(118, 159 - sfs * 136 / 100, 151, 159, 6);
01163                 RectFill(118, 159 - sfs * 136 / 100, 150, 158, 5);
01164             }
01165             if (plr == 0 && sfu > 0)
01166                 HDispIt(1, 120, 14, 151, 113, 125);
01167             else if (sfu > 0)
01168                 HDispIt(16, 130, 31, 151, 113, 135);
01169             sfu = -1;
01170             sfs = -1;
01171             if (Data->P[plr].Misc[0].Num >= 0)
01172             {
01173                 sfu = ScaleAmt * Data->P[plr].Misc[0].Steps;
01174                 if (sfu > 0)
01175                 {
01176                     ov = Data->P[plr].Misc[0].Steps -
01177                         Data->P[plr].Misc[0].Failures;
01178                     un = Data->P[plr].Misc[0].Steps;
01179                     sfs = sfu * (ov / un);
01180                 }
01181             }
01182             if (sfu > 0)
01183             {
01184                 RectFill(173, 159 - sfu * 136 / 100, 211, 159, 9);
01185                 RectFill(173, 159 - sfu * 136 / 100, 210, 158, 8);
01186             }
01187             if (sfs > 0)
01188             {
01189                 RectFill(173, 159 - sfs * 136 / 100, 206, 159, 6);
01190                 RectFill(173, 159 - sfs * 136 / 100, 205, 158, 5);
01191             }
01192             if (plr == 0 && sfu > 0)
01193                 HDispIt(33, 140, 47, 151, 165, 145);
01194             else if (sfu > 0)
01195                 HDispIt(49, 138, 61, 151, 165, 143);
01196             sfu = -1;
01197             sfs = -1;
01198             if (Data->P[plr].Misc[1].Num >= 0)
01199             {
01200                 sfu = ScaleAmt * Data->P[plr].Misc[1].Steps;
01201                 if (sfu > 0)
01202                 {
01203                     ov = Data->P[plr].Misc[1].Steps -
01204                         Data->P[plr].Misc[1].Failures;
01205                     un = Data->P[plr].Misc[1].Steps;
01206                     sfs = sfu * (ov / un);
01207                 }
01208             }
01209             if (sfu > 0)
01210             {
01211                 RectFill(226, 159 - sfu * 136 / 100, 254, 159, 9);
01212                 RectFill(226, 159 - sfu * 136 / 100, 253, 158, 8);
01213             }
01214             if (sfs > 0)
01215             {
01216                 RectFill(226, 159 - sfs * 136 / 100, 249, 159, 6);
01217                 RectFill(226, 159 - sfs * 136 / 100, 248, 158, 5);
01218             }
01219             if (plr == 0 && sfu > 0)
01220                 HDispIt(63, 131, 75, 151, 219, 136);
01221             else if (sfu > 0)
01222                 HDispIt(77, 129, 88, 151, 219, 134);
01223             sfu = -1;
01224             sfs = -1;
01225             if (Data->P[1].Misc[2].Num >= 0)
01226             {
01227                 sfu = ScaleAmt * Data->P[1].Misc[2].Steps;
01228                 if (sfu > 0)
01229                 {
01230                     ov = Data->P[1].Misc[2].Steps -
01231                         Data->P[1].Misc[2].Failures;
01232                     un = Data->P[1].Misc[2].Steps;
01233                     sfs = sfu * (ov / un);
01234                 }
01235             }
01236             if (sfu > 0 && plr == 1)
01237             {
01238                 RectFill(275, 159 - sfu * 136 / 100, 313, 159, 9);
01239                 RectFill(275, 159 - sfu * 136 / 100, 312, 158, 8);
01240             }
01241             if (sfs > 0 && plr == 1)
01242             {
01243                 RectFill(275, 159 - sfs * 136 / 100, 308, 159, 6);
01244                 RectFill(275, 159 - sfs * 136 / 100, 307, 158, 5);
01245             }
01246             if (sfu > 0 && plr == 1)
01247                 HDispIt(51, 77, 93, 127, 270, 106);
01248             break;
01249         default:
01250             break;
01251     };
01252 
01253     return;
01254 }
01255 
01256 void
01257 RankMe(char plr)
01258 {
01259     int i;
01260 
01261     FadeOut(2, pal, 5, 0, 0);
01262     PortPal(plr);
01263     gxClearDisplay(0, 0);
01264     ShBox(52, 0, 267, 32);
01265     ShBox(0, 0, 50, 32);
01266     ShBox(269, 0, 319, 32);
01267     DispBig(74, 4, "DIRECTOR RANKING", 0, -1);
01268     ShBox(0, 34, 319, 198);
01269     RectFill(25, 48, 293, 184, 4);
01270     RectFill(27, 50, 291, 182, 7);
01271     RectFill(28, 51, 290, 181, 0);
01272     RectFill(33, 56, 285, 176, 7);
01273     RectFill(34, 57, 284, 175, 0);
01274     grSetColor(7);
01275     grMoveTo(27, 50);
01276     grLineTo(33, 56);
01277     grMoveTo(27, 182);
01278     grLineTo(33, 176);
01279     grMoveTo(285, 56);
01280     grLineTo(291, 50);
01281     grMoveTo(285, 176);
01282     grLineTo(291, 182);
01283     grSetColor(7);
01284     for (i = 0; i < 22; i++)
01285     {
01286         if (i < 11)
01287         {
01288             grMoveTo(33, 56 + (i * 12));
01289             grLineTo(285, 56 + (i * 12));
01290         }
01291         grMoveTo(33 + (i * 12), 56);
01292         grLineTo(33 + (i * 12), 176);
01293     }
01294     grSetColor(16);
01295     grMoveTo(34, 152);
01296     grLineTo(284, 152);
01297     DrawRank(plr);
01298     if (Option == -1 || Option == 0)
01299     {
01300         RectFill(43, 66, 49, 70, 6);
01301         RectFill(43, 66, 48, 69, 5);
01302         grSetColor(1);
01303         PrintAt(56, 70, "U.S.A.");
01304     }
01305     if (Option == -1 || Option == 1)
01306     {
01307         RectFill(43, 78, 49, 82, 9);
01308         RectFill(43, 78, 48, 81, 8);
01309         PrintAt(56, 82, "U.S.S.R.");
01310     }
01311     FadeIn(2, pal, 5, 0, 0);
01312 
01313     WaitForMouseUp();
01314     while (1)
01315     {
01316         GetMouse();
01317         if ((x >= 0 && y >= 0 && x <= 319 && y <= 199 && mousebuttons > 0)
01318             || key == K_ENTER)
01319         {
01320             if (key > 0)
01321             {
01322                 delay(300);
01323                 key = 0;
01324             };
01325             WaitForMouseUp();
01326             key = 0;
01327             return;
01328         }
01329     };
01330 }
01331 
01332 void
01333 DrawRank(char plr)
01334 {
01335     int i, MaxPz = 0, MaxNg = 0, Px, Py, t1, t2, Cur = 0, OffSet, Year_Inc =
01336         12, score;
01337     char Digit[4];
01338 
01339     strcpy(IDT, "i030");
01340     strcpy(IKEY, "k030");
01341 
01342     //Win=Data->Prestige[22].Place;
01343     InBox(12, 4, 39, 20);
01344     InBox(281, 4, 308, 20);
01345     FlagSm(0, 13, 5);
01346     FlagSm(1, 282, 5);
01347     Px = 0;
01348     Py = 1;
01349     while (Px != -1 || Py != -1)
01350     {
01351         if (Px != -1)
01352             Cur = Px;
01353         else if (Py != -1)
01354             Cur = Py;
01355         t1 = 0;
01356         for (i = 0; i < Data->P[Cur].PastMis; i++)
01357         {
01358             if (Data->P[Cur].History[i].Prestige < -15)
01359                 Data->P[Cur].History[i].Prestige = 0;
01360             t1 += Data->P[Cur].History[i].Prestige;
01361             if (t1 >= 0)
01362             {
01363                 if (t1 >= MaxPz)
01364                     MaxPz = t1;
01365             }
01366             else if (t1 < 0)
01367             {
01368                 if (t1 <= MaxNg)
01369                     MaxNg = t1;
01370             }
01371         }
01372         if (Cur == Px)
01373             Px = -1;
01374         else if (Cur == Py)
01375             Py = -1;
01376     }
01377     OffSet = 0;
01378     for (i = 0; i < 50; i += 2)
01379     {
01380         if (MaxNg != 0)
01381         {
01382             if ((MaxNg >= -(i * 10)) && (MaxPz < i * 40))
01383                 if (OffSet == 0)
01384                     OffSet = i * 10;
01385         }
01386         else
01387         {
01388             if (MaxPz < i * 40)
01389                 if (OffSet == 0)
01390                     OffSet = i * 10;
01391         }
01392     }
01393     grSetColor(6);
01394     for (i = 0; i < 11; i++)
01395     {
01396         DispNum(29 + (24 * i), 43, (i * 2) + 57);
01397         DispNum(41 + (24 * i), 192, (i * 2) + 58);
01398     }
01399     grSetColor(6);
01400     for (i = 0; i < 6; i++)
01401     {
01402         switch (i)
01403         {
01404             case 0:
01405                 if (OffSet < 10)
01406                 {
01407                     DispNum(15, 178, -OffSet);
01408                     DispNum(311, 178, -OffSet);
01409                 }
01410                 else if (OffSet < 100)
01411                 {
01412                     DispNum(4, 178, -OffSet);
01413                     DispNum(300, 178, -OffSet);
01414                 }
01415                 else
01416                 {
01417                     DispNum(3, 178, -OffSet);
01418                     DispNum(299, 178, -OffSet);
01419                 }
01420                 break;
01421             case 1:
01422                 DispNum(10, 154, 0);
01423                 DispNum(306, 154, 0);
01424                 break;
01425             case 2:
01426             case 3:
01427             case 4:
01428             case 5:
01429                 if (OffSet * (i - 1) < 10)
01430                 {
01431                     DispNum(15, 178 - (i * 24), OffSet * (i - 1));
01432                     DispNum(311, 178 - (i * 24), OffSet * (i - 1));
01433                 }
01434                 else if (OffSet * (i - 1) < 100)
01435                 {
01436                     DispNum(6, 178 - (i * 24), OffSet * (i - 1));
01437                     DispNum(302, 178 - (i * 24), OffSet * (i - 1));
01438                 }
01439                 else
01440                 {
01441                     DispNum(3, 178 - (i * 24), OffSet * (i - 1));
01442                     DispNum(299, 178 - (i * 24), OffSet * (i - 1));
01443                 }
01444                 break;
01445             default:
01446                 break;
01447         }
01448     }
01449     //Win=Data->Prestige[22].Place;
01450     i = 0;
01451     t1 = 152;
01452     t2 = 0;
01453     grSetColor(5);
01454     grMoveTo(34, 152);
01455     //if ((Option==-1 && MAIL==-1) || Option==0 || MAIL==0)
01456 
01457     if (Option == -1 || Option == 0)
01458         while (i < Data->P[0].PastMis)
01459         {
01460             t2 = 0;
01461             t2 = Data->P[0].History[i].Prestige;
01462             t1 = t1 - (t2 * ((float) 24 / OffSet));
01463             grLineTo(34 + Year_Inc * (Data->P[0].History[i].MissionYear -
01464                     57) + Data->P[0].History[i].Month, t1);
01465             i++;
01466         }
01467     i = 0;
01468     t1 = 152;
01469     t2 = 0;
01470     grSetColor(9);
01471     grMoveTo(34, 152);
01472     //if ((Option==-1 && MAIL==-1) || Option==1 || MAIL==1)
01473 
01474     if (Option == -1 || Option == 1)
01475         while (i < Data->P[1].PastMis)
01476         {
01477             t2 = 0;
01478             t2 = Data->P[1].History[i].Prestige;
01479             t1 = t1 - (t2 * ((float) 24 / OffSet));
01480             grLineTo(34 + Year_Inc * (Data->P[1].History[i].MissionYear -
01481                     57) + Data->P[1].History[i].Month, t1);
01482             i++;
01483         }
01484     grSetColor(1);
01485     PrintAt(6, 27, "LEVEL:");
01486     PrintAt(275, 27, "LEVEL:");
01487     grSetColor(0);
01488     DispNum(41, 27, Data->Def.Lev1 + 1);
01489     grSetColor(0);
01490     DispNum(310, 27, Data->Def.Lev2 + 1);
01491     if (Option == -1 || Option == 0)
01492     {
01493         InBox(55, 21, 116, 29);
01494         grSetColor(1);
01495         PrintAt(57, 27, "SCORE:");
01496         score = 0;
01497         score = CalcScore(0, Data->Def.Lev1, Data->Def.Lev2);
01498         sprintf(&Digit[0], "%d", score);
01499         PrintAt(92, 27, &Digit[0]);
01500     }
01501     if (Option == -1 || Option == 1)
01502     {
01503         InBox(203, 21, 264, 29);
01504         grSetColor(1);
01505         PrintAt(205, 27, "SCORE:");
01506         score = CalcScore(1, Data->Def.Lev2, Data->Def.Lev1);
01507         sprintf(&Digit[0], "%d", score);
01508         PrintAt(240, 27, &Digit[0]);
01509     }
01510 
01511 }
01512 
01513 int
01514 CalcScore(char plr, char lvA, char lvB)
01515 {
01516     char i;
01517     int total = 0;
01518 
01519     ++lvA;
01520     ++lvB;
01521     for (i = 0; i < Data->P[plr].PastMis; i++)
01522     {
01523         if (Data->P[plr].History[i].Prestige > 0)
01524         {
01525             switch (lvA)
01526             {
01527                 case 1:
01528                     total += Data->P[plr].History[i].Prestige;
01529                     break;
01530                 case 2:
01531                     if (lvB == 1)
01532                         total +=
01533                             2 * Data->P[plr].History[i].Prestige +
01534                             Data->P[plr].History[i].Prestige / 3;
01535                     else if (lvB == 3)
01536                         total +=
01537                             2 * Data->P[plr].History[i].Prestige +
01538                             Data->P[plr].History[i].Prestige / 3;
01539                     else
01540                         total += 2 * Data->P[plr].History[i].Prestige;
01541                     break;
01542                 case 3:
01543                     if (lvB == 1)
01544                         total +=
01545                             2 * Data->P[plr].History[i].Prestige +
01546                             (2 * Data->P[plr].History[i].Prestige) / 3;
01547                     else if (lvB == 2)
01548                         total +=
01549                             3 * Data->P[plr].History[i].Prestige +
01550                             Data->P[plr].History[i].Prestige / 3;
01551                     else
01552                         total += 3 * Data->P[plr].History[i].Prestige;
01553                     break;
01554                 default:
01555                     break;
01556             }
01557         }
01558     }
01559     if (plr == Data->Prestige[22].Place)
01560     {
01561         if (lvA == 1)
01562         {
01563             if (Data->Year <= 67)
01564                 total += 50;
01565             else if (Data->Year <= 69)
01566                 total += 25;
01567         }
01568         else if (lvA == 2)
01569         {
01570             if (Data->Year <= 67)
01571                 total += 75;
01572             else if (Data->Year <= 69)
01573                 total += 50;
01574             else if (Data->Year <= 73)
01575                 total += 25;
01576         }
01577         else if (lvA == 3)
01578         {
01579             if (Data->Year <= 67)
01580                 total += 150;
01581             else if (Data->Year <= 69)
01582                 total += 75;
01583             else if (Data->Year <= 73)
01584                 total += 50;
01585         }
01586     }
01587     return (total);
01588 }
01589 
01590 /* EOF */
Generated on Fri Sep 28 00:35:45 2007 for raceintospace by  doxygen 1.5.3