home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Inne / Gry / Atomic_Tanks / Atomic-Tanks-5.1.exe / src / environment.cpp < prev    next >
C/C++ Source or Header  |  2010-09-05  |  38KB  |  1,040 lines
  1. /*
  2.  * atanks - obliterate each other with oversize weapons
  3.  * Copyright (C) 2003  Thomas Hudson
  4.  *
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * */
  19.  
  20.  
  21. #include "environment.h"
  22. #include "globaldata.h"
  23. #include "virtobj.h"
  24. #include "missile.h"
  25. #include "tank.h"
  26. #include "files.h"
  27.  
  28. ENVIRONMENT::ENVIRONMENT (GLOBALDATA *global):_global(global),done(NULL),fp(NULL),h(NULL),surface(NULL),dropTo(NULL),
  29.     velocity(NULL),dropIncr(NULL),height(NULL),db(NULL),terrain(NULL),sky(NULL)
  30. {
  31.   gravity = 0.150;
  32.   viscosity = 0.5;
  33.   landSlideType = LANDSLIDE_GRAVITY;
  34.   landSlideDelay = MAX_GRAVITY_DELAY;
  35.   windstrength = 8;
  36.   windvariation = 1;
  37.   weapontechLevel = itemtechLevel = 5;
  38.   landType = LANDTYPE_RANDOM;
  39.   meteors = 0;
  40.   lightning = 0;
  41.   satellite = 0.0;
  42.   falling_dirt_balls = 0.0;
  43.   fog = 0;
  44.   wallType = 0.0;
  45.   dBoxedMode        =    0.0;    // default is 0 = off
  46.   dFadingText        =    0.0;    // defaults to 0 for backwards compatibilities sake
  47.   dShadowedText    =    0.0;    // defaults to 0 for backwards compatibilities sake
  48.   current_wallType = 0;
  49.   custom_background = 0.0;
  50.   bitmap_filenames = NULL;
  51.   number_of_bitmaps = 0;
  52.   current_drawing_mode = DRAW_MODE_SOLID;
  53.  
  54.   done = new char[global->screenWidth];
  55.   fp = new int[global->screenWidth];
  56.   h = new int[global->screenWidth];
  57.   surface = new int[global->screenWidth];
  58.   dropTo = new int[global->screenWidth];
  59.   velocity = new double[global->screenWidth];
  60.   dropIncr = new double[global->screenWidth];
  61.   height = new double[global->screenWidth];
  62.  
  63.   db = create_bitmap (global->screenWidth, global->screenHeight);
  64.   if (!db)
  65.     cout << "Failed to create db bitmap: " << allegro_error;
  66.   terrain = create_bitmap (global->screenWidth, global->screenHeight);
  67.   if (!terrain)
  68.     cout << "Failed to create terrain bitmap: " << allegro_error;
  69.   sky = create_bitmap (global->screenWidth, global->screenHeight - MENUHEIGHT);
  70.   if (!sky)
  71.     cout << "Failed to create sky bitmap: " << allegro_error;
  72.   waiting_sky = NULL;
  73.   waiting_terrain = NULL;
  74.   _global = global;
  75.   global_tank_index = 0;
  76.  
  77.   initialise ();
  78. }
  79.  
  80.  
  81.  
  82. /** @brief ~ENVIRONMENT default dtor
  83.  *  *   *
  84.  *   *     * Cleanly remove created objects
  85.  *    *       */
  86. ENVIRONMENT::~ENVIRONMENT()
  87. {
  88.   int count;
  89.  
  90.   if (db)      destroy_bitmap(db);      db      = NULL;
  91.   if (sky)     destroy_bitmap(sky);     sky     = NULL;
  92.   if (waiting_sky) destroy_bitmap(sky); waiting_sky = NULL;
  93.   if (terrain) destroy_bitmap(terrain); terrain = NULL;
  94.  
  95.   _global = NULL;
  96.  
  97.   if (done)     delete [] (done);     done = NULL;
  98.   if (fp)       delete [] (fp);       fp = NULL;
  99.   if (h)        delete [] (h);        h = NULL;
  100.   if (surface)  delete [] (surface);  surface = NULL;
  101.   if (dropTo)   delete [] (dropTo);   dropTo = NULL;
  102.   if (velocity) delete [] (velocity); velocity = NULL;
  103.   if (dropIncr) delete [] (dropIncr); dropIncr = NULL;
  104.   if (height)   delete [] (height);   height = NULL;
  105.   if (bitmap_filenames)
  106.   {
  107.      for (count = 0; count < number_of_bitmaps; count++)
  108.      {
  109.         if (bitmap_filenames[count]) 
  110.            free(bitmap_filenames[count]);
  111.      }
  112.      free(bitmap_filenames);
  113.   }
  114. }
  115.  
  116.  
  117.  
  118. /*
  119. This function saves the environment settings to a text
  120. file. Each line has the format
  121. name=value\n
  122.  
  123. The function returns TRUE on success and FALSE on failure.
  124. -- Jesse
  125. */
  126. int ENVIRONMENT::saveToFile_Text (FILE *file)
  127. {
  128.   if (! file) return FALSE;
  129.  
  130.   fprintf (file, "*ENV*\n");
  131.  
  132.   fprintf (file, "WINDSTRENGTH=%f\n", windstrength);
  133.   fprintf (file, "WINDVARIATION=%f\n", windvariation);
  134.   fprintf (file, "VISCOSITY=%f\n", viscosity);
  135.   fprintf (file, "GRAVITY=%f\n", gravity);
  136.   fprintf (file, "WEAPONTECHLEVEL=%f\n", weapontechLevel);
  137.   fprintf (file, "ITEMTECHLEVEL=%f\n", itemtechLevel);
  138.   fprintf (file, "METEORS=%f\n", meteors);
  139.   fprintf (file, "LIGHTNING=%f\n", lightning);
  140.   fprintf (file, "SATELLITE=%f\n", satellite);
  141.   fprintf (file, "FOG=%f\n", fog);
  142.   fprintf (file, "LANDTYPE=%f\n", landType);
  143.   fprintf (file, "LANDSLIDETYPE=%f\n", landSlideType);
  144.   fprintf (file, "WALLTYPE=%f\n", wallType);
  145.   fprintf (file, "BOXMODE=%f\n", dBoxedMode);
  146.   fprintf (file, "TEXTFADE=%f\n", dFadingText);
  147.   fprintf (file, "TEXTSHADOW=%f\n", dShadowedText);
  148.   fprintf (file, "LANDSLIDEDELAY=%f\n", landSlideDelay);
  149.   fprintf (file, "FALLINGDIRTBALLS=%f\n", falling_dirt_balls);
  150.   fprintf (file, "CUSTOMBACKGROUND=%f\n", custom_background);
  151.   fprintf (file, "***\n");
  152.   return TRUE;
  153. }
  154.  
  155. /*
  156. This function loads environment settings from a text
  157. file. The function returns TRUE on success and FALSE if
  158. any erors are encountered.
  159. -- Jesse
  160. */
  161. int ENVIRONMENT::loadFromFile_Text (FILE *file)
  162. {
  163.   char line[MAX_CONFIG_LINE];
  164.   int equal_position, line_length;
  165.   char field[MAX_CONFIG_LINE], value[MAX_CONFIG_LINE];
  166.   char *result = NULL;
  167.   bool done = false;
  168.  
  169.   // read until we hit line (char *)"*ENV*" or "***" or EOF
  170.   do
  171.     {
  172.       result = fgets(line, MAX_CONFIG_LINE, file);
  173.       if (! result)     // eof
  174.         return FALSE;
  175.       if (! strncmp(line, "***", 3) )     // end of record
  176.         return FALSE;
  177.     }
  178.   while ( strncmp(line, "*ENV*", 5) );     // read until we hit new record
  179.  
  180.   while ( (result) && (!done) )
  181.     {
  182.       // read a line
  183.       memset(line, '\0', MAX_CONFIG_LINE);
  184.       result = fgets(line, MAX_CONFIG_LINE, file);
  185.       if (result)
  186.         {
  187.           // if we hit end of the record, stop
  188.           if (! strncmp(line, "***", 3) ) return TRUE;
  189.           // find equal sign
  190.           line_length = strlen(line);
  191.           // strip newline character
  192.           if ( line[line_length - 1] == '\n')
  193.             {
  194.               line[line_length - 1] = '\0';
  195.               line_length--;
  196.             }
  197.           equal_position = 1;
  198.           while ( ( equal_position < line_length) && (line[equal_position] != '=') )
  199.             equal_position++;
  200.           // make sure we have valid equal sign
  201.  
  202.           if ( equal_position <= line_length )
  203.             {
  204.               // seperate field from value
  205.               memset(field, '\0', MAX_CONFIG_LINE);
  206.               memset(value, '\0', MAX_CONFIG_LINE);
  207.               strncpy(field, line, equal_position);
  208.               strcpy(value, & (line[equal_position + 1]));
  209.               // check for fields and values
  210.               if (! strcasecmp(field, "windstrength") )
  211.                 sscanf(value, "%lf", &windstrength);
  212.               else if (! strcasecmp(field, "windvariation") )
  213.                 sscanf(value, "%lf", &windvariation);
  214.               else if (! strcasecmp(field, "viscosity") )
  215.                 sscanf(value, "%lf", &viscosity);
  216.               else if (! strcasecmp(field, "gravity") )
  217.                 sscanf(value, "%lf", &gravity);
  218.               else if (! strcasecmp(field, "techlevel"))
  219.                 {
  220.                   sscanf(value, "%lf", &weapontechLevel);
  221.                   itemtechLevel = weapontechLevel;    // for backward compatibility
  222.                 }
  223.               else if (! strcasecmp(field, "weapontechlevel") )
  224.                 sscanf(value, "%lf", &weapontechLevel);
  225.               else if (! strcasecmp(field, "itemtechlevel") )
  226.                 sscanf(value, "%lf", &itemtechLevel);
  227.               else if (! strcasecmp(field, "meteors"))
  228.                 sscanf(value, "%lf", &meteors);
  229.               else if (! strcasecmp(field, "lightning") )
  230.                 sscanf(value, "%lf", &lightning);
  231.               else if (! strcasecmp(field, "satellite") )
  232.                 sscanf(value, "%lf", &satellite);
  233.               else if (! strcasecmp(field, "fog") )
  234.                 sscanf(value, "%lf", &fog);
  235.               else if (! strcasecmp(field, "landtype"))
  236.                 sscanf(value, "%lf", &landType);
  237.               else if (! strcasecmp(field, "landslidetype"))
  238.                 sscanf(value, "%lf", &landSlideType);
  239.               else if (! strcasecmp(field, "walltype"))
  240.                 sscanf(value, "%lf", &wallType);
  241.               else if (! strcasecmp(field, "boxmode"))
  242.                 sscanf(value, "%lf", &dBoxedMode);
  243.               else if (! strcasecmp(field, "textfade"))
  244.                 sscanf(value, "%lf", &dFadingText);
  245.               else if (! strcasecmp(field, "textshadow"))
  246.                 sscanf(value, "%lf", &dShadowedText);
  247.               else if (! strcasecmp(field, "landslidedelay"))
  248.                 sscanf(value, "%lf", &landSlideDelay);
  249.               else if (! strcasecmp(field, "fallingdirtballs") )
  250.                 sscanf(value, "%lf", &falling_dirt_balls);
  251.               else if (! strcasecmp(field, "custombackground") )
  252.                 sscanf(value, "%lf", &custom_background);
  253.  
  254.             }    // end of found field=value line
  255.  
  256.         }     // end of read a line properly
  257.     }     // end of while not done
  258.  
  259.   return TRUE;
  260. }
  261.  
  262.  
  263.  
  264. void ENVIRONMENT::initialise ()
  265. {
  266.   for (int count = 0; count < _global->screenWidth; count++)
  267.     {
  268.       h[count] = 0;
  269.       fp[count] = 0;
  270.       done[count] = 1;
  271.       dropTo[count] = _global->screenHeight - 1;
  272.       surface[count] = 0;
  273.     }
  274.   for (int count = 0; count < MAX_OBJECTS; count++)
  275.     objects[count] = NULL;
  276.   for (int count = 0; count < MAXPLAYERS; count++)
  277.     order[count] = NULL;
  278.  
  279.   clear_to_color (sky, PINK);
  280.   clear_to_color (db, WHITE);
  281.   clear_to_color (terrain, PINK);
  282.  
  283.   // oldFogX = 0;
  284.   // oldFogY = 0;
  285.  
  286.   combineUpdates = TRUE;
  287. }
  288.  
  289. int ENVIRONMENT::isItemAvailable (int itemNum)
  290. {
  291.   if (itemNum < WEAPONS)
  292.     {
  293.       if ((weapon[itemNum].warhead) ||
  294.           (weapon[itemNum].techLevel > weapontechLevel))
  295.         return (FALSE);
  296.     }
  297.   else if (item[itemNum - WEAPONS].techLevel > itemtechLevel)
  298.     {
  299.       return (FALSE);
  300.     }
  301.   return (TRUE);
  302. }
  303.  
  304. void ENVIRONMENT::generateAvailableItemsList ()
  305. {
  306.   int slot = 0;
  307.   for (int itemNum = 0; itemNum < THINGS; itemNum++)
  308.     {
  309.       if (!isItemAvailable (itemNum))
  310.         continue;
  311.       availableItems[slot] = itemNum;
  312.       slot++;
  313.     }
  314.   numAvailable = slot;
  315. }
  316.  
  317. int ENVIRONMENT::addObject (VIRTUAL_OBJECT *object)
  318. {
  319.   int objCount = 0;
  320.  
  321.   while ((objects[objCount] != NULL) && (objCount < MAX_OBJECTS))
  322.     objCount++;
  323.   if (objCount < MAX_OBJECTS)
  324.     objects[objCount] = object;
  325.  
  326.   return (objCount);
  327. }
  328.  
  329. int ENVIRONMENT::removeObject (VIRTUAL_OBJECT *object)
  330. {
  331.   int objCount  = object->getIndex();
  332.   int objClass  = object->getClass();
  333.  
  334.   object->requireUpdate();
  335.   object->update();
  336.  
  337.   if (objCount < MAX_OBJECTS)
  338.     {
  339.       objects[objCount] = NULL;
  340.       if (objClass == TANK_CLASS)
  341.         for (int ordCount = 0; ordCount < MAXPLAYERS; ordCount++)
  342.           if (order[ordCount] == object)
  343.             order[ordCount] = NULL;
  344.     }
  345.   else
  346.     {
  347.       return (objCount);
  348.     }
  349.  
  350.   return (0);
  351. }
  352.  
  353. VIRTUAL_OBJECT *ENVIRONMENT::getNextOfClass (int classNum, int *objCount)
  354. {
  355.   for (;*objCount < MAX_OBJECTS; (*objCount)++)
  356.     {
  357.       if ((objects[*objCount] != NULL) &&
  358.           ((classNum == ANY_CLASS) || (classNum == objects[*objCount]->getClass ())))
  359.         break;
  360.     }
  361.  
  362.   if (*objCount < MAX_OBJECTS)
  363.     return (objects[*objCount]);
  364.   else
  365.     return (NULL);
  366. }
  367.  
  368. void ENVIRONMENT::newRound ()
  369. {
  370.   for (int objCount = 0; objCount < MAX_OBJECTS; objCount++)
  371.     {
  372.       if (objects[objCount])
  373.         {
  374.           if ((!objects[objCount]->isSubClass (TANK_CLASS)) &&
  375.               (!objects[objCount]->isSubClass (FLOATTEXT_CLASS)))
  376.             {
  377.               delete objects[objCount];
  378.               objects[objCount] = NULL;
  379.             }
  380.           else if (objects[objCount]->isSubClass (TANK_CLASS))
  381.             ((TANK *)objects[objCount])->newRound();
  382.         }
  383.     }
  384.  
  385.   naturals_since_last_shot = 0;
  386.   // set wall type
  387.   if (wallType == WALL_RANDOM)
  388.     current_wallType = rand() % 4;
  389.   else
  390.     current_wallType = (int) wallType;
  391.  
  392.   // time_to_fall = (rand() % MAX_GRAVITY_DELAY) + 1;
  393.   time_to_fall = (rand() & (int)landSlideDelay) + 1;
  394.   global_tank_index = 0;
  395. }
  396.  
  397. int ENVIRONMENT::ingamemenu ()
  398. {
  399.   int button[INGAMEBUTTONS];
  400.   int pressed = -1;
  401.   int updatew[INGAMEBUTTONS];
  402.   char *buttext[INGAMEBUTTONS];
  403.   buttext[0] = _global->ingame->complete_text[69];
  404.   buttext[1] =  _global->ingame->complete_text[70];
  405.   buttext[2] = _global->ingame->complete_text[71];
  406.   buttext[3] =  _global->ingame->complete_text[72];
  407.   // char buttext_de[INGAMEBUTTONS][32] = { "Zuruck", "Hauptmenu", "Verlassen", "Skip AI" };
  408.   int z, zz;
  409.  
  410.   // Set/calcualte button size and positions
  411.   int button_width = 150;
  412.   int button_height = 20;
  413.   int button_space = 5;
  414.   int button_halfwidth = button_width / 2;
  415.   // int button_halfheight = button_height / 2;
  416.   int dialog_width = 200;
  417.   int dialog_height = ((INGAMEBUTTONS + 2) * button_height) + ((INGAMEBUTTONS + 1) * button_space);
  418.   int dialog_halfwidth = dialog_width / 2;
  419.   int dialog_halfheight = dialog_height / 2;
  420.  
  421.   // Calculate button y values and set all button status to 0
  422.   int y = -dialog_halfheight + button_height + button_space;
  423.  
  424.   for (z = 0; z < INGAMEBUTTONS; z++)
  425.   {
  426.     updatew[z] = 0;
  427.     button[z] = y;
  428.     y += button_height + button_space;
  429.   }
  430.  
  431.   if (! _global->os_mouse) show_mouse (NULL);
  432.    make_update (_global->halfWidth - dialog_halfwidth, _global->halfHeight - dialog_halfheight, dialog_width, dialog_height);
  433.    rectfill (db, _global->halfWidth - dialog_halfwidth, _global->halfHeight - dialog_halfheight, _global->halfWidth + dialog_halfwidth - 1, _global->halfHeight + dialog_halfheight - 1, makecol (128, 128, 128));
  434.    rect (db, _global->halfWidth - dialog_halfwidth, _global->halfHeight - dialog_halfheight, _global->halfWidth + dialog_halfwidth - 1, _global->halfHeight + dialog_halfheight - 1, BLACK);
  435.  
  436.  
  437.   while (1)
  438.     {
  439.       LINUX_SLEEP;
  440.       if (keypressed ())
  441.         {
  442.           k = readkey ();
  443.           if ( (k >> 8 == KEY_ESC) || (k >> 8 == KEY_P) )
  444.             return (0);
  445.         }
  446.  
  447.       if (mouse_b & 1)
  448.         {
  449.           zz = 0;
  450.           for (z = 0; z < INGAMEBUTTONS; z++)
  451.             {
  452.                 if (mouse_x >= _global->halfWidth - button_halfwidth && mouse_x < _global->halfWidth + button_halfwidth && mouse_y >= button[z] + _global->halfHeight
  453.                    && mouse_y < button[z] + button_height + _global->halfHeight)
  454.                 {
  455.                   zz = 1;
  456.                   if (pressed > -1)
  457.                     updatew[pressed] = 1;
  458.                   pressed = z;
  459.                   updatew[z] = 1;
  460.                 }
  461.             }
  462.           if (!zz)
  463.             {
  464.               if (pressed > -1)
  465.                 updatew[pressed] = 1;
  466.               pressed = -1;
  467.             }
  468.         }
  469.       if (pressed > -1 && !mouse_b & 1)
  470.         return (pressed);
  471.       for (z = 0; z < INGAMEBUTTONS; z++)
  472.         {
  473.           if (updatew[z])
  474.             {
  475.               updatew[z] = 0;
  476.               make_update (_global->halfWidth - button_halfwidth, _global->halfHeight + button[z], button_width, button_height);
  477.             }
  478.         }
  479.       make_update (mouse_x, mouse_y, ((BITMAP *) (_global->misc[0]))->w, ((BITMAP *) (_global->misc[0]))->h);
  480.       make_update (lx, ly, ((BITMAP *) (_global->misc[0]))->w, ((BITMAP *) (_global->misc[0]))->h);
  481.       lx = mouse_x;
  482.       ly = mouse_y;
  483.       if (! _global->os_mouse)  show_mouse (NULL);
  484.       for (z = 0; z < INGAMEBUTTONS; z++)
  485.         {
  486.           draw_sprite (db, (BITMAP *) _global->misc[(pressed == z) ? 8 : 7], _global->halfWidth - button_halfwidth, _global->halfHeight + button[z]);
  487.           textout_centre_ex (db, font, buttext[z], _global->halfWidth, _global->halfHeight + button[z] + 6, WHITE, -1);
  488.         }
  489.       if (! _global->os_mouse) show_mouse (db);
  490.       do_updates ();
  491.     }
  492. }
  493.  
  494. void ENVIRONMENT::do_updates ()
  495. {
  496.   int count;
  497.  
  498.   bool bIsBgUpdNeeded = false;
  499.   if (_global->lastUpdatesCount)
  500.     bIsBgUpdNeeded = true;
  501.  
  502.   if (_global->updateCount >= MAXUPDATES)
  503.     make_fullUpdate();
  504.   else
  505.     {
  506.       for (count = 0; count < _global->updateCount && count < MAXUPDATES; count++)
  507.         {
  508.           blit (db, screen, _global->updates[count].x, _global->updates[count].y, _global->updates[count].x, _global->updates[count].y, _global->updates[count].w, _global->updates[count].h);
  509.           // Debug rectangle
  510.           //rect (screen, _global->updates[count].x, _global->updates[count].y, _global->updates[count].x + _global->updates[count].w, _global->updates[count].y + _global->updates[count].h, WHITE);
  511.           if (bIsBgUpdNeeded)
  512.             make_bgupdate(_global->updates[count].x, _global->updates[count].y, _global->updates[count].w, _global->updates[count].h);
  513.         }
  514.  
  515.       if (!bIsBgUpdNeeded)
  516.         {
  517.           _global->lastUpdatesCount = _global->updateCount;
  518.           memcpy (_global->lastUpdates, _global->updates, sizeof (BOX) * _global->updateCount);
  519.         }
  520.       _global->updateCount = 0;
  521.     }
  522. }
  523.  
  524. void ENVIRONMENT::replaceCanvas ()
  525. {
  526.   int count;
  527.  
  528.   if (_global->lastUpdatesCount >= MAXUPDATES)
  529.     make_fullUpdate();
  530.   else
  531.     {
  532.       for (count = 0; count < _global->lastUpdatesCount && count < MAXUPDATES; count++)
  533.         {
  534.           blit (sky, db, _global->lastUpdates[count].x, _global->lastUpdates[count].y - MENUHEIGHT, _global->lastUpdates[count].x, _global->lastUpdates[count].y, _global->lastUpdates[count].w, _global->lastUpdates[count].h);
  535.           masked_blit (terrain, db, _global->lastUpdates[count].x, _global->lastUpdates[count].y, _global->lastUpdates[count].x, _global->lastUpdates[count].y, _global->lastUpdates[count].w, _global->lastUpdates[count].h);
  536.         }
  537.           #ifdef NEW_GAMELOOP
  538.           int iLeft = 0;
  539.           int iRight = _global->screenWidth - 1;
  540.           int iTop = MENUHEIGHT;
  541.           int iBottom = _global->screenHeight - 1;
  542.  
  543.           vline(db, iLeft, iTop, iBottom, wallColour);    // Left edge
  544.           vline(db, iLeft + 1, iTop, iBottom, wallColour);    // Left edge
  545.           vline(db, iRight, iTop, iBottom, wallColour);   // right edge
  546.           vline(db, iRight - 1, iTop, iBottom, wallColour);   // right edge
  547.           hline(db, iLeft, iBottom, iRight, wallColour);// bottom edge
  548.           if (_global->bIsBoxed)
  549.               hline(db, iLeft, iTop, iRight, wallColour);// top edge
  550.           #endif
  551.       _global->lastUpdatesCount = 0;
  552.       // The menu needs to be redrawn:
  553.       make_update(0, 0, _global->screenWidth - 1, MENUHEIGHT);
  554.     }
  555. }
  556.  
  557. void ENVIRONMENT::make_update (int x, int y, int w, int h)
  558. {
  559.   int combined = 0;
  560.   if (combineUpdates && _global->updateCount && _global->updateCount < MAXUPDATES)
  561.     {
  562.       BOX prev, next;
  563.       prev.x = _global->updates[_global->updateCount - 1].x;
  564.       prev.y = _global->updates[_global->updateCount - 1].y;
  565.       // .w = .x + .w = x2 (aka renamed to be the right x-position)
  566.       prev.w = _global->updates[_global->updateCount - 1].x + _global->updates[_global->updateCount - 1].w;
  567.       // .h = .y + .h = y2 (aka renamed to be the bottom y-position)
  568.       prev.h = _global->updates[_global->updateCount - 1].y + _global->updates[_global->updateCount - 1].h;
  569.  
  570.       next.x = x;
  571.       next.y = y;
  572.       next.w = x + w; // same as above, becoming x2 and not the width!
  573.       next.h = y + h; // same as above, becoming y2 and not the height!
  574.  
  575.       if (((next.w > prev.x - 3) && (prev.w > next.x - 3)) &&
  576.           ((next.h > prev.y - 3) && (prev.h > next.y - 3)))
  577.         {
  578.           next.x = (next.x < prev.x)?next.x:prev.x;
  579.           next.y = (next.y < prev.y)?next.y:prev.y;
  580.           next.w = (next.w > prev.w)?next.w:prev.w;
  581.           next.h = (next.h > prev.h)?next.h:prev.h;
  582.           _global->updates[_global->updateCount - 1].x = next.x;
  583.           _global->updates[_global->updateCount - 1].y = next.y;
  584.           _global->updates[_global->updateCount - 1].w = next.w - next.x;
  585.           _global->updates[_global->updateCount - 1].h = next.h - next.y;
  586.           combined = 1;
  587.         }
  588.     }
  589.   if (!combined)
  590.     {
  591.       _global->updates[_global->updateCount].x = x;
  592.       _global->updates[_global->updateCount].y = y;
  593.       _global->updates[_global->updateCount].w = w;
  594.       _global->updates[_global->updateCount].h = h;
  595.       if (_global->updateCount < MAXUPDATES)
  596.         _global->updateCount++;
  597.     }
  598.  
  599.   if (_global->updateCount >= MAXUPDATES)
  600.     make_fullUpdate();
  601.   else if (!_global->stopwindow)
  602.     {
  603.       if (x < _global->window.x)
  604.         _global->window.x = x;
  605.       if (y < _global->window.y)
  606.         _global->window.y = y;
  607.       if (x + w > _global->window.w)
  608.         _global->window.w = (x + w) - 1;
  609.       if (y + h > _global->window.h)
  610.         _global->window.h = (y + h) - 1;
  611.       if (_global->window.x < 0)
  612.         _global->window.x = 0;
  613.       if (_global->window.y < MENUHEIGHT)
  614.         _global->window.y = MENUHEIGHT;
  615.       if (_global->window.w > (_global->screenWidth-1))
  616.         _global->window.w = (_global->screenWidth-1);
  617.       if (_global->window.h > (_global->screenHeight-1))
  618.         _global->window.h = (_global->screenHeight-1);
  619.     }
  620. }
  621.  
  622. void ENVIRONMENT::make_bgupdate (int x, int y, int w, int h)
  623. {
  624.   int combined = 0;
  625.   if (_global && combineUpdates && _global->lastUpdatesCount && (_global->lastUpdatesCount < MAXUPDATES))
  626.     {
  627.       BOX prev, next;
  628.       prev.x = _global->lastUpdates[_global->lastUpdatesCount - 1].x;
  629.       prev.y = _global->lastUpdates[_global->lastUpdatesCount - 1].y;
  630.       prev.w = _global->lastUpdates[_global->lastUpdatesCount - 1].x + _global->lastUpdates[_global->lastUpdatesCount - 1].w;
  631.       prev.h = _global->lastUpdates[_global->lastUpdatesCount - 1].y + _global->lastUpdates[_global->lastUpdatesCount - 1].h;
  632.  
  633.       next.x = x;
  634.       next.y = y;
  635.       next.w = x + w;
  636.       next.h = y + h;
  637.  
  638.       if (((next.w > prev.x - 3) && (prev.w > next.x - 3)) &&
  639.           ((next.h > prev.y - 3) && (prev.h > next.y - 3)))
  640.         {
  641.           next.x = (next.x < prev.x)?next.x:prev.x;
  642.           next.y = (next.y < prev.y)?next.y:prev.y;
  643.           next.w = (next.w > prev.w)?next.w:prev.w;
  644.           next.h = (next.h > prev.h)?next.h:prev.h;
  645.           _global->lastUpdates[_global->lastUpdatesCount - 1].x = next.x;
  646.           _global->lastUpdates[_global->lastUpdatesCount - 1].y = next.y;
  647.           _global->lastUpdates[_global->lastUpdatesCount - 1].w = next.w - next.x;
  648.           _global->lastUpdates[_global->lastUpdatesCount - 1].h = next.h - next.y;
  649.           combined = 1;
  650.         }
  651.     }
  652.   if (_global && !combined)
  653.     {
  654.       _global->lastUpdates[_global->lastUpdatesCount].x = x;
  655.       _global->lastUpdates[_global->lastUpdatesCount].y = y;
  656.       _global->lastUpdates[_global->lastUpdatesCount].w = w;
  657.       _global->lastUpdates[_global->lastUpdatesCount].h = h;
  658.       if (_global->lastUpdatesCount < MAXUPDATES)
  659.         _global->lastUpdatesCount++;
  660.     }
  661.  
  662.   if (_global && _global->lastUpdatesCount >= MAXUPDATES)
  663.     make_fullUpdate();
  664. }
  665.  
  666. void ENVIRONMENT::make_fullUpdate()
  667. {
  668.   // Replace Updates with a full screen update:
  669.   int iOldCombUpd = combineUpdates;
  670.   combineUpdates = 0;
  671.  
  672.   // They are splitted into 4 x 2 updates:
  673.   int iQuartWidth = _global->halfWidth / 2;
  674.   int iHalfHeight = _global->halfHeight;
  675.  
  676.   _global->updateCount = 0;
  677.   for (int x = 0; x < 4; x++)
  678.     for (int y = 0; y < 2; y++)
  679.       make_update(iQuartWidth *        x        , iHalfHeight *        y,
  680.                   iQuartWidth * (x+1)    , iHalfHeight *    (y+1));
  681.  
  682.   _global->lastUpdatesCount = 0;
  683.   for (int x = 0; x < 4; x++)
  684.     for (int y = 0; y < 2; y++)
  685.       make_bgupdate(iQuartWidth *        x        , iHalfHeight *        y,
  686.                     iQuartWidth * (x+1)    , iHalfHeight *    (y+1));
  687.  
  688.   combineUpdates = iOldCombUpd;
  689. }
  690.  
  691.  
  692.  
  693.  
  694.  
  695. int ENVIRONMENT::getAvgBgColor(int aTopLeftX, int aTopLeftY, int aBotRightX, int aBotRightY, double aVelX, double aVelY)
  696.     {
  697.       // Coordinate sets:
  698.       int iLeftX    = aTopLeftX;
  699.       int iRightX    = aBotRightX;
  700.       int iCentX;    // Will be calculated later
  701.       int iTopY        =    aTopLeftY;
  702.       int iBottomY=    aBotRightY;
  703.       int iCentY; // Will be calculated later!
  704.  
  705.       // Colors:
  706.       int iColorToLe, iColorToCe, iColorToRi;    // top row
  707.       int iColorCeLe, iColorCeCe, iColorCeRi; // center row
  708.       int iColorBoLe, iColorBoCe, iColorBoRi; // bottom row
  709.       int iRed = 0;
  710.       int iGreen = 0;
  711.       int iBlue = 0;
  712.  
  713.       // Get the coordinates into range:
  714.       if (aTopLeftX     < 1)                                                    iLeftX = 1;
  715.       if (aTopLeftX     > (_global->screenWidth - 2))    iLeftX = _global->screenWidth - 2;
  716.       if (aBotRightX    <    1)                                                    iRightX= 1;
  717.       if (aBotRightX    >    (_global->screenWidth - 2))    iRightX= _global->screenWidth    -    2;
  718.       iCentX = (iLeftX + iRightX) / 2;
  719.  
  720.       if (aTopLeftY        < (MENUHEIGHT + 1))                             iTopY            = MENUHEIGHT + 1;
  721.       if (aTopLeftY        > (_global->screenHeight - 2))    iTopY            = _global->screenHeight - 2;
  722.       if (aBotRightY    < (MENUHEIGHT + 1))                             iBottomY    = MENUHEIGHT + 1;
  723.       if (aBotRightY    > (_global->screenHeight - 2))    iBottomY    = _global->screenHeight - 2;
  724.       iCentY = (iTopY + iBottomY) / 2;
  725.  
  726.       // Get Sky color or bg color, whatever fits:
  727.       /*---------------------
  728.          --- Left side ---
  729.       ---------------------*/
  730.       if (surface[iLeftX] <= iTopY)
  731.         {
  732.           // All infront of the surface:
  733.           iColorBoLe    =    getpixel(terrain, iLeftX,        iBottomY);
  734.           iColorCeLe    =    getpixel(terrain, iLeftX,        iCentY);
  735.           iColorToLe    =    getpixel(terrain, iLeftX,        iTopY);
  736.         }
  737.       else
  738.         {
  739.           // look where we are going...
  740.           if (surface[iLeftX] > iBottomY)
  741.             {
  742.               // Left part is guaranteed to be in front of the sky, get all three colors at once:
  743.               iColorBoLe    =    getpixel(sky, iLeftX,        iBottomY - MENUHEIGHT);
  744.               iColorCeLe    =    getpixel(sky, iLeftX,        iCentY - MENUHEIGHT);
  745.               iColorToLe    =    getpixel(sky, iLeftX,        iTopY - MENUHEIGHT);
  746.             }
  747.           else
  748.             {
  749.               // At least the bottom color is infront of the terrain
  750.               iColorBoLe    =    getpixel(terrain, iLeftX,        iBottomY);
  751.               if (surface[iLeftX] > iCentY)
  752.                 {
  753.                   // ...but the other two are in front of the sky:
  754.                   iColorCeLe    =    getpixel(sky, iLeftX,        iCentY - MENUHEIGHT);
  755.                   iColorToLe    =    getpixel(sky, iLeftX,        iTopY - MENUHEIGHT);
  756.                 }
  757.               else
  758.                 {
  759.                   // Nope, they are in front of the terrain
  760.                   iColorCeLe    =    getpixel(terrain, iLeftX,        iCentY);
  761.                   iColorToLe    =    getpixel(terrain, iLeftX,        iTopY);
  762.                 }
  763.             }
  764.         }
  765.       /*---------------------
  766.          --- The Center ---
  767.       ---------------------*/
  768.       if (surface[iCentX] <= iTopY)
  769.         {
  770.           // All infront of the surface:
  771.           iColorBoCe =    getpixel(terrain, iCentX,        iBottomY);
  772.           iColorCeCe =    getpixel(terrain, iCentX,        iCentY);
  773.           iColorToCe =    getpixel(terrain, iCentX,        iTopY);
  774.         }
  775.       else
  776.         {
  777.           // look where we are going...
  778.           if (surface[iCentX] > iBottomY)
  779.             {
  780.               // Left part is guaranteed to be in front of the sky, get all three colors at once:
  781.               iColorBoCe =    getpixel(sky, iCentX,        iBottomY - MENUHEIGHT);
  782.               iColorCeCe =    getpixel(sky, iCentX,        iCentY - MENUHEIGHT);
  783.               iColorToCe =    getpixel(sky, iCentX,        iTopY - MENUHEIGHT);
  784.             }
  785.           else
  786.             {
  787.               // At least the bottom color is infront of the terrain
  788.               iColorBoCe =    getpixel(terrain, iCentX,        iBottomY);
  789.               if (surface[iCentX] > iCentY)
  790.                 {
  791.                   // ...but the other two are in front of the sky:
  792.                   iColorCeCe =    getpixel(sky, iCentX,        iCentY - MENUHEIGHT);
  793.                   iColorToCe =    getpixel(sky, iCentX,        iTopY - MENUHEIGHT);
  794.                 }
  795.               else
  796.                 {
  797.                   // Nope, they are in front of the terrain
  798.                   iColorCeCe =    getpixel(terrain, iCentX,        iCentY);
  799.                   iColorToCe =    getpixel(terrain, iCentX,        iTopY);
  800.                 }
  801.             }
  802.         }
  803.       /*----------------------
  804.          --- Right side ---
  805.       ----------------------*/
  806.       if (surface[iRightX] <= iTopY)
  807.         {
  808.           // All infront of the surface:
  809.           iColorBoRi =    getpixel(terrain, iRightX,        iBottomY);
  810.           iColorCeRi =    getpixel(terrain, iRightX,        iCentY);
  811.           iColorToRi =    getpixel(terrain, iRightX,        iTopY);
  812.         }
  813.       else
  814.         {
  815.           // look where we are going...
  816.           if (surface[iRightX] > iBottomY)
  817.             {
  818.               // Left part is guaranteed to be in front of the sky, get all three colors at once:
  819.               iColorBoRi =    getpixel(sky, iRightX,        iBottomY - MENUHEIGHT);
  820.               iColorCeRi =    getpixel(sky, iRightX,        iCentY - MENUHEIGHT);
  821.               iColorToRi =    getpixel(sky, iRightX,        iTopY - MENUHEIGHT);
  822.             }
  823.           else
  824.             {
  825.               // At least the bottom color is infront of the terrain
  826.               iColorBoRi =    getpixel(terrain, iRightX,        iBottomY);
  827.               if (surface[iRightX] > iCentY)
  828.                 {
  829.                   // ...but the other two are in front of the sky:
  830.                   iColorCeRi =    getpixel(sky, iRightX,        iCentY - MENUHEIGHT);
  831.                   iColorToRi =    getpixel(sky, iRightX,        iTopY - MENUHEIGHT);
  832.                 }
  833.               else
  834.                 {
  835.                   // Nope, they are in front of the terrain
  836.                   iColorCeRi =    getpixel(terrain, iRightX,        iCentY);
  837.                   iColorToRi =    getpixel(terrain, iRightX,        iTopY);
  838.                 }
  839.             }
  840.         }
  841.  
  842.       // Fetch the rgb parts, according to movement:
  843.       /* --- X-Movement --- */
  844.       if (aVelX < 0.0)
  845.         {
  846.           // Movement to the left, weight left side color twice
  847.           iRed        +=    (_GET_R(iColorBoLe) * 2) + (_GET_R(iColorCeLe) * 2) + (_GET_R(iColorToLe) * 2);
  848.           iGreen    +=    (_GET_G(iColorBoLe) * 2) + (_GET_G(iColorCeLe) * 2) + (_GET_G(iColorToLe) * 2);
  849.           iBlue        +=    (_GET_B(iColorBoLe) * 2) + (_GET_B(iColorCeLe) * 2) + (_GET_B(iColorToLe) * 2);
  850.           // The others are counted once
  851.           iRed        +=    _GET_R(iColorBoCe) + _GET_R(iColorCeCe) + _GET_R(iColorToCe) + _GET_R(iColorBoRi) + _GET_R(iColorCeRi) + _GET_R(iColorToRi);
  852.           iGreen    +=    _GET_G(iColorBoCe) + _GET_G(iColorCeCe) + _GET_G(iColorToCe) + _GET_G(iColorBoRi) + _GET_G(iColorCeRi) + _GET_G(iColorToRi);
  853.           iBlue        +=    _GET_B(iColorBoCe) + _GET_B(iColorCeCe) + _GET_B(iColorToCe) + _GET_B(iColorBoRi) + _GET_B(iColorCeRi) + _GET_B(iColorToRi);
  854.         }
  855.       if (aVelX == 0.0)
  856.         {
  857.           // No X-Movement, weight center twice
  858.           iRed        +=    (_GET_R(iColorBoCe) * 2) + (_GET_R(iColorCeCe) * 2) + (_GET_R(iColorToCe) * 2);
  859.           iGreen    +=    (_GET_G(iColorBoCe) * 2) + (_GET_G(iColorCeCe) * 2) + (_GET_G(iColorToCe) * 2);
  860.           iBlue        +=    (_GET_B(iColorBoCe) * 2) + (_GET_B(iColorCeCe) * 2) + (_GET_B(iColorToCe) * 2);
  861.           // The others are counted once
  862.           iRed        +=    _GET_R(iColorBoLe) + _GET_R(iColorCeLe) + _GET_R(iColorToLe) + _GET_R(iColorBoRi) + _GET_R(iColorCeRi) + _GET_R(iColorToRi);
  863.           iGreen    +=    _GET_G(iColorBoLe) + _GET_G(iColorCeLe) + _GET_G(iColorToLe) + _GET_G(iColorBoRi) + _GET_G(iColorCeRi) + _GET_G(iColorToRi);
  864.           iBlue        +=    _GET_B(iColorBoLe) + _GET_B(iColorCeLe) + _GET_B(iColorToLe) + _GET_B(iColorBoRi) + _GET_B(iColorCeRi) + _GET_B(iColorToRi);
  865.         }
  866.       if (aVelX > 0.0)
  867.         {
  868.           // Movement to the right, weight right side color twice
  869.           iRed        +=    (_GET_R(iColorBoRi) * 2) + (_GET_R(iColorCeRi) * 2) + (_GET_R(iColorToRi) * 2);
  870.           iGreen    +=    (_GET_G(iColorBoRi) * 2) + (_GET_G(iColorCeRi) * 2) + (_GET_G(iColorToRi) * 2);
  871.           iBlue        +=    (_GET_B(iColorBoRi) * 2) + (_GET_B(iColorCeRi) * 2) + (_GET_B(iColorToRi) * 2);
  872.           // The others are counted once
  873.           iRed        +=    _GET_R(iColorBoCe) + _GET_R(iColorCeCe) + _GET_R(iColorToCe) + _GET_R(iColorBoLe) + _GET_R(iColorCeLe) + _GET_R(iColorToLe);
  874.           iGreen    +=    _GET_G(iColorBoCe) + _GET_G(iColorCeCe) + _GET_G(iColorToCe) + _GET_G(iColorBoLe) + _GET_G(iColorCeLe) + _GET_G(iColorToLe);
  875.           iBlue        +=    _GET_B(iColorBoCe) + _GET_B(iColorCeCe) + _GET_B(iColorToCe) + _GET_B(iColorBoLe) + _GET_B(iColorCeLe) + _GET_B(iColorToLe);
  876.         }
  877.       /* --- Y-Movement --- */
  878.       if (aVelY < 0.0)
  879.         {
  880.           // Movement upwards, weight upper side color twice
  881.           iRed        +=    (_GET_R(iColorToLe) * 2) + (_GET_R(iColorToCe) * 2) + (_GET_R(iColorToRi) * 2);
  882.           iGreen    +=    (_GET_G(iColorToLe) * 2) + (_GET_G(iColorToCe) * 2) + (_GET_G(iColorToRi) * 2);
  883.           iBlue        +=    (_GET_B(iColorToLe) * 2) + (_GET_B(iColorToCe) * 2) + (_GET_B(iColorToRi) * 2);
  884.           // The others are counted once
  885.           iRed        +=    _GET_R(iColorBoLe) + _GET_R(iColorCeLe) + _GET_R(iColorBoCe) + _GET_R(iColorCeCe) + _GET_R(iColorBoRi) + _GET_R(iColorCeRi);
  886.           iGreen    +=    _GET_G(iColorBoLe) + _GET_G(iColorCeLe) + _GET_G(iColorBoCe) + _GET_G(iColorCeCe) + _GET_G(iColorBoRi) + _GET_G(iColorCeRi);
  887.           iBlue        +=    _GET_B(iColorBoLe) + _GET_B(iColorCeLe) + _GET_B(iColorBoCe) + _GET_B(iColorCeCe) + _GET_B(iColorBoRi) + _GET_B(iColorCeRi);
  888.         }
  889.       if (aVelY == 0.0)
  890.         {
  891.           // No Y-Movement, weight center twice
  892.           iRed        +=    (_GET_R(iColorCeLe) * 2) + (_GET_R(iColorCeCe) * 2) + (_GET_R(iColorCeRi) * 2);
  893.           iGreen    +=    (_GET_G(iColorCeLe) * 2) + (_GET_G(iColorCeCe) * 2) + (_GET_G(iColorCeRi) * 2);
  894.           iBlue        +=    (_GET_B(iColorCeLe) * 2) + (_GET_B(iColorCeCe) * 2) + (_GET_B(iColorCeRi) * 2);
  895.           // The others are counted once
  896.           iRed        +=    _GET_R(iColorBoLe) + _GET_R(iColorToLe) + _GET_R(iColorBoCe) + _GET_R(iColorToCe) + _GET_R(iColorBoRi) + _GET_R(iColorToRi);
  897.           iGreen    +=    _GET_G(iColorBoLe) + _GET_G(iColorToLe) + _GET_G(iColorBoCe) + _GET_G(iColorToCe) + _GET_G(iColorBoRi) + _GET_G(iColorToRi);
  898.           iBlue        +=    _GET_B(iColorBoLe) + _GET_B(iColorToLe) + _GET_B(iColorBoCe) + _GET_B(iColorToCe) + _GET_B(iColorBoRi) + _GET_B(iColorToRi);
  899.         }
  900.       if (aVelY > 0.0)
  901.         {
  902.           // Movement downwards, weight lower side color twice
  903.           iRed        +=    (_GET_R(iColorBoRi) * 2) + (_GET_R(iColorBoCe) * 2) + (_GET_R(iColorBoLe) * 2);
  904.           iGreen    +=    (_GET_G(iColorBoRi) * 2) + (_GET_G(iColorBoCe) * 2) + (_GET_G(iColorBoLe) * 2);
  905.           iBlue        +=    (_GET_B(iColorBoRi) * 2) + (_GET_B(iColorBoCe) * 2) + (_GET_B(iColorBoLe) * 2);
  906.           // The others are counted once
  907.           iRed        +=    _GET_R(iColorToLe) + _GET_R(iColorCeLe) + _GET_R(iColorToCe) + _GET_R(iColorCeCe) + _GET_R(iColorToRi) + _GET_R(iColorCeRi);
  908.           iGreen    +=    _GET_G(iColorToLe) + _GET_G(iColorCeLe) + _GET_G(iColorToCe) + _GET_G(iColorCeCe) + _GET_G(iColorToRi) + _GET_G(iColorCeRi);
  909.           iBlue        +=    _GET_B(iColorToLe) + _GET_B(iColorCeLe) + _GET_B(iColorToCe) + _GET_B(iColorCeCe) + _GET_B(iColorToRi) + _GET_B(iColorCeRi);
  910.         }
  911.       /* I know this looks weird, but what we now have is some kind of summed matrix, which is always the same:
  912.        * Let's assume that dVelX and dVelY are both 0.0, so no movement is happening. The result is: (In counted times)
  913.        * 2|3|2  ( =  7)
  914.        * -+-+-
  915.        * 3|4|3  ( = 10)
  916.        * -+-+-
  917.        * 2|3|2  ( =  7)
  918.        *          = 24
  919.        * And it is always 24, no matter which movement combination you try. */
  920.       iRed     /= 24;
  921.       if (iRed    > 0xff)    iRed    = 0xff;
  922.       iGreen/= 24;
  923.       if (iGreen> 0xff)    iGreen= 0xff;
  924.       iBlue /= 24;
  925.       if (iBlue    > 0xff)    iBlue    = 0xff;
  926.  
  927.       return(makecol(iRed, iGreen, iBlue));
  928.     }
  929.  
  930.  
  931.  
  932.  
  933. /*
  934.  * This function puts all the of the environment settings back
  935.  * to their default values. These are settings which get written
  936.  * to the config file.
  937.  * -- Jesse
  938.  *  */ 
  939. void ENVIRONMENT::Reset_Options()
  940. {
  941.   windstrength = 8;
  942.   windvariation = 1;
  943.   viscosity = 0.5;
  944.   gravity = 0.150;
  945.   weapontechLevel = 5;
  946.   itemtechLevel = 5;
  947.   meteors = 0;
  948.   lightning = 0;
  949.   satellite = 0.0;
  950.   fog = 0;
  951.   landType = LANDTYPE_RANDOM;
  952.   landSlideType = LANDSLIDE_GRAVITY;
  953.   landSlideDelay = MAX_GRAVITY_DELAY;
  954.   falling_dirt_balls = 0.0;
  955.   wallType = 0.0;
  956.   dBoxedMode = 0.0;
  957.   dFadingText = 0.0;
  958.   dShadowedText = 0.0;
  959.   custom_background = 0.0;
  960. }
  961.  
  962.  
  963. /*
  964. This function checks to see which wall type we are using
  965. and sets the appropriate colour.
  966. */
  967. void ENVIRONMENT::Set_Wall_Colour()
  968. {
  969.     switch (current_wallType)
  970.     {
  971.        case WALL_RUBBER:
  972.           wallColour = makecol(0, 255, 0); break;
  973.        case WALL_STEEL:
  974.           wallColour = makecol(255, 0, 0); break;
  975.        case WALL_SPRING:
  976.           wallColour = makecol(0, 0, 255); break;
  977.        case WALL_WRAP:
  978.           wallColour = makecol(255, 255, 0); break;
  979.     }
  980. }
  981.  
  982.  
  983.  
  984. bool ENVIRONMENT::Get_Boxed_Mode(GLOBALDATA *global)
  985. {
  986.     if (dBoxedMode == 2.0)
  987.     {
  988.        if (rand() % 2)
  989.           global->bIsBoxed = true;
  990.        else
  991.           global->bIsBoxed = false;
  992.     }
  993.     else if (dBoxedMode == 1.0)
  994.          global->bIsBoxed = true;
  995.     else if (dBoxedMode == 0.0)
  996.          global->bIsBoxed = false;
  997.     return global->bIsBoxed;
  998. } 
  999.  
  1000.  
  1001.  
  1002. TANK *ENVIRONMENT::Get_Next_Tank(int *wrapped_around)
  1003. {
  1004.    int index;
  1005.    int found = FALSE;
  1006.    int old_index;
  1007.    int wrapped = 0;
  1008.  
  1009.    index = global_tank_index;
  1010.    old_index = index;
  1011.    index++;
  1012.    while (!found)
  1013.    {
  1014.         if (index >= MAXPLAYERS)
  1015.         {
  1016.              index = 0;
  1017.              *wrapped_around = TRUE;
  1018.              wrapped++;
  1019.         }
  1020.         if ( (order[index]) && (index != old_index) )
  1021.         {
  1022.              found = TRUE;
  1023.         }
  1024.         else
  1025.            index++;
  1026.         if (wrapped > 1)
  1027.            break;
  1028.    }
  1029.  
  1030.    /* 
  1031.    if (! found)
  1032.       *wrapped_around = TRUE;
  1033.    else
  1034.       *wrapped_around = FALSE;
  1035.    */
  1036.    global_tank_index = index;
  1037.    return order[index];
  1038. }
  1039.  
  1040.