src/skill-list.cpp

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 
00025 #include "skill-list.hpp"
00026 #include "xmlutils.hpp"
00027 #include <string.h>
00028 #include <malloc.h>
00029 #include <stdio.h>
00030 #include <iostream>
00031 
00032 static void checkString(char* mod,char* s){
00033         int ix;
00034         for(ix=0;ix<strlen(s);ix++)
00035                 if ( ! 
00036                          ( 
00037                            (( 'a' <= s[ix] ) && ( s[ix] <= 'z' ) )|| 
00038                            (( 'A' <= s[ix] ) && ( s[ix] <= 'Z' )) ||
00039                            (( '0' <= s[ix] ) && ( s[ix] <= '9' )) ||
00040                            ( s[ix] == '\''  ) ||
00041                            ( s[ix] == ' '  ) ||
00042                            ( s[ix] == '-' ) 
00043                           ) 
00044                         ) {
00045                                 fprintf(stderr,"%s: Bad string: \"%s\"\n",mod,s);
00046                                 exit(1);
00047                         }
00048 
00049 }
00050 
00051 skillList::skillList(){
00052         root = new skillEntry();
00053         root->setSkill("ROOT NODE");
00054         root->setLevel(-100);
00055         
00056 }
00057 
00058 void skillList::addSkill(char *s,int l) {
00059         skillEntry* p = root;
00060         while(p->getNext() != (skillEntry*)0){
00061                 p = p->getNext();
00062                 if ( strcmp(p->getSkill(),s) == 0 ) {
00063                         p->setLevel(p->getLevel()+l);
00064                         if ( p->getLevel() < 0 ) 
00065                                 p->setLevel(0);
00066                         return;
00067                 }
00068         }
00069         skillEntry *n = new skillEntry(s,l);
00070         p->setNext(n);
00071         n->setNext((skillEntry*)0);
00072         fprintf(stderr,"WARN:  obsolete method skillList::addSkill(char*,int) being called.\n");
00073         
00074         
00075 }
00076 
00077 void skillList::addSkill(skillObj* s){
00078         skillEntry* p=root;
00079                 while(p->getNext() != (skillEntry*)0){
00080                 p = p->getNext();
00081                 if ( strcmp(p->getSkill(),s->getSkill()) == 0 ) {
00082                         p->setLevel(p->getLevel()+ s->getLevel());
00083                         if ( p->getLevel() < 0 ) 
00084                                 p->setLevel(0);
00085                         return;
00086                 }
00087         }
00088         
00089         p->setNext(s);
00090         s->setNext((skillEntry*)0);
00091         
00092 }
00093 
00094 int skillList::skillCount(){
00095         int count=0;
00096         skillEntry* p = root;
00097         while ( p->getNext() != (skillEntry*)0){
00098                 p = p->getNext();
00099                 count++;
00100         }
00101         return count;
00102 }
00103 
00104 char** skillList::listOfSkills(){
00105         int dimx = this->skillCount();
00106         char** buffer=(char**)malloc(dimx);
00107         int ix=0;
00108         skillEntry *p=root;
00109         
00110         if (root->getNext() == (skillEntry*)0)
00111                 return (char**)0;  // This should never happen. 
00112         while( p->getNext() != (skillEntry*)0){
00113                 p=p->getNext();
00114                 buffer[ix]=p->toString();
00115                 checkString("skillList::listOfSkills",buffer[ix]);
00116                 ix++;
00117         }
00118         return (char **) buffer;
00119 }
00120 
00121 
00122 
00123 char *skillList::listOfSkillString(){
00124         int size = 0;
00125         int linesize=0;
00126         int ix;
00127         skillEntry *p=root;
00128         char* buffer;
00129         
00130         if ( this->skillCount() == 0 ) 
00131                 return "NONE";
00132         
00133         while(p->getNext()!=(skillEntry*)0){
00134                 p=p->getNext();
00135                 char *skill=p->getSkill();
00136                 int  level = p->getLevel();
00137                 char rval[10];
00138                 
00139                 sprintf(rval," - %d",level);
00140                 
00141                 linesize = linesize + strlen(skill) + strlen(rval) + 1 ;
00142                 size = size + strlen(skill) + strlen(rval) + 1 ;
00143                 
00144                 if ( linesize >= 71 ) {
00145                         linesize=0;
00146                         size = size + 2;
00147                 }
00148         }
00149         
00150         buffer=(char *)malloc(size+1);
00151         sprintf(buffer,"\n");
00152         p=root;
00153         linesize=0;
00154         while(p->getNext()!=(skillEntry*)0){
00155                 p=p->getNext();
00156                 char *skill=p->getSkill();
00157                 int  level = p->getLevel();
00158                 char rval[10];
00159                 
00160                 sprintf(rval,"-%d",level);
00161                 
00162                 
00163                 if ( (linesize + strlen(skill) + strlen(rval) )  >=72 ) {
00164                         linesize=0;
00165                         sprintf(buffer,"%s\n",buffer);
00166                 } else {
00167                         linesize = linesize + strlen(skill) + strlen(rval) + 1;
00168                 }
00169                 sprintf(buffer,"%s%s%s ",buffer,skill,rval);
00170         }
00171         return buffer;
00172 }
00173 
00174 void skillList::XMLout(FILE* fout){
00175         skillEntry *p = root;
00176         
00177         fprintf(fout,"\t%s\n",createStartElement("skill-list"));
00178         while(p->getNext() != (skillEntry*)0){
00179                 p=p->getNext();
00180                 p->XMLout(fout);
00181         }
00182         
00183         fprintf(fout,"\t%s\n",createEndElement("skill-list"));
00184         
00185 }
00186 
00187                 

Generated on Fri Mar 7 16:40:53 2008 for frpuniverse by  doxygen 1.4.7