src/planet.cpp

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * frpuniverse
 * Copyright (C) Peter L. Berghold 2008 <Peter@Berghold.net>
 * 
 * frpuniverse is free software.
 * 
 * You may redistribute it and/or modify it under the terms of the
 * GNU General Public License, as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 * 
 * frpuniverse is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with frpuniverse.  If not, write to:
 *      The Free Software Foundation, Inc.,
 *      51 Franklin Street, Fifth Floor
 *      Boston, MA  02110-1301, USA.
 * $Id: planet.cpp,v 1.5 2008/02/27 03:48:39 plankowner Exp $
 * 
 * $Log: planet.cpp,v $
 * Revision 1.5  2008/02/27 03:48:39  plankowner
 * Starting to put "World Builders Handbook" stuff into the modules.
 *
 * Revision 1.4  2008/02/26 22:22:11  plankowner
 * Major checkpoint
 *
 * Revision 1.3  2008/02/12 22:10:51  plankowner
 * Started fleshing more things out a bit.
 *
 * 
 */

#include "planet.hpp"
#include "dice.hpp"

static int correctedRoll(int dm,int j){
        int roll = ( d2d6() - dm ) + j ; 
        return ( roll >= 0 ? roll : 0 ) ; 
        
}

void planet::setPhysicalElements(){
        int ix;
        
        physicalElements.s.diameter = d2d6() - 2; // Set our diameter. 
        if ( physicalElements.s.diameter == 0 ) {
                physicalElements.s.atmosphere = 0; 
        } else {
                physicalElements.s.atmosphere = 
                        correctedRoll(7,physicalElements.s.diameter);
        }
        
        if ( physicalElements.s.diameter <= 1 ) { 
                physicalElements.s.hydrosphere = 0; 
        } else { 
                ix = correctedRoll(7,physicalElements.s.diameter);
                if ( (physicalElements.s.atmosphere <= 1 ) || 
                         ( physicalElements.s.atmosphere >= 10 ) ) 
                        ix = ix - 4;
                ix = ( ix < 0 ? 0 : ix) ; 
                ix = ( ix > 10 ? 10 : ix) ; 
                physicalElements.s.hydrosphere = ix;
        }
}


planet::planet():orbitPlace(){
        this->setPhysicalElements();
        this->setSignature("planet");
}

planet::planet(char *s) : orbitPlace(){
        this->setSignature(s);
        this->setPhysicalElements();
}

        
void planet::setDiameter(int d){
        physicalElements.s.diameter = ( d>= 0? d : 0 );
}

int planet::getDiameter(){
        return physicalElements.s.diameter;
}

void planet::setAtmosphere(int a){
        physicalElements.s.atmosphere = a; 
}

int planet::getAtmosphere(){
         return physicalElements.s.atmosphere;
}

void planet::setHydrosphere(int h){
        physicalElements.s.hydrosphere = h;
}

int planet::getHydrosphere(){
        return physicalElements.s.hydrosphere;
}

void planet::setPopulation(int p){
        peopleElements.s.population = p;
}

int planet::getPopulation(){
        return peopleElements.s.population;
}

void planet::setGovernment(int g){
        peopleElements.s.government = g;
}

int planet::getGovernment(){
        return peopleElements.s.government;
}


int planet::getLawlevel(){
        return peopleElements.s.lawlevel;
}

void planet::setLawlevel (int l){
        peopleElements.s.lawlevel=l;
}

void planet::setTechlevel(int t){
        techlevel = t;
        techlevel = ( techlevel < 0 ? 0 : techlevel );
        
}

int planet::getTechlevel(){
        return techlevel;
}

void planet::setScoutBase(int f){
        scoutBase = (f != 0 ? 1:0);
}

int planet::getScoutBase(){
        return scoutBase;
}

void planet::setNavalBase(int f){
        navalBase = ( f != 0 ? 1:0);
}

int planet::getNavalBase(){
        return navalBase;
}

void planet::setSignature(char *s){
        signature = s;
}

char* planet::getSignature(){
        return signature;
}

void planet::genWBHData(){
}

void planet::setSizeModifier(int s){
        size_details.modifier = s;
        
}

        
int planet::getSizeModifier(){
        return size_details.modifier;
}

void planet::setPlanetDensityType(int d){
        size_details.density_type=d;
}

int planet::getPlanetDensityType(){
        return size_details.density_type;
}

void planet::determinePlanetDensityType(){
        int dm=0;
        
        if ( this->getDiameter() < 5 ) dm = 1;
        if ( this->getDiameter() > 5) dm = dm-2;
        
        if ( this->getAtmosphere() < 4 ) dm = dm+1;
        if ( this->getAtmosphere() > 5 ) dm = dm-2;
        
                switch(d2d6()){
                case 1: 
                        this->setPlanetDensityType(HEAVY_CORE);
                break;
                case 2:
                        case 3:
                        case 4:
                        case 5:
                        case 6:
                        case 7:
                        case 8: 
                        case 9:
                        case 10:
                        this->setPlanetDensityType(MOLTEN_CORE);
                break;
                case 11:
                        case 12:
                        case 13:
                        case 14:
                        this->setPlanetDensityType(ROCKY_BODY);
                break;
                default:
                        this->setPlanetDensityType(ICY_BODY);
                break;
        };
}

void planet::setPlanetDensity(double d){
        size_details.density=d;
        
}

double planet::getPlanetDensity(){
        return size_details.density;
}

double density_table[15][4];

static int density_table_initialized=0;

static void initializeDensityTable(){
        int ix;
        int iy;
        double start_values[4]={1.10,0.82,0.50,0.18};
        
        for(ix=0;ix<15;ix++){
                for(iy=0;iy<4;iy++){
                        density_table[ix][iy]=start_values[iy];
                }
                if ( ix <= 10 ) start_values[0] = start_values[0] + 0.05;
                else start_values[0] = start_values[0] + 0.10;
                if ( ix == 15 ) start_values[0] = 2.25;
                
                start_values[1] = start_values[1] + 0.02;
                
                start_values[2] = start_values[2] + 0.02;
                
                start_values[3] = start_values[3] + 0.02;
        }
        density_table_initialized=1;
}


void planet::calculatePlanetDensity(){
        if ( density_table_initialized == 0 ) 
                initializeDensityTable ();
        int rx = d2d6() + d1d6() - 3;
        this->setPlanetDensity(density_table[rx][this->getPlanetDensityType()-1]);
        
        
}

void planet::calculatePlanetMass(){
        double mass;
        
        mass = ( ( this->getDiameter() == 0 ? 0.8 : (double) this->getDiameter()) / 8 ) ;
        mass = mass * mass * mass;
        mass = this->getPlanetDensity() * mass;
        
        size_details.mass = mass;
        
}

---