frpuniverse: src/star.cpp Source File

00001 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
00002 /*
00003  * frpuniverse
00004  * Copyright (C) Peter L. Berghold 2008 <Peter@Berghold.net>
00005  * 
00006  * frpuniverse is free software.
00007  * 
00008  * You may redistribute it and/or modify it under the terms of the
00009  * GNU General Public License, as published by the Free Software
00010  * Foundation; either version 2 of the License, or (at your option)
00011  * any later version.
00012  * 
00013  * frpuniverse is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00016  * See the GNU General Public License for more details.
00017  * 
00018  * You should have received a copy of the GNU General Public License
00019  * along with frpuniverse.  If not, write to:
00020  *      The Free Software Foundation, Inc.,
00021  *      51 Franklin Street, Fifth Floor
00022  *      Boston, MA  02110-1301, USA.
00023  * 
00024  *  $Id: star.cpp,v 1.5 2008/02/11 19:33:09 plankowner Exp $
00025  * 
00026  *  $Log: star.cpp,v $
00027  *  Revision 1.5  2008/02/11 19:33:09  plankowner
00028  *  Checkpoint ---
00029  *
00030  *  Revision 1.4  2008/02/01 21:05:53  plankowner
00031  *  Did some more hacking on the star attribute generation.  Primary stars
00032  *  are finished at this point.  Next increment will be companion stars.
00033  *
00034  *  Revision 1.3  2008/01/31 19:41:24  plankowner
00035  *  Book 1 style people started with Navy characters first.
00036  *
00037  *  Revision 1.2  2008/01/30 18:53:30  plankowner
00038  *  More progress on defining stars
00039  *
00040  *  Added the ability for the build environment to properly install the libraries and headers in the proper places (/usr/include/frpuniverse and /usr/lib/frpuniverse)
00041  *
00042  */
00043 
00044 #include <malloc.h>
00045 #include <string.h>
00046 #include <stdio.h>
00047 #include "star.hpp"
00048 #include "dice.hpp"
00049 #include "xmlutils.hpp"
00050 #include "numeric2string.hpp"
00051 
00052 
00053 // Constructors
00054 
00055 star::star():orbitPlace(){
00056         orbits= new orbitPlane();
00057         this->generateStarInfo();
00058         closeCompanionPresent=0;
00059 }
00060 
00061 star::star(star* s) : orbitPlace() {
00062         orbits=new orbitPlane();
00063         this->generateStarInfo(s);
00064         closeCompanionPresent=0;
00065         
00066 }
00067 
00068 // Special cases.... don't upset us...
00069 
00070 int star::hasCloseCompanion() {
00071         return closeCompanionPresent;
00072 }
00073 
00074         
00075 
00076 // minimum orbit is the inner most orbit an orbiting body (such as a planet) 
00077 // can occupy without being vaporised or consumed. 
00078 //
00079 //
00080 int star::calculateMinOrbit(){
00081         switch(size){
00082                 case STAR_SIZE_Ia:
00083                         switch (type){
00084                                 case STAR_TYPE_B:
00085                                         switch(spectral){
00086                                                 case 0: 
00087                                                         return 8;
00088                                                 case 5:
00089                                                         return 7;
00090                                         };
00091                                 case STAR_TYPE_A:
00092                                         switch(spectral){
00093                                                 case 0: 
00094                                                         return 7;
00095                                                 case 5:
00096                                                         return 7;
00097                                         };
00098                                 case STAR_TYPE_F:
00099                                         switch(spectral){
00100                                                 case 0: 
00101                                                         return 6;
00102                                                 case 5:
00103                                                         return 6;
00104                                         };
00105                                 case STAR_TYPE_G:
00106                                         switch(spectral){
00107                                                 case 0: 
00108                                                         return 7;
00109                                                 case 5:
00110                                                         return 7;
00111                                         };
00112                                 case STAR_TYPE_K:
00113                                         switch(spectral){
00114                                                 case 0: 
00115                                                 case 5:
00116                                                         return 7;
00117                                         };
00118                                 case STAR_TYPE_M:
00119                                         switch(spectral){
00120                                                 case 0: 
00121                                                         return 7;
00122                                                 case 5:
00123                                                         return 8;
00124                                         };
00125                         };
00126                         break;
00127                 case STAR_SIZE_Ib:
00128                         switch (type){
00129                                 case STAR_TYPE_B:
00130                                         switch(spectral){
00131                                                 case 0: 
00132                                                         return 8;
00133                                                 case 5:
00134                                                         return 6;
00135                                         };
00136                                 case STAR_TYPE_A:
00137                                         switch(spectral){
00138                                                 case 0:
00139                                                         
00140                                                 case 5:
00141                                                         return 5;
00142                                         };
00143                                 case STAR_TYPE_F:
00144                                         switch(spectral){
00145                                                 case 0: 
00146                                                         return 5;
00147                                                 case 5:
00148                                                         return 4;
00149                                         };
00150                                 case STAR_TYPE_G:
00151                                         switch(spectral){
00152                                                 case 0: 
00153                                                         return 4;
00154                                                 case 5:
00155                                                         return 5;
00156                                         };
00157                                 case STAR_TYPE_K:
00158                                         switch(spectral){
00159                                                 case 0: 
00160                                                         return 5;
00161                                                 case 5:
00162                                                         return 6;
00163                                         };
00164                                 case STAR_TYPE_M:
00165                                         switch(spectral){
00166                                                 case 0: 
00167                                                         return 6;
00168                                                 case 5:
00169                                                         return 7;
00170                                         };
00171                         };
00172                         break;
00173                 case STAR_SIZE_II:
00174                         switch (type){
00175                                 case STAR_TYPE_B:
00176                                         switch(spectral){
00177                                                 case 0: 
00178                                                         return 7;
00179                                                 case 5:
00180                                                         return 5;
00181                                         };
00182                                 case STAR_TYPE_A:
00183                                         switch(spectral){
00184                                                 case 0: 
00185                                                         return 3;
00186                                                 case 5:
00187                                                         return 2;
00188                                         };
00189                                 case STAR_TYPE_F:
00190                                         switch(spectral){
00191                                                 case 0: 
00192                                                 case 5:
00193                                                         return 2;
00194                                         };
00195                                 case STAR_TYPE_G:
00196                                         switch(spectral){
00197                                                 case 0: 
00198                                                 case 5:
00199                                                         return 2;
00200                                         };
00201                                 case STAR_TYPE_K:
00202                                         switch(spectral){
00203                                                 case 0: 
00204                                                         return 2;
00205                                                 case 5:
00206                                                         return 3;
00207                                         };
00208                                 case STAR_TYPE_M:
00209                                         switch(spectral){
00210                                                 case 0: 
00211                                                         return 4;
00212                                                 case 5:
00213                                                         return 6;
00214                                         };
00215                         };
00216                         break;
00217                 case STAR_SIZE_III:
00218                         switch (type){
00219                                 case STAR_TYPE_B:
00220                                         switch(spectral){
00221                                                 case 0: 
00222                                                         return 7;
00223                                                 case 5:
00224                                                         return 5;
00225                                         };
00226                                 case STAR_TYPE_A:
00227                                         switch(spectral){
00228                                                 case 0: 
00229                                                 case 5:
00230                                                         return 1;
00231                                         };
00232                                 case STAR_TYPE_F:
00233                                         switch(spectral){
00234                                                 case 0: 
00235                                                 case 5:
00236                                                         return 1;
00237                                         };
00238                                 case STAR_TYPE_G:
00239                                         switch(spectral){
00240                                                 case 0: 
00241                                                 case 5:
00242                                                         return 1;
00243                                         };
00244                                 case STAR_TYPE_K:
00245                                         switch(spectral){
00246                                                 case 0: 
00247                                                 case 5:
00248                                                         return 1;
00249                                         };
00250                                 case STAR_TYPE_M:
00251                                         switch(spectral){
00252                                                 case 0: 
00253                                                         return 2;
00254                                                 case 5:
00255                                                         return 5;
00256                                         };
00257                         };
00258                         break;
00259                 case STAR_SIZE_IV:
00260                         switch (type){
00261                                 case STAR_TYPE_B:
00262                                         switch(spectral){
00263                                                 case 0: 
00264                                                         return 7;
00265                                                 case 5:
00266                                                         return 3;
00267                                         };
00268                                 case STAR_TYPE_A:
00269                                         switch(spectral){
00270                                                 case 0: 
00271                                                         return 1;
00272                                                 case 5:
00273                                                         return 0;
00274                                         };
00275                                 case STAR_TYPE_F:
00276                                         switch(spectral){
00277                                                 case 0: 
00278                                                         
00279                                                 case 5:
00280                                                         return 0;
00281                                         }
00282                                 case STAR_TYPE_G:
00283                                         switch(spectral){
00284                                                 case 0: 
00285                                                 case 5:
00286                                                         return 0;
00287                                         }
00288                                 case STAR_TYPE_K:
00289                                         switch(spectral){
00290                                                 case 0: 
00291                                                 case 5:
00292                                                         return 0;
00293                                         }
00294                                 case STAR_TYPE_M:
00295                                         switch(spectral){
00296                                                 case 0: 
00297                                                 case 5:
00298                                                         return 0;
00299                                         }
00300                         };
00301                         break;
00302                 case STAR_SIZE_V:
00303                         switch (type){
00304                                 case STAR_TYPE_B:
00305                                         switch(spectral){
00306                                                 case 0: 
00307                                                         return 6;
00308                                                 case 5:
00309                                                         return 4;
00310                                         }
00311                                 case STAR_TYPE_A:
00312                                         switch(spectral){
00313                                                 case 0: 
00314                                                 case 5:
00315                                                         return 0;
00316                                         }
00317                                 case STAR_TYPE_F:
00318                                         switch(spectral){
00319                                                 case 0: 
00320                                                 case 5:
00321                                                         return 0;
00322                                         }
00323                                 case STAR_TYPE_G:
00324                                         switch(spectral){
00325                                                 case 0: 
00326                                                 case 5:
00327                                                         return 0;
00328                                         }
00329                                 case STAR_TYPE_K:
00330                                         switch(spectral){
00331                                                 case 0: 
00332                                                 case 5:
00333                                                         return 0;
00334                                         }
00335                                 case STAR_TYPE_M:
00336                                         switch(spectral){
00337                                                 case 0: 
00338                                                 case 5:
00339                                                         return 0;
00340                                         }
00341                         };
00342                         break;
00343                 
00344                 case STAR_SIZE_VI:
00345                         return 0;
00346                 case STAR_SIZE_D:
00347                         return 0;
00348                         
00349         };
00350         
00351 }
00352 
00353 int star::calculateHabitableOrbit(){
00354         switch (size){
00355                 case STAR_SIZE_Ia:
00356                         switch (type){
00357                                 case STAR_TYPE_O:
00358                                         
00359                                 case STAR_TYPE_B:
00360                                         if ( spectral == 0 ) return 13;
00361                                         else return 12;
00362                                         break;
00363                                 case STAR_TYPE_A: 
00364                                         return 12;
00365                                 case STAR_TYPE_F:
00366                                         if ( spectral == 0 ) return 12; 
00367                                         else  return 11;
00368                                 case STAR_TYPE_G:
00369                                 case STAR_TYPE_K:
00370                                 case STAR_TYPE_M:
00371                                         return 12;
00372                         };
00373                 
00374                 case STAR_SIZE_Ib:
00375                         switch (type){
00376                                 case STAR_TYPE_O:
00377                                         
00378                                 case STAR_TYPE_B:
00379                                         if ( spectral == 0 ) return 13;
00380                                         else return 11;
00381                                 case STAR_TYPE_A: 
00382                                         if ( spectral == 0 ) return 11;
00383                                         else return 10;
00384                                 case STAR_TYPE_F: 
00385                                 case STAR_TYPE_G:
00386                                         return 10;
00387                                 case STAR_TYPE_K:
00388                                         return ( spectral == 0 ? 10:11);
00389                                 case STAR_TYPE_M:
00390                                         return ( spectral == 0 ? 11: 12);
00391                         };
00392                 case STAR_SIZE_II:
00393                         switch (type){
00394                                 case STAR_TYPE_O:
00395                                 case STAR_TYPE_B:
00396                                         return ( spectral == 0 ? 8: 6);
00397                                 case STAR_TYPE_A:
00398                                         return 5;
00399                                 case STAR_TYPE_F: 
00400                                         return 4;
00401                                 case STAR_TYPE_G:
00402                                         return ( spectral == 0 ? 4 : 5 );
00403                                 case STAR_TYPE_K:
00404                                         return ( spectral == 0 ? 5 : 6 );
00405                                 case STAR_TYPE_M:
00406                                         return ( spectral == 0 ? 6 : 7 );
00407                         };
00408                 case STAR_SIZE_III:
00409                         switch (type){
00410                                 case STAR_TYPE_O:
00411                                 case STAR_TYPE_B:
00412                                         return (spectral == 0 ? 12 : 10 );
00413                                 case STAR_TYPE_A: 
00414                                         return (spectral == 0 ? 8 : 7 ) ;
00415                                 case STAR_TYPE_F: 
00416                                         return 6;
00417                                 case STAR_TYPE_G:
00418                                         return ( spectral == 0 ? 6 : 7 );
00419                                 case STAR_TYPE_K:
00420                                         return ( spectral == 0 ? 7 : 8 );
00421                                 case STAR_TYPE_M:
00422                                         return ( spectral == 0 ? 8 : 9 );
00423                         };
00424                 case STAR_SIZE_IV:
00425                         switch (type){
00426                                 case STAR_TYPE_O:
00427                                 case STAR_TYPE_B:
00428                                         return ( spectral == 0 ? 12: 9 ) ;
00429                                 case STAR_TYPE_A: 
00430                                         return ( spectral == 0 ? 7 : 6);
00431                                 case STAR_TYPE_F: 
00432                                         return ( spectral == 0 ? 6 : 5);
00433                                 case STAR_TYPE_G:
00434                                         return 5;
00435                                 case STAR_TYPE_K:
00436                                 case STAR_TYPE_M:
00437                                         return 4;
00438                         };
00439                 case STAR_SIZE_V:
00440                         switch (type){
00441                                 case STAR_TYPE_O:
00442                                 case STAR_TYPE_B:
00443                                         return ( spectral == 0 ? 12 : 9 );
00444                                 case STAR_TYPE_A: 
00445                                         return ( spectral == 0 ? 7 : 6 ); 
00446                                 case STAR_TYPE_F: 
00447                                         return ( spectral == 0 ? 5 : 4 );
00448                                 case STAR_TYPE_G:
00449                                         return ( spectral == 0 ? 3 : 2 );
00450                                 case STAR_TYPE_K:
00451                                         return 1;
00452                                 case STAR_TYPE_M:
00453                                         return -1; // NO habitable zone...
00454                         };
00455                 case STAR_SIZE_VI:
00456                         switch (type){
00457                                 case STAR_TYPE_O:
00458                                 case STAR_TYPE_B:
00459                                 case STAR_TYPE_A: 
00460                                 case STAR_TYPE_F: 
00461                                         return 3;
00462                                 case STAR_TYPE_G:
00463                                         return ( spectral == 0 ? 2 : 1 );
00464                                 case STAR_TYPE_K:
00465                                         return ( spectral == 0 ? 0 : -1 );
00466                                 case STAR_TYPE_M:
00467                                         return -1;
00468                         };
00469                 case STAR_SIZE_D: 
00470                         switch (type){
00471                                 case STAR_TYPE_O:
00472                                 case STAR_TYPE_B:
00473                                         return 0;
00474                                 case STAR_TYPE_A: 
00475                                 case STAR_TYPE_F: 
00476                                 case STAR_TYPE_G:
00477                                 case STAR_TYPE_K:
00478                                 case STAR_TYPE_M:
00479                                         return -1;
00480                         };
00481         };
00482         
00483 }
00484 
00485 
00486 static int primarySizeLookup(int n){
00487         switch(n){
00488                 case 0:
00489                         return STAR_SIZE_Ia;
00490                 case 1:
00491                         return STAR_SIZE_Ib;
00492                 case 2: 
00493                         return STAR_SIZE_II;
00494                 case 3:
00495                         return STAR_SIZE_III;
00496                 case 4:
00497                         return STAR_SIZE_IV;
00498                 case 5:
00499                 case 6:
00500                 case 7:
00501                 case 8:
00502                 case 9: 
00503                 case 10: 
00504                         return STAR_SIZE_V;
00505                 case 11:
00506                         return STAR_SIZE_VI;
00507                 default:
00508                         return STAR_SIZE_D;
00509                         
00510                         
00511         };
00512         
00513 }
00514 
00515 static int primaryTypeLookup(int n){
00516         switch(n){
00517                 case 0:
00518                 case 1:
00519                         return STAR_TYPE_B;
00520                 case 2:
00521                         return STAR_TYPE_A;
00522                 case 3:
00523                 case 4:
00524                 case 5:
00525                 case 6:
00526                 case 7: 
00527                         return STAR_TYPE_M;
00528                 case 8:
00529                         return STAR_TYPE_K;
00530                 case 9: 
00531                         return STAR_TYPE_G;
00532                 default: 
00533                         return STAR_TYPE_F;
00534                         
00535         };
00536 }
00537 
00538 
00539 
00540 char *star::toXML(){
00541         char *buffer;
00542         
00543         buffer=createStartElement("star");
00544         buffer=addXMLElement(buffer,"size",starSize(size));
00545         buffer=addXMLElement(buffer,"type",starType(type));
00546         
00547         return buffer;
00548         
00549 }
00550 
00551 void star::generateStarInfo(){
00552         int dm;
00553         size_roll = d2d6();
00554         type_roll = d2d6();
00555         size = primarySizeLookup(size_roll);
00556         type = primaryTypeLookup(type_roll);
00557         
00558         spectral = ( d1d6() > 3 ? 5 : 0 );
00559         min_orbit_number = this->calculateMinOrbit();
00560         habitable_orbit = this->calculateHabitableOrbit();
00561         
00562         // Calculate a DM based on star size. 
00563         dm = ( size == STAR_SIZE_III ? 4 : 
00564                    ( ((STAR_SIZE_Ia <= size ) && ( size <= STAR_SIZE_II)) ? 
00565                                 8:0 ) );
00566         // Add to or subtract from that DM based on type. 
00567         dm = dm + ( type == STAR_TYPE_M ? -4 : 
00568                             ( type == STAR_TYPE_K ? -2 : 0 ) );
00569         max_orbits = d2d6() + dm;
00570         // Eliminate negative values if present. 
00571         max_orbits = ( max_orbits >= 0 ? max_orbits : 0 ); 
00572         
00573         // Determine if gas giants are present and how many
00574         if ( d2d6() < 10 ) {
00575                 int roll = d2d6();
00576                 gas_giants = 
00577                         ( roll < 4 ? 1 : 
00578                           ( (( roll == 4) || (roll == 5 )) ? 2 :
00579                             ( ( roll == 6) || (roll == 7) ? 3 : 4 ) ) );
00580                 
00581                 
00582         } else {
00583                 gas_giants=0;
00584         }
00585         
00586         gas_giants = ( gas_giants > max_orbits ? max_orbits : gas_giants);
00587         
00588         // Determine if planetoid belts are present and how many
00589         
00590         dm = gas_giants;
00591         
00592         if ( (d2d6() + dm ) > 6 ) {
00593                 planetoid = 0;
00594         } else { 
00595                 int roll= d2d6() + roll; 
00596                 planetoid = ( roll > 6 ? 1 : 2 ) ;
00597         }
00598         
00599         planetoid = ( (gas_giants + planetoid) > max_orbits? (max_orbits-gas_giants) : 
00600                                  planetoid);
00601         
00602         
00603 }
00604 
00605 void star::generateStarInfo(star* s){
00606         size_roll = s->size_roll + d2d6();
00607         type_roll = s->type_roll + d2d6();
00608         int dm;
00609         
00610         size = primarySizeLookup(size_roll);
00611         type = primaryTypeLookup(type_roll);
00612         
00613         spectral = ( d1d6() > 3 ? 5 : 0 );
00614         min_orbit_number = this->calculateMinOrbit();
00615         habitable_orbit = this->calculateHabitableOrbit();
00616         
00617         // Calculate a DM based on star size. 
00618         dm = ( size == STAR_SIZE_III ? 4 : 
00619                    ( ((STAR_SIZE_Ia <= size ) && ( size <= STAR_SIZE_II)) ? 
00620                                 8:0 ) );
00621         // Add to or subtract from that DM based on type. 
00622         dm = dm + ( type == STAR_TYPE_M ? -4 : 
00623                             ( type == STAR_TYPE_K ? -2 : 0 ) );
00624         max_orbits = d2d6() + dm;
00625         // Eliminate negative values if present. 
00626         max_orbits = ( max_orbits >= 0 ? max_orbits : 0 ); 
00627         
00628         // Determine if gas giants are present and how many
00629         if ( d2d6() < 10 ) {
00630                 int roll = d2d6();
00631                 gas_giants = 
00632                         ( roll < 4 ? 1 : 
00633                           ( (( roll == 4) || (roll == 5 )) ? 2 :
00634                             ( ( roll == 6) || (roll == 7) ? 3 : 4 ) ) );
00635                 
00636                 
00637         } else {
00638                 gas_giants=0;
00639         }
00640         
00641         gas_giants = ( gas_giants > max_orbits ? max_orbits : gas_giants);
00642         
00643         // Determine if planetoid belts are present and how many
00644         
00645         dm = gas_giants;
00646         
00647         if ( (d2d6() + dm ) > 6 ) {
00648                 planetoid = 0;
00649         } else { 
00650                 int roll= d2d6() + roll; 
00651                 planetoid = ( roll > 6 ? 1 : 2 ) ;
00652         }
00653         
00654         planetoid = ( (gas_giants + planetoid) > max_orbits? (max_orbits-gas_giants) : 
00655                                  planetoid);
00656         
00657         
00658         
00659 }
00660 
00661 void star::placeCompanion(star* s,int x){
00662         int dm = ( x == 3 ? 4:0);
00663         int dist;
00664         
00665         switch (d2d6()+dm){
00666                 case 0:
00667                 case 1:
00668                 case 2:
00669                 case 3:
00670                         closeCompanionPresent=1;
00671                         closeCompanion=s;
00672                         break;
00673                 case 4:
00674                         if ( min_orbit_number > 1 ) {
00675                                 closeCompanionPresent=1;
00676                                 closeCompanion=s;
00677                         } else { 
00678                                 orbits->addAt(1,s);
00679                                 min_orbit_number = 2;
00680                         }
00681                         break;
00682                 case 5:
00683                         if ( min_orbit_number > 2 ) {
00684                                 closeCompanionPresent=1;
00685                                 closeCompanion=s;
00686                         } else { 
00687                                 orbits->addAt(2,s);
00688                                 min_orbit_number=3;
00689                         }
00690                         break;
00691                 case 6:
00692                         if ( min_orbit_number > 3 ) {
00693                                 closeCompanionPresent=1;
00694                                 closeCompanion=s;
00695                         } else { 
00696                                 orbits->addAt(3,s);
00697                                 min_orbit_number=4;
00698                         }
00699                         break;
00700                 case 7:
00701                         dist = 4 + d1d6();
00702                         if ( min_orbit_number > dist ) {
00703                                 closeCompanionPresent=1;
00704                                 closeCompanion=s;
00705                         } else {
00706                                 orbits->addAt(dist,s);
00707                         }
00708                         break;
00709                 case 8:
00710                         dist= 5 + d1d6();
00711                         if ( min_orbit_number > dist ) {
00712                                 closeCompanionPresent=1;
00713                                 closeCompanion=s;
00714                         } else {
00715                                 orbits->addAt(dist,s);
00716                         }
00717                         break;
00718                 case 9:
00719                         dist = 6 + d1d6();
00720                         if ( min_orbit_number > dist ) {
00721                                 closeCompanionPresent=1;
00722                                 closeCompanion=s;
00723                         } else {
00724                                 orbits->addAt(dist,s);
00725                         }
00726                         break;
00727                 case 10:
00728                         dist = 7 + d1d6();
00729                         if ( min_orbit_number > dist ) {
00730                                 closeCompanionPresent=1;
00731                                 closeCompanion=s;
00732                         } else {
00733                                 orbits->addAt(dist,s);
00734                         }
00735                         break;
00736                 case 11:
00737                         dist = 8+ d1d6();
00738                         if ( min_orbit_number > dist ) {
00739                                 closeCompanionPresent=1;
00740                                 closeCompanion=s;
00741                         } else {
00742                                 orbits->addAt(dist,s);
00743                         }
00744                         break;
00745                 default:
00746                         dist = 20+d2d6();
00747                         orbits->addAt(dist,s);
00748                         break;
00749         };
00750         
00751         // Let's prevent some cosmological imposibilities...
00752         //
00753         if ( closeCompanionPresent == 1 ) {
00754                 closeCompanion->habitable_orbit=-1;  // Take away the habitable orbit if it existed.
00755                 closeCompanion->gas_giants=0;
00756                 closeCompanion->planetoid=0;
00757                 closeCompanion->max_orbits=0;
00758         }
00759         
00760                 
00761 }
00762 
00763 orbitPlane* star::getOrbits(){
00764         return orbits;
00765 }
00766 
00767 void star::setOrbits(orbitPlane* op){
00768         orbits= op;
00769 }
00770 
00771 
00772 char* star::nodeSignature(){
00773         return "star";
00774 }