src/person-obj.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.
 */

#include "person-obj.hpp"
#include "dice.hpp"
#include "string.h"
#include "numeric2string.hpp"
#include "malloc.h"
#include "stdio.h"


personObj::personObj(){
        int ix;
        for(ix=0;ix<6;ix++){
                physical_stats.upp[ix]=d2d6();
        }
        age = 18;
        accepted=0;
        alive=1;
        terms=0;
        rank=0;
        commissioned=0;
        cash=0;
        skills = new skillList();
        musterOutBenefits = new materialBenefitList();
        
}
int personObj::getCommissioned(){
        return commissioned;
}

void personObj::setCommissioned(int c){
        commissioned=(c==0?0:1);
}
int personObj::getRank(){
        return rank;
}
void personObj::setRank(int r){
        rank = r;
}
int personObj::getTerms(){
        return terms;
}

void personObj::setTerms(int t){
        terms=t;
}

int personObj::getIndexedAttribute(int ix){
        return this->physical_stats.upp[ix];
}

char* personObj::toString(){
        char *buffer;
        int ix;
        buffer=(char*)malloc(50); // more than what we need, but oh-well...
        buffer[0]='\0';
        
        sprintf(buffer,"%s: ","UPP");
        for(ix=0;ix<6;ix++){
                strcat(buffer,itohex(physical_stats.upp[ix]));
        }
        sprintf(buffer,"%s Age: %d",buffer,age);
        return buffer;
}

char* personObj::UPPasString(){
                char *buffer;
        int ix;
        buffer=(char*)malloc(50); // more than what we need, but oh-well...
        buffer[0]='\0';
        
        sprintf(buffer,"%s: ","UPP");
        for(ix=0;ix<6;ix++){
                strcat(buffer,itohex(physical_stats.upp[ix]));
        }
        return buffer;
}

void personObj::setService(char *s){
        service=s;
}
char* personObj::getService(){
        return service;
}

void personObj::incrementAge(int ix){
        age = age + ix;
}

void personObj::incrementStrength(int ix){
        this->incrementAttribute(STRENGTH,ix);
}

void personObj::incrementDexterity(int ix){
        this->incrementAttribute(DEXTERITY,ix);
}

void personObj::incrementEndurance(int ix){
        this->incrementAttribute(ENDURANCE,ix);
}

void personObj::incrementIntelligence(int ix){
        this->incrementAttribute(INTELLIGENCE,ix);
}

void personObj::incrementEducation(int ix){
        this->incrementAttribute(EDUCATION,ix);
}

void personObj::incrementSocialStanding(int ix){
        this->incrementAttribute(SOCIALSTANDING,ix);
}

int personObj::getStrength(){
        return physical_stats.a.strength; 
}

void personObj::setStrength(int s){ 
        physical_stats.a.strength=s; 
}

void personObj::setDexterity(int d) { 
        physical_stats.a.dexterity=d;
}

int personObj::getDexterity(){ 
        return physical_stats.a.dexterity;
}

void personObj::setEndurance(int c){ 
        physical_stats.a.endurance=c;
}

int personObj::getEndurance(){ 
        return physical_stats.a.endurance;
}

int personObj::getIntelligence(){ 
        return physical_stats.a.intelligence; 
}

void personObj::setIntelligence(int i){ 
        physical_stats.a.intelligence=i; 
}

int personObj::getEducation(){ 
        return physical_stats.a.education; 
}

void personObj::setEducation(int e){ 
        physical_stats.a.education=e; 
}

void  personObj::setSocialStanding(int s){ 
        physical_stats.a.social_standing=s;
}

int   personObj::getSocialStanding(){ 
        return physical_stats.a.social_standing; 
}

int personObj::getAge(){ 
        return age;
}

void personObj::setAge(int a){ 
        age=a; 
}

void personObj::incrementAttribute(int attr,int incr){
        physical_stats.upp[attr] = physical_stats.upp[attr] + incr;
        if ( physical_stats.upp[attr] < 0 ) 
                physical_stats.upp[attr] = 0;
        
}

int personObj::getAccepted(){
        return accepted;
}
void personObj:: setAccepted(int a){
        accepted=(a!=0 ? 1 : 0 ) ;
}

int personObj::survived(){
        // I could have just returned the value of "alive" but decided 
        // this was more readable.  So shoot me....
        //
        
        if ( alive == 1 ) return 1;
        else return 0;
}

int personObj::wasRejected(){
        if (accepted == 1) return 0;
        else return 1;
        
}

int personObj::getAlive(){
        return alive;
}
void personObj::setAlive(int a){
        alive=(a == 0 ? 0 : 1 ) ;
}

int personObj::skillCount(){
        return skills->skillCount();
}

char **personObj::listOfSkills(){
        return skills->listOfSkills();
}


void personObj::addSkill(int s,int l){
        skills->addSkill(new skillObj(this,s,l));
                
}


char* personObj::listOfSkillString(){
        return skills->listOfSkillString();
}

skillList* personObj::getSkillList(){
        return skills;
}

double personObj::getCash(){
        return cash;
}

void personObj::setCash(double c){
        cash=c;
}

materialBenefitList* personObj::getBenefitList(){
        return musterOutBenefits;
}

void personObj::addMaterialBenefit(materialBenefit *b){
        musterOutBenefits->addBenefit(b);
}

---