khanat-opennel-code/code/ryzom/tools/phrase_generator/phrase_generator.cpp

2758 lines
85 KiB
C++
Raw Normal View History

2016-12-09 15:04:26 +00:00
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// phrase_generator.cpp : Defines the entry point for the console application.
//
//-b -p r:\code\ryzom\data_leveldesign -o r:/code/ryzom/data_leveldesign/leveldesign/game_element/sphrase/magic/ magic_bricks.csv -d -m
// -p r:\code\ryzom\data_leveldesign -o r:/code/ryzom/data_leveldesign/leveldesign/game_element/sphrase/magic/ magic_bricks.csv -d -m
#include "stdafx.h"
// Misc
#include <nel/misc/types_nl.h>
#include "nel/misc/path.h"
#include "nel/misc/file.h"
#include "nel/misc/smart_ptr.h"
#include "nel/misc/command.h"
#include "nel/misc/common.h"
#include "nel/misc/path.h"
#include <nel/misc/sstring.h>
#include <nel/misc/diff_tool.h>
#include "nel/misc/algo.h"
#include "nel/misc/words_dictionary.h"
// Georges
#include "nel/georges/u_form.h"
#include "nel/georges/u_form_elm.h"
#include "nel/georges/u_form_dfn.h"
#include "nel/georges/u_form_loader.h"
#include "nel/georges/u_type.h"
// Georges, bypassing interface
#include "georges/stdgeorges.h"
#include "georges/form.h"
// Game share
//#include "game_share/xml.h"
// Unicode language file
// C
#include <time.h>
#include <stdio.h>
#include <conio.h>
#include <fstream>
// stl
#include <map>
#include "skill_tree.h"
using namespace NLMISC;
using namespace NLGEORGES;
using namespace std;
typedef vector<string> vs;
typedef map< string, string > mss;
typedef map< string, vs > msvs;
bool GenerateBrickProgression = false;
bool ProduceDocFromExistingPhrases = false;
bool MultipleDocFiles = false;
bool Hypertext = true;
string PhrasePath = "r:/code/ryzom/data_leveldesign/leveldesign/game_element/sphrase/";
uint NbSheetsGenTries = 0;
uint NbSheetsWritten = 0;
uint NbSheetsRead = 0;
uint NbSheetsRejected = 0;
bool UseBricks;
const string brSheetType = "sbrick";
const string phSheetType = "sphrase";
const string PHRASE_MAGIC_PREFIX = "abm_"; // action bricks magic (bm for brick filter)
struct CBrickInfo
{
CBrickInfo( const string& ls="", const string& t="",
const vs& props=vs() ) :
LearnSkills(ls), Text(t), Props(props) {}
string LearnSkills;
string Text; // UTF-8
vs Props;
};
vs OptionBricks, CounterpartBricks, AllBricks, PhrasesWithInvalidCost, InvalidPhrases;
set<string> UsedCounterpartBricks, UsedCounterpartBrickFamiliesInPhrase;
map<string, sint> SabrinaCosts;
map<string, sint> PhraseSabrinaCosts;
map<string, bool> PhraseCastable;
map<string, CBrickInfo> BrickInfo;
mss TextToBrick;
multimap< uint, pair<string, string> > Progression; // phrase code, min. skill
mss PhraseNames, PhraseTitles;
vector<vs> ValidPhrases;
set<string> UsedBricks, GeneratedPhrases;
map<string, vs> GrammarMandatParamBrickFamilies, GrammarOptionCreditBrickFamilies;
UFormLoader *FormLoader;
vector<FILE*> PhraseDocFiles( 26 );
string DocFileName,DocFileNameRoot;
msvs Phrases;
map<string,uint> SkillNameToMaxSkill;
map<string,string> PhraseCodeToLink;
CWordsDictionary Dico;
CStaticSkillsTree SkillsTree;
/*
*
*/
string inputSheetPath;
bool inputSheetPathLoaded = false;
map<string, string> inputSheetPathContent; // short filename without ext, full filename with path
//-----------------------------------------------
// getBrickTypeLetterRPos
//
//-----------------------------------------------
uint getBrickTypeLetterRPos( string& brick )
{
/*
uint i =0;
while( i<brick.size() && !isdigit(brick[i]) )
i++;
nlassert(i<brick.size());
return (brick.size() - i + 2);
*/
uint i =brick.size()-1;
while( i>=0 && (isdigit(brick[i]) || brick[i]=='_') )
i--;
return (brick.size() - i + 1);
} // getBrickTypeLetterRPos //
//-----------------------------------------------
// loadSheetPath
//
// from georges2csv
//-----------------------------------------------
void loadSheetPath()
{
if (inputSheetPathLoaded)
return;
NLMISC::createDebug();
NLMISC::WarningLog->addNegativeFilter( "CPath::insertFileInMap" );
CPath::addSearchPath(inputSheetPath, true, false); // for Georges to work properly
vector<string> files;
CPath::getPathContent (inputSheetPath, true, false, true, files);
uint i;
for (i=0; i<files.size(); ++i)
{
string filename = files[i];
string filebase = CFile::getFilenameWithoutExtension(filename);
if( CFile::getExtension(filename)!="saibrick" && CFile::getExtension(filename)!="saiphrase" )
{
inputSheetPathContent[filebase] = filename;
}
}
inputSheetPathLoaded = true;
} // loadSheetPath //
/*
*
*/
void displayList( const string& title, const vector<string>& v, CLog *log=DebugLog )
{
if ( ! title.empty() )
log->displayRaw( "%s: ", title.c_str() );
vector<string>::const_iterator ist;
for ( ist=v.begin(); ist!=v.end(); ++ist )
log->displayRaw( "%s ", (*ist).c_str() );
log->displayRawNL( "" );
}
/*
*
*/
class CStrIComparator : public binary_function<string, string, bool>
{
public:
bool operator() ( const string& s1, const string& s2 ) const
{
return (nlstricmp( s1, s2 ) == 0);
}
};
/*
*
*/
uint getIndexFromString( const string& s, const vector<string>& v, bool displayWarning=true )
{
if ( v.empty() )
{
nlwarning( "Can't find '%s' in empty array", s.c_str() );
return ~0;
}
else
{
vector<string>::const_iterator ist = find_if( v.begin(), v.end(), bind2nd(CStrIComparator(), s) );
if ( ist == v.end() )
{
if ( displayWarning )
{
nlwarning( "Can't find '%s' in:", s.c_str() );
displayList( "", v, WarningLog );
}
return ~0;
}
else
return ist - v.begin();
}
}
//-----------------------------------------------
// Erase every carriage returns of the string
//
//-----------------------------------------------
void eraseCarriageReturns( string& s )
{
const char CR = '\n';
string::size_type p = s.find( CR );
while ( (p=s.find( CR )) != string::npos )
s.erase( p, 1 );
} //
// First param: vector of indices of columns matching wantedColumnNames
// Second param: vector of fields matching wantedColumnNames
typedef void (*TDeliveryCallback) ( mss& );
//-----------------------------------------------
// loadCSVFile
//
//-----------------------------------------------
void loadCSVFile( const char *filename, TDeliveryCallback deliveryCallback )
{
char lineBuffer[2048];
FILE *file;
const char *SEPARATOR = ";";
vector<string> args;
vector<string>::iterator iarg;
if ( (file = nlfopen( filename, "r" )) == NULL )
{
nlwarning( "Can't find file %s", filename );
}
else
{
// Read first line as header with column names
lineBuffer[0] = '\0';
fgets( lineBuffer, 2048, file );
explode( lineBuffer, SEPARATOR, args );
// Store column names (and get rid of carriage returns!)
vector < string > columnNames;
mss valuesByName;
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
eraseCarriageReturns( *iarg );
columnNames.push_back( *iarg );
valuesByName.insert( make_pair( *iarg, string("") ) );
}
// for each line, deliver the value of the fields
while ( ! feof(file) )
{
// Get from file
lineBuffer[0] = '\0';
fgets( lineBuffer, 2048, file );
explode( lineBuffer, SEPARATOR, args );
// Set values (and get rid of carriage returns!)
for ( iarg=args.begin(); iarg!=args.end(); ++iarg )
{
eraseCarriageReturns( *iarg );
valuesByName[columnNames[iarg-args.begin()]] = *iarg;
}
// Deliver the wanted fields
deliveryCallback( valuesByName );
}
}
} // loadCSVFile //
//set<string> Skills;
//-----------------------------------------------
// brickDeliveryCallback
//
// Fetch brick code and sabrina cost
// - AllBricks
// - BrickInfo
// - OptionBricks
// - CounterpartBricks
// - SabrinaCosts
//-----------------------------------------------
void brickDeliveryCallback( mss& values )
{
string s = values["Brick_id"];
if ( s.empty() )
{
s = values["FILE"];
if ( s.empty() )
s = values["fileName"];
}
string brick = CFile::getFilenameWithoutExtension( s );
strupr( brick );
if ( brick.empty() )
{
nlwarning("<brickDeliveryCallback> can't get root filename of %s",s.c_str());
return;
}
string sc = values["Basics.SabrinaCost"];
string ls = values["Basics.LearnRequiresOneOfSkills"];
string txt = values["name"]; // TODO: only for combat
string fmn = values["familyName"];
string propIdent = "Basics.Property";
if ( UseBricks )
{
AllBricks.push_back( brick );
string name = (txt.empty()) ? fmn : txt;
vs props;
// Find all Basics.Property N (assumes they are subsequent)
mss::const_iterator imv = values.find( propIdent + " 0" );
for ( ; imv!=values.end(); ++imv )
{
const string& colName = (*imv).first;
const string& v = (*imv).second;
if ( colName.find( propIdent ) != string::npos )
{
if ( v != "NULL" && !v.empty() )
props.push_back( v );
}
else
break;
}
BrickInfo.insert( make_pair( brick, CBrickInfo( ls, name, props ) ) );
}
// Store brick in right container
string::size_type p = brick.size() - getBrickTypeLetterRPos(brick);
if ( ((sint)p) >= 0 )
{
switch ( brick[p] )
{
case 'O': OptionBricks.push_back( brick );
break;
case 'C': CounterpartBricks.push_back( brick );
break;
}
}
else
{
nlwarning( "Invalid brick code: %s", brick.c_str() );
return;
}
// Store cost
sint sabrinaCost;
if ( sc.empty() )
{
nldebug( "No sabrina cost for %s, assuming cost 0", brick.c_str() );
sabrinaCost = 0;
}
else
{
sabrinaCost = atoi( sc.c_str() );
}
SabrinaCosts.insert( make_pair( brick, sabrinaCost ) );
/* // Quick hack to generate skill codes
string skill = brick.substr( 1, p-1 );
if ( ! skill.empty() )
Skills.insert( skill );*/
} // brickDeliveryCallback //
//-----------------------------------------------
// loadBricks
//
//-----------------------------------------------
void loadBricks( const char* filename )
{
loadCSVFile( filename, brickDeliveryCallback );
if ( ProduceDocFromExistingPhrases )
nlinfo( "Loaded %u option bricks, %u counterpart bricks, %u sabrina costs", OptionBricks.size(), CounterpartBricks.size(), SabrinaCosts.size() );
else if ( UseBricks )
nlinfo( "Loaded %u bricks", AllBricks.size() );
/*set<string>::const_iterator iss;
for ( iss=Skills.begin(); iss!=Skills.end(); ++iss )
{
const string& skill = (*iss);
InfoLog->displayRawNL( " <DEFINITION Label=\"S%s\" Value=\"S%s\"/>", skill.c_str(), skill.c_str() );
}*/
} // loadBricks //
/*
*
*/
string getRootBrickForOptionOrCredit( const string& ob )
{
// Extract brick code radix
string::size_type p = ob.size() - getBrickTypeLetterRPos(const_cast<string&>(ob));
if ( (ob.size() <= getBrickTypeLetterRPos(const_cast<string&>(ob))) ||
((ob[p] != 'O') && (ob[p] != 'C')) )
nlerror( "%s is not an option or credit brick", ob.c_str() );
string radix = ob.substr( 0, p );
// Append root brick suffix
return radix + "PA01";
}
/*
*
*/
string getBrickFamily( const string& b )
{
if ( b.size() >= getBrickTypeLetterRPos(const_cast<string&>(b))+2 )
{
string::size_type p = b.size() - getBrickTypeLetterRPos(const_cast<string&>(b));
return b.substr( 0, p+2 );
}
return string();
}
/*
*
*/
bool isFromBrickFamily( const string& brick, const string& fam )
{
return nlstricmp( brick.substr( 0, fam.size() ), fam ) == 0;
}
/*
*
*/
string getFirstBrickOfFamily( const string& family )
{
vs::const_iterator ib;
for ( ib=AllBricks.begin(); ib!=AllBricks.end(); ++ib )
{
const string& brick = *ib;
if ( isFromBrickFamily( brick, family ) )
return brick;
}
return string();
}
/*
*
*/
vs getAllBricksOfFamily( const string& family )
{
vs res;
vs::const_iterator ib;
for ( ib=AllBricks.begin(); ib!=AllBricks.end(); ++ib )
{
const string& brick = *ib;
if ( isFromBrickFamily( brick, family ) )
res.push_back( brick );
}
return res;
}
/*
*
*/
uint getCompatibleCounterpartBrickForCost( uint phraseCost, vs& phrase )
{
//nlinfo( "Searching credit for cost %u", phraseCost );
// Get the lowest matching counterpart brick
uint minHigherCounterpartValue = ~0, maxLowerCounterpartValue = 0, counterpartValue;
vs::const_iterator icb, iPerfectMatch = CounterpartBricks.end(), iMinCb = CounterpartBricks.end(), iMaxCb = CounterpartBricks.end();
for ( icb=CounterpartBricks.begin(); icb!=CounterpartBricks.end(); ++icb)
{
const string& cb = *icb;
// Skip if family already used in current phrase
if ( UsedCounterpartBrickFamiliesInPhrase.find( getBrickFamily( cb ) ) != UsedCounterpartBrickFamiliesInPhrase.end() )
continue;
counterpartValue = abs( SabrinaCosts[cb] );
//nldebug( "Trying with credit %u", counterpartValue );
if ( counterpartValue == phraseCost )
{
// Perfect match, check if not already taken
if ( UsedCounterpartBricks.insert( cb ).second )
{
UsedCounterpartBrickFamiliesInPhrase.insert( getBrickFamily( cb ) );
phrase.push_back( cb );
return counterpartValue;
}
else
{
// If already taken, we will come back to it later
iPerfectMatch = icb;
}
}
else if ( counterpartValue > phraseCost )
{
// Higher => get the minimum
if ( counterpartValue < minHigherCounterpartValue )
{
minHigherCounterpartValue = counterpartValue;
iMinCb = icb;
}
}
else // counterpartValue < phraseCost : store the max
{
if ( counterpartValue >= maxLowerCounterpartValue )
{
maxLowerCounterpartValue = counterpartValue;
iMaxCb = icb;
}
}
}
if ( iPerfectMatch != CounterpartBricks.end() )
{
// We skipped a perfect match in order to try to get a new value. But none found. Now get back to the last value.
phrase.push_back( *iPerfectMatch );
UsedCounterpartBrickFamiliesInPhrase.insert( getBrickFamily( *iPerfectMatch ) );
return abs( SabrinaCosts[*iPerfectMatch] );
}
else if ( iMinCb == CounterpartBricks.end() )
{
if ( iMaxCb == CounterpartBricks.end() )
{
nlerror( "No matching counterpart" );
return ~0;
}
else
{
// No phrase possible with only one (more) counterpart, try with the max and more (recurse)
UsedCounterpartBricks.insert( *iMaxCb );
UsedCounterpartBrickFamiliesInPhrase.insert( getBrickFamily( *iMaxCb ) );
phrase.push_back( *iMaxCb );
return maxLowerCounterpartValue + getCompatibleCounterpartBrickForCost( phraseCost - maxLowerCounterpartValue, phrase );
}
}
else
{
// Phrase possible with one (more) counterpart
UsedCounterpartBricks.insert( *iMinCb );
UsedCounterpartBrickFamiliesInPhrase.insert( getBrickFamily( *iMinCb ) );
phrase.push_back( *iMinCb );
return minHigherCounterpartValue;
}
}
/*
*
*/
void getCompatibleCounterpartBricks( vs& phrase )
{
// Calculate the cost of the phrase
sint phraseCost = 0;
string phraseStr;
vs::const_iterator ip;
for ( ip=phrase.begin(); ip!=phrase.end(); ++ip )
{
const string& brick = *ip;
sint sabrinaCost;
map<string, sint>::const_iterator isc = SabrinaCosts.find( brick );
if ( isc != SabrinaCosts.end() )
sabrinaCost = (*isc).second;
else
sabrinaCost = 0;
phraseCost += sabrinaCost;
phraseStr += brick + " ";
}
// Find matching counterpart(s), only 1 per family
UsedCounterpartBrickFamiliesInPhrase.clear();
uint counterpartValue = getCompatibleCounterpartBrickForCost( phraseCost, phrase );
displayList( toString( "+%3u -%3u", phraseCost, counterpartValue ), phrase );
}
/*
*
*/
/*void getCompatiblePhraseByCounterpart( const string& counterpartBrick, vs& phrase )
{
sint sabrinaCost = SabrinaCosts[counterpartBrick];
// Assuming root brick cost is zero!
vs::const_iterator iob;
for ( iob=OptionBricks.begin(); iob!=OptionBricks.end(); ++iob )
{
// TODO: Find the highest cost that is lower or equal than the counterpart value
const string& ob = *iob;
if ( SabrinaCosts[ob] <= SabrinaCosts[counterpartBrick] )
break; // currently, take the first found
}
if ( iob != OptionBricks.end() )
{
string rb = getRootBrickForOptionOrCredit( *iob );
phrase.push_back( rb );
phrase.push_back( *iob );
phrase.push_back( counterpartBrick );
nldebug( "%s %s %s: +%u -%u", rb.c_str(), (*iob).c_str(), counterpartBrick.c_str(),
SabrinaCosts[rb]+SabrinaCosts[*iob], SabrinaCosts[counterpartBrick] );
}
else
nlwarning( "No matching phrase for counterpart %s", counterpartBrick.c_str() );
}*/
/*
* Clear the form to reuse it (and all contents below node)
*/
void clearSheet( CForm *form, UFormElm* node )
{
((CFormElm*)node)->clean();
form->clean();
}
/*
*
*/
inline void explodeBrickAndParameters( const string& brickAndParams, vs& bricks )
{
explode( brickAndParams, " ", bricks );
}
/*
*
*/
string getBrickType( const string& brick )
{
if ( brick.size() < 4 )
return "INVALID TYPE in " + brick;
else
{
switch ( brick[brick.size()-getBrickTypeLetterRPos(const_cast<string&>(brick))] )
{
case 'P': return "Root";
break;
case 'E': return "Effect";
break;
case 'O': return "Option";
break;
case 'M': return "Modifier";
break;
case 'C': return "Credit";
break;
default:
return "INVALID TYPE in " + brick;
}
}
}
//-----------------------------------------------
// printBrickInfo
//
//-----------------------------------------------
void printBrickInfo( FILE *htmlfile, const string& brick, const string& grammarError, sint& sabrinaCost, uint& minSkillValue, string& minSkill )
{
minSkill.clear();
string b = brick;
strupr( b );
string brickType = getBrickType( b );
sint sc = (brickType=="Credit") ? -abs( SabrinaCosts[b] ) : SabrinaCosts[b];
CBrickInfo& bInfo = BrickInfo[b];
fprintf( htmlfile, "<LI><B>%s %s</B> %s<BR>\n", brickType.c_str(), b.c_str(), bInfo.Text.c_str() );
if ( ! grammarError.empty() )
{
fprintf( htmlfile, "<FONT COLOR=\"RED\">%s</FONT><BR>\n", grammarError.c_str() );
}
else
{
fprintf( htmlfile, "Sabrina Cost: %d <BR>\n", sc );
if( !bInfo.LearnSkills.empty() )
{
fprintf( htmlfile, "Skills required: %s<BR>\n", bInfo.LearnSkills.c_str() );
}
if( bInfo.Props.size() )
{
fprintf( htmlfile, "Properties:" );
for ( vs::const_iterator ip = bInfo.Props.begin(); ip!=bInfo.Props.end(); ++ip )
{
fprintf( htmlfile, " %s", (*ip) );
}
}
}
fprintf( htmlfile, "</LI>\n" );
// Calculate sabrina cost & skill value
sabrinaCost = sc;
if ( bInfo.LearnSkills.empty() )
minSkillValue = 0;
else
{
minSkillValue = ~0;
vector<string> skillsAndValues;
explode( bInfo.LearnSkills, ":", skillsAndValues, true );
vector<uint> skillValues( skillsAndValues.size(), ~0 );
vector<string>::iterator isv;
for ( isv=skillsAndValues.begin(); isv!=skillsAndValues.end(); ++isv )
{
const string& sav = *isv;
string::size_type p = sav.find( ' ' );
if ( (p == string::npos) || (sav.size() == p+1) )
nlwarning( "Invalid LearnRequiresOneOfSkills value '%s'", sav.c_str() );
else
{
uint sv = atoi( sav.substr( p+1 ).c_str() );
skillValues[isv-skillsAndValues.begin()] = sv;
if ( sv < minSkillValue )
minSkillValue = sv;
}
}
for ( isv=skillsAndValues.begin(); isv!=skillsAndValues.end(); ++isv )
{
if ( skillValues[isv-skillsAndValues.begin()] == minSkillValue )
{
string& sav = *isv;
if ( (! sav.empty()) && (sav[0] != 'S') )
sav = 'S' + sav;
if ( minSkill.find( sav ) == string::npos )
{
if ( ! minSkill.empty() )
minSkill += ", ";
minSkill += sav;
}
}
}
}
} // printBrickInfo //
//-----------------------------------------------
// loadBrickGrammar
//
//-----------------------------------------------
void loadBrickGrammar()
{
uint nbRootBricks = 0;
vs::const_iterator ib;
for ( ib=AllBricks.begin(); ib!=AllBricks.end(); ++ib )
{
string brick = *ib;
strupr( brick );
if ( brick.size() >= 4 )
{
char brickType = brick[brick.size()-getBrickTypeLetterRPos(brick)];
/*// As the root bricks may be absent from the table, deduce them (obsolete)
if ( brickType == 'O' )
{
string rootBrick = getRootBrickForOptionOrCredit( brick );
if ( GrammarOptionCreditBrickFamilies.find( rootBrick ) == GrammarOptionCreditBrickFamilies.end() )
{
brick = rootBrick;
brickType = 'P';
}
else
{
continue;
}
}*/
// If not skipped by previous 'continue'
if ( (brickType == 'P') || (brickType == 'E') || (brickType == 'O' ) ) // root, effect, option
{
NLMISC::CSmartPtr<CForm> form = (CForm*)FormLoader->loadForm( (strlwr(static_cast<const string&>(brick))+"."+brSheetType).c_str() );
if ( ! form )
{
nlwarning( "Can't load sheet %s", ((strlwr(static_cast<const string&>(brick)))+"."+phSheetType).c_str() );
continue;
}
for ( uint i=0; i!=12; ++i )
{
string value;
form->getRootNode().getValueByName( value, toString( "Mandatory.f%u", i ).c_str() );
if ( (! value.empty()) && (value != "Unknown") )
{
GrammarMandatParamBrickFamilies[brick].push_back( value );
}
}
if ( brickType == 'O' )
{
for ( uint i=0; i!=4; ++i )
{
string value;
form->getRootNode().getValueByName( value, toString( "Parameter.f%u", i ).c_str() );
if ( (! value.empty()) && (value != "Unknown") )
{
GrammarMandatParamBrickFamilies[brick].push_back( value );
}
}
}
if ( brickType == 'P' ) // root
{
++nbRootBricks;
for ( uint i=0; i!=32; ++i )
{
string value;
form->getRootNode().getValueByName( value, toString( "Optional.f%u", i ).c_str() );
if ( (! value.empty()) && (value != "Unknown") )
{
GrammarOptionCreditBrickFamilies[brick].push_back( value );
}
}
for ( uint i=0; i!=12; ++i )
{
string value;
form->getRootNode().getValueByName( value, toString( "Credit.f%u", i ).c_str() );
if ( (! value.empty()) && (value != "Unknown") )
{
GrammarOptionCreditBrickFamilies[brick].push_back( value );
}
}
}
}
}
else
{
nlwarning( "Invalid brick code %s", brick.c_str() );
}
}
nlinfo( "%u bricks have mandatory/parameter grammar rules", GrammarMandatParamBrickFamilies.size() );
nlinfo( "%u bricks have option/credit grammar rules", GrammarOptionCreditBrickFamilies.size() );
nlinfo( "Found or deduced %u root bricks", nbRootBricks );
} // loadBrickGrammar //
//-----------------------------------------------
// loadPhraseTitles
//
//-----------------------------------------------
void loadPhraseTitles()
{
STRING_MANAGER::TWorksheet worksheet;
STRING_MANAGER::loadExcelSheet( "r:/code/ryzom/translation/translated/sphrase_words_en.txt", worksheet );
uint cp, cn;
if ( worksheet.findCol( ucstring("sphrase ID"), cp ) && worksheet.findCol( ucstring("name"), cn ) )
{
for ( std::vector<STRING_MANAGER::TWorksheet::TRow>::iterator ip = worksheet.begin(); ip!=worksheet.end(); ++ip )
{
if ( ip == worksheet.begin() ) // skip first row
continue;
STRING_MANAGER::TWorksheet::TRow& row = *ip;
PhraseTitles.insert( make_pair( strlwr(row[cp].toString()), row[cn].toUtf8() ) );
}
}
else
nlwarning( "sphrase ID or name not found" );
nlinfo( "Loaded %u phrase titles", PhraseTitles.size() );
} // loadPhraseTitles //
//-----------------------------------------------
// loadBrickTitles
//
//-----------------------------------------------
void loadBrickTitles()
{
STRING_MANAGER::TWorksheet worksheet;
STRING_MANAGER::loadExcelSheet( "r:/code/ryzom/translation/translated/sbrick_words_en.txt", worksheet );
uint cp, cn, nbTitles = 0;
if ( worksheet.findCol( ucstring("sbrick ID"), cp ) && worksheet.findCol( ucstring("name"), cn ) )
{
for ( std::vector<STRING_MANAGER::TWorksheet::TRow>::iterator ip = worksheet.begin(); ip!=worksheet.end(); ++ip )
{
if ( ip == worksheet.begin() ) // skip first row
continue;
STRING_MANAGER::TWorksheet::TRow& row = *ip;
BrickInfo[strupr(row[cp].toString())].Text = row[cn].toUtf8();;
++nbTitles;
}
}
else
nlwarning( "sbrick ID or name not found" );
nlinfo( "Loaded %u brick titles", nbTitles );
} // loadBrickTitles //
/*
*
*/
void getChildrenBricks( const string& brick, vs& chFamilies )
{
chFamilies = GrammarMandatParamBrickFamilies[brick];
}
/*
*
*/
void addError( string& errorStr, string& newError, uint& nbGrammarErrors )
{
if ( ! errorStr.empty() )
errorStr += "<BR>";
errorStr += newError;
++nbGrammarErrors;
}
/*
*
*/
void checkOptionOrCreditCompatibility( string& errorStr, const string& currentBrick, const string& rootBrick, uint& nbGrammarErrors )
{
string brick = currentBrick;
strupr( brick );
if ( brick.size() >= 4 && brick[1]!='C' && brick[1]!='H') // C & H for craft and harvest
{
char brickType = brick[brick.size()-getBrickTypeLetterRPos(brick)];
if ( (brickType == 'O') || (brickType == 'C') )
{
string rootBrick = getRootBrickForOptionOrCredit( brick );
const vs& compatibleOptionOrCredits = GrammarOptionCreditBrickFamilies[rootBrick];
vs::const_iterator ic;
for ( ic=compatibleOptionOrCredits.begin(); ic!=compatibleOptionOrCredits.end(); ++ic )
{
if ( isFromBrickFamily( brick, (*ic) ) )
break;
}
if ( ic == compatibleOptionOrCredits.end() )
{
addError( errorStr, toString( "This family is not compatible with options/credits of root %s", rootBrick.c_str() ), nbGrammarErrors );
}
}
}
}
/*
* Preconditions:
* - grammarErrors.size() == phrase.size()
* - r < phrase.size()
*
* Note: does not check that all bricks should have a different family
*/
void checkGrammar( const vs& phrase, uint& r, vs& grammarErrors, uint& nbGrammarErrors, const string& rootBrick, bool readNext=true )
{
uint origR = r;
string grammarBrick = phrase[origR];
strupr( grammarBrick );
// Check option/credit
checkOptionOrCreditCompatibility( grammarErrors[r], phrase[r], rootBrick, nbGrammarErrors );
// Check mandatory/parameter
vs chFamilies;
getChildrenBricks( grammarBrick, chFamilies );
++r;
for ( vs::const_iterator icf=chFamilies.begin(); icf!=chFamilies.end(); ++icf )
{
// Detect incomplete phrase
if ( r >= phrase.size() )
{
addError( grammarErrors[origR], "Missing mandatory/parameter " + (*icf) + " at the end", nbGrammarErrors );
break;
}
// Detect wrong brick family
if ( isFromBrickFamily( phrase[r], (*icf) ) )
{
// Check grammar using child as root
checkGrammar( phrase, r, grammarErrors, nbGrammarErrors, phrase[r], false );
}
else
{
addError( grammarErrors[r], "Error: " + (*icf) + " expected (mandatory/parameter of " + grammarBrick + ")", nbGrammarErrors );
++r;
}
}
// Next
if ( readNext && (r < phrase.size()) )
{
checkGrammar( phrase, r, grammarErrors, nbGrammarErrors, rootBrick );
}
}
/*
*
*/
char getDocFileLetter( const string& sheetName )
{
// skip abm_mt_, abm_ml_...
char letter = 'a';
uint nbUnderscoresToSkip = 2, nbUnderscoresFound = 0;
for ( uint c=0; c!=sheetName.size(); ++c )
{
if ( nbUnderscoresFound == nbUnderscoresToSkip )
{
letter = sheetName[c];
break;
}
if ( sheetName[c] == '_' )
++nbUnderscoresFound;
}
return tolower( letter );
}
//-----------------------------------------------
// testPhraseGrammarAndProduceDoc
//
//-----------------------------------------------
bool testPhraseGrammarAndProduceDoc( const string& sheetName, const vs& phrase )
{
string filename = strlwr( sheetName ) + "." + phSheetType;
string phraseStatus;
bool isPhraseCorrect = true;
const char *rejectedstr = "(grammatically invalid)";
// Check grammar for this phrase
vs grammarErrors( phrase.size() );
uint nbGrammarErrors = 0, r = 0;
checkGrammar( phrase, r, grammarErrors, nbGrammarErrors, phrase[0] );
if ( nbGrammarErrors != 0 )
{
InvalidPhrases.push_back( sheetName );
isPhraseCorrect = false;
phraseStatus = rejectedstr;
}
// Look-up phrase title
string phraseTitle = PhraseTitles[sheetName];
// Output phrase description
char letter = 'a';
if ( (! MultipleDocFiles) && (sheetName.size() > 3) )
{
letter = tolower( sheetName[3] );
}
else
{
letter = getDocFileLetter( sheetName );
}
if ( letter < 'a' )
letter = 'a';
else if ( letter > 'z' )
letter = 'z';
FILE *htmlFile = PhraseDocFiles[letter - 'a'];
sint sabrinaCost;
fprintf( htmlFile, "<A NAME=\"%s\"></A><P><B>%s</B> %s %s<BR><UL>\n", sheetName.c_str(), filename.c_str(), phraseTitle.c_str(), phraseStatus.c_str() );
vector<string> minBrickSkills( phrase.size() );
vector<uint> minBrickSkillValues( phrase.size(), 0 );
string brickMinSkill, maxSkill;
sint posCost = 0, negCost = 0, totalCost;
uint maxSkillValue = 0, brickMinSkillValue;
for ( uint i=0; i!=phrase.size(); ++i )
{
printBrickInfo( htmlFile, phrase[i], grammarErrors[i], sabrinaCost, brickMinSkillValue, brickMinSkill );
if ( sabrinaCost > 0 )
posCost += sabrinaCost;
else
negCost += sabrinaCost;
minBrickSkillValues[i] = brickMinSkillValue;
minBrickSkills[i] = brickMinSkill;
if ( brickMinSkillValue > maxSkillValue )
maxSkillValue = brickMinSkillValue;
}
for ( uint i=0; i!=phrase.size(); ++i )
{
if ( minBrickSkillValues[i] == maxSkillValue )
{
if ( maxSkill.find( minBrickSkills[i] ) == string::npos )
{
if ( ! maxSkill.empty() )
maxSkill += "; ";
maxSkill += minBrickSkills[i];
}
}
}
if ( phrase.size() > 1 )
{
string effectOrOptionBrick = phrase[1];
strupr( effectOrOptionBrick );
if ( ! PhraseNames.insert( make_pair( sheetName, BrickInfo[effectOrOptionBrick].Text ) ).second )
nlwarning( "Found duplicate phrase %s", sheetName.c_str() );
}
Progression.insert( make_pair( maxSkillValue, make_pair( sheetName, maxSkill ) ) );
totalCost = posCost + negCost;
PhraseSabrinaCosts.insert( make_pair(sheetName,totalCost) );
char *redbegin = "", *redend = "";
if ( totalCost > 0 )
{
map<string,bool>::const_iterator itCastable = PhraseCastable.find(sheetName);
if( itCastable != PhraseCastable.end() )
{
if( (*itCastable).second )
{
redbegin = "<FONT COLOR=\"RED\">";
redend = "</FONT>";
PhrasesWithInvalidCost.push_back( sheetName );
isPhraseCorrect = false;
}
}
}
fprintf( htmlFile, "<LI>%s<B>Total sabrina cost: </B>+%d %d = %d%s</LI>\n", redbegin, posCost, negCost, totalCost, redend );
fprintf( htmlFile, "<LI><B>Minimum skill value required: %d</B></LI>\n", maxSkillValue );
fprintf( htmlFile, "</UL></P>\n" );
if ( ! isPhraseCorrect )
{
++NbSheetsRejected;
}
return isPhraseCorrect;
} // testPhraseGrammarAndProduceDoc //
/*
*
*/
inline bool isSeparator( char c )
{
return (c == ' ') || (c == '\t');
}
//-----------------------------------------------
// produceDocFromExistingPhrases
//
// - Phrases
//-----------------------------------------------
void produceDocFromExistingPhrases()
{
vs files;
CPath::getPathContent( PhrasePath, true, false, true, files );
NbSheetsRead = 0;
for ( vs::const_iterator ip=files.begin(); ip!=files.end(); ++ip )
{
if ( CFile::getExtension( *ip ) == phSheetType )
{
// Read george sheet
NLMISC::CSmartPtr<UForm> form = (UForm*)FormLoader->loadForm( (*ip).c_str() );
if ( ! form )
nlerror( "Can't load sheet %s", (*ip).c_str() );
// Get the bricks of the phrase
vs phrase;
for ( uint i=0; i!=100; ++i )
{
string value;
form->getRootNode().getValueByName( value, toString( "brick %u", i ).c_str() );
if ( !value.empty() )
{
strupr( value );
phrase.push_back( CFile::getFilenameWithoutExtension( value ) );
}
}
Phrases.insert( make_pair(CFile::getFilenameWithoutExtension( *ip ), phrase) );
// look if phrase is castable
bool castable;
form->getRootNode().getValueByName( castable, "castable");
PhraseCastable.insert( make_pair(CFile::getFilenameWithoutExtension( *ip ), castable) );
// Test grammar and produce doc
testPhraseGrammarAndProduceDoc( CFile::getFilenameWithoutExtension( *ip ), phrase );
++NbSheetsRead;
}
}
nlinfo( "Total: %u phrases", NbSheetsRead );
} // produceDocFromExistingPhrases //
/*
*
*/
string getLink( const string& phrase )
{
string res;
if ( MultipleDocFiles && (! phrase.empty()) )
{
res += DocFileName + "_" + getDocFileLetter( phrase ) + ".html";
}
else
{
res += DocFileName + ".html";
}
res += "#" + phrase;
//nlinfo( "%s", res.c_str() );
return res;
}
/*
*
*/
void usage(char *argv0, FILE *out)
{
fprintf(out, "\n");
fprintf(out, "Syntax: %s [-p <sheet path>] <bricksFilename> [-o <phrasePath>] [-b] [-d] [-m] [-n]\n", argv0);
fprintf(out, "-o: output phrase path (or input if -d is set)\n");
fprintf(out, "-b: produce doc about brick learning infos\n");
fprintf(out, "-d: browse existing phrases in <phrasePath> (and subdirs) and produce doc\n");
fprintf(out, "-m: multiple doc html files, alphabetically (use with -g,-c,-d with numerous phrases)\n");
fprintf(out, "-n: no hypertext (don't produce links phrases)\n");
fprintf(out, "\n");
}
//-----------------------------------------------
// makeIndexFile
//
//-----------------------------------------------
void makeIndexFile()
{
FILE * indexFile = nlfopen( "_" + DocFileNameRoot + "_INDEX.html", "wt" );
if( indexFile )
{
fprintf( indexFile, ("<html><head>\n<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n<title>Summary of " + DocFileNameRoot + "</title>\n</head><body>\n").c_str() );
DocFileName = DocFileNameRoot + "_actions";
if ( MultipleDocFiles )
{
// One HTML file per alphabet letter
for ( uint l=0; l!=26; ++l )
{
string filename = toString( "%s_%c.html", DocFileName.c_str(), 'a'+l );
PhraseDocFiles[l] = nlfopen( filename, "wt" );
fprintf( PhraseDocFiles[l], ("<html><head>\n<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n<title>" + DocFileName + toString( " - %c", (char)('A'+l) ) + "</title>\n</head><body>\n").c_str() );
fprintf( indexFile, ("<A HREF=\"" + filename + "\">" + (char)('A'+l) + "</A> ").c_str() );
}
}
else
{
// One single HTML file
fprintf( indexFile, ("<A HREF=\"" + DocFileName + ".html\">Go to action details</A>").c_str() );
PhraseDocFiles[0] = nlfopen( DocFileName + ".html", "wt" );
fprintf( PhraseDocFiles[0], ("<html><head>\n<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n<title>" + DocFileName + "</title>\n</head><body>\n").c_str() );
for ( uint l=1; l!=26; ++l )
{
PhraseDocFiles[l] = PhraseDocFiles[0];
}
}
fprintf( indexFile, ("<BR><A HREF=\"" + DocFileName + "__by_skill_value.html" + "\">Go to action by skill value</A>\n").c_str() );
fprintf( indexFile, ("<BR><A HREF=\"" + DocFileName + "__by_skill_value_detail.html" + "\">Go to action by skill value (detail)</A>\n").c_str() );
fprintf( indexFile, ("<BR><A HREF=\"" + DocFileName + "__by_skill.html" + "\">Go to action by skill</A><BR>\n").c_str() );
if( GenerateBrickProgression )
{
fprintf( indexFile, ("<BR><BR><A HREF=\"" + DocFileNameRoot + ".html" + "\">Go to brick list</A><BR>\n").c_str() );
}
produceDocFromExistingPhrases();
for ( map< uint, pair<string, string> >::const_iterator ip=Progression.begin(); ip!=Progression.end(); ++ip )
{
const string& phraseCode = (*ip).second.first;
string link = Hypertext ? toString( "<A HREF=\"%s\">%s</A>", getLink(phraseCode).c_str(), phraseCode.c_str() ) : "<B>" + phraseCode + "</B>";
PhraseCodeToLink.insert( make_pair(phraseCode,link) );
}
// Summary (errors in phrases)
fprintf( indexFile, "<BR><A NAME=\"summary\"></A>\n" );
fprintf( indexFile, ("<FONT SIZE=\"20\">Summary of " + DocFileName + "</FONT><BR>\n").c_str() );
if ( NbSheetsGenTries != 0 )
fprintf( indexFile, "<P>%u valid sheets written on %u</P>\n", NbSheetsWritten, NbSheetsGenTries );
if ( NbSheetsRead != 0 )
fprintf( indexFile, "<P>%u sheets read</P>\n", NbSheetsRead );
fprintf( indexFile, "<P>%u invalid sheets rejected", NbSheetsRejected );
if ( ! PhrasesWithInvalidCost.empty() )
{
fprintf( indexFile, "<P><B>Phrases with invalid sabrina cost:</B><BR>\n" );
for ( vs::const_iterator iip=PhrasesWithInvalidCost.begin(); iip!=PhrasesWithInvalidCost.end(); ++iip )
{
string link = Hypertext ? toString( "<A HREF=\"%s\">%s</A>", getLink(*iip).c_str(), (*iip).c_str() ) : "<B>" + (*iip) + "</B>";
fprintf( indexFile, "%s<BR>\n", link.c_str() );
}
fprintf( indexFile, "</P>\n" );
}
else
{
fprintf( indexFile, "<P><B>All phrases have valid sabrina cost.</B></P>\n" );
}
if ( ! InvalidPhrases.empty() )
{
fprintf( indexFile, "<P><B>Grammatically invalid phrases:</B><BR>\n" );
for ( vs::const_iterator iip=InvalidPhrases.begin(); iip!=InvalidPhrases.end(); ++iip )
{
string link = Hypertext ? toString( "<A HREF=\"%s\">%s</A>", getLink(*iip).c_str(), (*iip).c_str() ) : "<B>" + (*iip) + "</B>";
fprintf( indexFile, "%s<BR>\n", link.c_str() );
}
fprintf( indexFile, "</P>\n" );
}
else
{
fprintf( indexFile, "<P><B>All phrases are grammatically valid.</B></P>\n" );
}
fprintf( indexFile, "</body></html>\n" );
fclose( indexFile );
if ( MultipleDocFiles )
{
for ( uint l=0; l!=26; ++l )
{
fprintf( PhraseDocFiles[l], "</body></html>\n" );
fclose( PhraseDocFiles[l] );
}
}
else
{
fprintf( PhraseDocFiles[0], "</body></html>\n" );
fclose( PhraseDocFiles[0] );
}
}
} // makeIndexFile //
//-----------------------------------------------
// makeActionsBySkillGroupFile
//
//-----------------------------------------------
void makeActionsBySkillGroupFile()
{
// progression by skill
FILE * actionsBySkillGroupFile = nlfopen( DocFileName + "__by_skill.html", "wt" );
if( actionsBySkillGroupFile )
{
fprintf( actionsBySkillGroupFile, ("<html><head>\n<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n<title>Progression of " + DocFileName + "</title>\n</head><body>\n").c_str() );
fprintf( actionsBySkillGroupFile, "<BR><A NAME=\"by_skill_group\"></A>\n" );
fprintf( actionsBySkillGroupFile, "<P><B>ACTIONS BY SKILL GROUP:</B><BR>\n<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n" );
map<string, multimap<uint,string> > phrasesBySkill;
for ( map< uint, pair<string, string> >::const_iterator ip=Progression.begin(); ip!=Progression.end(); ++ip )
{
const string& phraseCode = (*ip).second.first;
string skillName = (*ip).second.second.substr(0,(*ip).second.second.find(" "));
string skillValueStr = (*ip).second.second.substr((*ip).second.second.find(" ")+1,(*ip).second.second.size()-(*ip).second.second.find(" ")-1);
uint skillValue = atoi(skillValueStr.c_str());
map<string, multimap<uint,string> >::iterator it = phrasesBySkill.find(skillName);
if( it != phrasesBySkill.end() )
{
(*it).second.insert(make_pair(skillValue,phraseCode));
}
else
{
multimap<uint,string> m;
m.insert(make_pair(skillValue,phraseCode));
phrasesBySkill.insert( make_pair(skillName,m) );
}
}
map<string, multimap<uint,string> >::iterator itPhrasesBySkill;
for( itPhrasesBySkill = phrasesBySkill.begin(); itPhrasesBySkill != phrasesBySkill.end(); ++itPhrasesBySkill )
{
CVectorSString dicoResult;
Dico.lookup( (*itPhrasesBySkill).first, dicoResult, true );
if( !dicoResult.empty() )
fprintf( actionsBySkillGroupFile, "<tr><td><A HREF=\"#%s\">%s</A></td></tr>\n", (*itPhrasesBySkill).first.c_str(),dicoResult[0].c_str());
else
fprintf( actionsBySkillGroupFile, "<tr><td><A HREF=\"#%s\">%s</A></td></tr>\n", (*itPhrasesBySkill).first.c_str(),(*itPhrasesBySkill).first.c_str());
}
for( itPhrasesBySkill = phrasesBySkill.begin(); itPhrasesBySkill != phrasesBySkill.end(); ++itPhrasesBySkill )
{
CVectorSString dicoResult;
Dico.lookup( (*itPhrasesBySkill).first, dicoResult, true );
if( !dicoResult.empty() )
fprintf( actionsBySkillGroupFile, "<tr><td><A NAME=\"%s\"><B>%s</B></A><BR></td></tr>\n", (*itPhrasesBySkill).first.c_str(), dicoResult[0].c_str() );
else
fprintf( actionsBySkillGroupFile, "<tr><td><A NAME=\"%s\"><B>%s</B></A><BR></td></tr>\n", (*itPhrasesBySkill).first.c_str(),(*itPhrasesBySkill).first.c_str() );
multimap<uint,string>::iterator it;
for( it = (*itPhrasesBySkill).second.begin(); it != (*itPhrasesBySkill).second.end(); ++it )
{
fprintf( actionsBySkillGroupFile, "<tr><td>%d</td><td>%s</td><td>%s<BR></td></tr>\n", (*it).first, PhraseCodeToLink[(*it).second].c_str(), PhraseTitles[(*it).second].c_str());
}
}
fprintf( actionsBySkillGroupFile, "</tbody><table></P>\n" );
fprintf( actionsBySkillGroupFile, "</body></html>\n" );
fclose( actionsBySkillGroupFile );
}
} // makeActionsBySkillGroupFile //
//-----------------------------------------------
// makeActionsBySkillValueFile
//
//-----------------------------------------------
void makeActionsBySkillValueFile()
{
FILE * actionsBySkillValueFile = fopen( (DocFileName + "__by_skill_value.html").c_str(), "wt" );
if( actionsBySkillValueFile )
{
fprintf( actionsBySkillValueFile, ("<html><head>\n<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n<title>Progression of " + DocFileName + "</title>\n</head><body>\n").c_str() );
// Progression (phrases sorted by skill value)
fprintf( actionsBySkillValueFile, "<BR><A NAME=\"by_skill_value\"></A>\n" );
fprintf( actionsBySkillValueFile, "<P><B>ACTIONS BY SKILL VALUE: <A HREF=\"%s\">[detail]</A></B>\n<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n",(DocFileName + "__by_skill_value_detail.html").c_str() );
fprintf( actionsBySkillValueFile, "<tr><td><B>File</B></td><td><B>Name</B></td><td><B>Skill needed</B><BR></td></tr>\n");
map<string,string> phraseCodeToLink;
for ( map< uint, pair<string, string> >::const_iterator ip=Progression.begin(); ip!=Progression.end(); ++ip )
{
const string& phraseCode = (*ip).second.first;
fprintf( actionsBySkillValueFile, "<tr><td><font size=2>%s</font></td><td><font size=2>%s</font></td><td><B><font size=2>%s</font></B><BR></td></tr>\n", PhraseCodeToLink[phraseCode].c_str(), /*newbrickTitle.c_str(),*/ PhraseTitles[phraseCode].c_str(), (*ip).second.second.c_str() );
}
fprintf( actionsBySkillValueFile, "</tbody><table></P>\n" );
fprintf( actionsBySkillValueFile, "</body></html>\n" );
fclose( actionsBySkillValueFile );
}
} // makeActionsBySkillValueFile //
//-----------------------------------------------
// makeActionsBySkillValueDetailFile
//
//-----------------------------------------------
void makeActionsBySkillValueDetailFile()
{
FILE * actionsBySkillValueDetailFile = nlfopen( DocFileName + "__by_skill_value_detail.html", "wt" );
if( actionsBySkillValueDetailFile )
{
fprintf( actionsBySkillValueDetailFile, ("<html><head>\n<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n<title>Progression of " + DocFileName + "</title>\n</head><body>\n").c_str() );
// Progression summary (phrases sorted by skill value)
fprintf( actionsBySkillValueDetailFile, "<BR><A NAME=\"progression\"></A>\n" );
fprintf( actionsBySkillValueDetailFile, "<P><B>ACTIONS BY SKILL VALUE:</B><BR>\n<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n" );
fprintf( actionsBySkillValueDetailFile, "<tr><td><B>File</B></td><td><B>Name</B></td><td><B>Skill needed</B><BR></td><td><B>Sabrina cost</B></td><td><B>Bricks ...</B></td></tr>\n");
set<string> effects;
map<string,set<string> > effectAndModifiers;
for ( map< uint, pair<string, string> >::const_iterator ip=Progression.begin(); ip!=Progression.end(); ++ip )
{
const string& phraseCode = (*ip).second.first;
fprintf( actionsBySkillValueDetailFile, "<tr><td><font size=2>%s</font></td><td><font size=2>%s</font></td><td><B><font size=2>%s</font></B></td><td><font size=2>%d</font></td>",PhraseCodeToLink[phraseCode].c_str(), PhraseTitles[phraseCode].c_str(), (*ip).second.second.c_str(),PhraseSabrinaCosts[phraseCode]);
msvs::iterator itPhrases = Phrases.find( phraseCode );
if( itPhrases != Phrases.end() )
{
string effect;
uint modifierCount = 0;
uint creditCount = 0;
for( uint i = 0; i<(*itPhrases).second.size(); ++i )
{
string brick = (*itPhrases).second[i];
string color;
switch ( brick[brick.size()-getBrickTypeLetterRPos(brick)] )
{
case 'P': color = "Black";
break;
case 'E':
{
color = "Brown";
effects.insert(brick);
if( effectAndModifiers.find(brick) == effectAndModifiers.end() )
{
set<string> s;
effectAndModifiers.insert( make_pair(brick,s) );
}
effect = brick;
}
break;
case 'O': color = "Green";
break;
case 'M':
{
color = "Blue";
effectAndModifiers[effect].insert(brick);
modifierCount++;
}
break;
case 'C': color = "Red"; creditCount++;
break;
default:
color = "Black";
}
string text = BrickInfo[brick].Text;
if( text.empty() )
{
text = strlwr(brick);
nlwarning("%s not found in BrickInfo",brick.c_str());
}
else
{
if(text.find("$|sap")!=-1)
{
text = text.substr(0,text.size()-5);
string str = brick.substr(brick.size()-5,5);
text += toString(atoi(str.c_str()));
}
}
fprintf( actionsBySkillValueDetailFile, "<td><FONT COLOR=\"%s\" SIZE=2>%s</FONT></td>",color.c_str(),text.c_str());
}
}
else
{
nlerror("not found : %s",phraseCode.c_str());
}
fprintf( actionsBySkillValueDetailFile, "</tr>\n");
}
fprintf( actionsBySkillValueDetailFile, "</tbody><table></P>\n" );
fprintf( actionsBySkillValueDetailFile, "</body></html>\n" );
fclose( actionsBySkillValueDetailFile );
}
} // makeActionsBySkillValueDetailFile //
//-----------------------------------------------
// validateBrick
//
//-----------------------------------------------
bool validateBrick( const string& brk )
{
if(brk[1]=='C') return true;
if(brk[1]=='F') return true;
if(brk[1]=='H') return true;
if(brk[1]=='M') return true;
if(brk[1]=='S') return true;
return false;
} // validateBrick //
//-----------------------------------------------
// makeSkillTreeFile
//
//-----------------------------------------------
void makeSkillTreeFile( char filter, string skillFamily, bool withTraduction )
{
vector<map<string,uint16> > skillsArray;
skillsArray.resize(6); // 6 tranches de skill
uint i;
for( i = 0; i<SkillsTree.SkillsTree.size(); ++i )
{
string skillCode = SkillsTree.SkillsTree[i].SkillCode;
if( skillCode[1] == filter )
{
uint sIdx = skillCode.length()-2; // -1 for 'S', -1 for 0
skillsArray[sIdx].insert( make_pair(skillCode,SkillsTree.SkillsTree[i].MaxSkillValue) );
}
}
uint16 maxLine = 0;
for( i=0; i<skillsArray.size(); ++i )
{
if( skillsArray[i].size() > maxLine )
{
maxLine = skillsArray[i].size();
}
}
string filename = skillFamily + "_skill_tree.html";
string filenameWithTraduction = skillFamily + "_skill_tree_detailed.html";
FILE * skillTreeFile;
if( withTraduction )
skillTreeFile = nlfopen( filenameWithTraduction, "wt" );
else
skillTreeFile = nlfopen( filename, "wt" );
fprintf( skillTreeFile,"<html><head>\n");
fprintf( skillTreeFile,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( skillTreeFile,"<title>SKILL TREE ( %s )</title>\n",skillFamily.c_str());
fprintf( skillTreeFile,"</head><body>\n");
if( withTraduction )
fprintf( skillTreeFile,"<b>SKILL TREE ( %s )</b>\n",skillFamily.c_str());
else
fprintf( skillTreeFile,"<b>SKILL TREE ( %s )</b> [<A HREF=\"%s\">display traduction</A>]<BR>\n",skillFamily.c_str(),filenameWithTraduction.c_str());
fprintf( skillTreeFile,"<table cellpadding=\"2\" cellspacing=\"2\" border=\"0\" style=\"text-align: left;\"><tbody>\n");
fprintf( skillTreeFile,"<tr><td><b>0 to 20</b></td><td><b>20 to 50</b></td><td><b>50 to 100</b></td><td><b>100 to 150</b></td><td><b>150 to 200</b></td><td><b>200 to 250</b></td></tr>\n");
uint j;
// print line by line
for( j=0; j<maxLine; ++j )
{
fprintf( skillTreeFile,"<tr>");
// for each column
for( i=0; i<skillsArray.size(); ++i )
{
uint p;
map<string,uint16>::iterator itSkillcode;
for( itSkillcode = skillsArray[i].begin(), p=0; itSkillcode != skillsArray[i].end() && p<j; ++itSkillcode,++p );
if( itSkillcode != skillsArray[i].end() )
{
if( withTraduction )
{
CVectorSString dicoResult;
Dico.lookup( (*itSkillcode).first, dicoResult, true );
if(dicoResult.empty())
fprintf( skillTreeFile,"<td>%s : ???</td>",(*itSkillcode).first.c_str());
else
fprintf( skillTreeFile,"<td>%s</td>",dicoResult[0].c_str());
}
else
fprintf( skillTreeFile,"<td>%s</td>",(*itSkillcode).first.c_str());
}
else
fprintf( skillTreeFile,"<td></td>");
}
fprintf( skillTreeFile,"</tr>\n");
}
fprintf( skillTreeFile, "</tbody><table></P>\n" );
fprintf( skillTreeFile, "</body></html>\n" );
fclose( skillTreeFile );
} // makeSkillTreeFile //
//-----------------------------------------------
// MAIN
//
//-----------------------------------------------
int main(int argc, char* argv[])
{
// parse command line
const char *inputFilename = NULL;
for ( uint i=1; (sint)i!=argc; i++ )
{
const char *arg = argv[i];
if ( arg[0] == '-' )
{
switch ( arg[1] )
{
case 'p':
++i;
if ( (sint)i == argc )
{
fprintf( stderr, "Missing <sheet path> after -p option\n" );
usage( argv[0], stderr );
exit( 0 );
}
inputSheetPath = argv[i];
break;
case 'o':
++i;
if ( (sint)i == argc )
{
fprintf( stderr, "Missing <phrasePath> after -o option\n" );
usage( argv[0], stderr );
exit( 0 );
}
PhrasePath = argv[i];
if ( PhrasePath[PhrasePath.size()-1] != '/' )
PhrasePath += '/';
break;
case 'b' :
GenerateBrickProgression = true;
break;
case 'd':
ProduceDocFromExistingPhrases = true;
break;
case 'm':
MultipleDocFiles = true;
break;
case 'n':
Hypertext = false;
break;
}
}
else
{
if ( CFile::getExtension(arg) == "csv" )
{
inputFilename = arg;
}
else
nlerror( "Unrecognized extension in %s", arg );
}
}
Dico.init();
loadSheetPath();
FormLoader = UFormLoader::createLoader();
CSheetId::init();
CSheetId skillTreeSheet("skills.skill_tree");
CSmartPtr<UForm> skillTreeForm = FormLoader->loadForm( "skills.skill_tree" );
SkillsTree.readGeorges( skillTreeForm, skillTreeSheet );
makeSkillTreeFile('C',"craft", false);
makeSkillTreeFile('F',"fight", false);
makeSkillTreeFile('H',"forage", false);
makeSkillTreeFile('M',"magic", false);
makeSkillTreeFile('C',"craft", true);
makeSkillTreeFile('F',"fight", true);
makeSkillTreeFile('H',"forage", true);
makeSkillTreeFile('M',"magic", true);
// Load bricks from the csv
UseBricks = ProduceDocFromExistingPhrases;
if ( UseBricks )
{
if ( ! inputFilename )
{
usage( argv[0], stderr );
exit( 0 );
}
loadBricks( inputFilename );
}
// Phrases
if ( ProduceDocFromExistingPhrases )
{
loadBrickGrammar();
loadBrickTitles();
loadPhraseTitles();
DocFileNameRoot = toString( "%s", CFile::getFilenameWithoutExtension( inputFilename ).c_str() );
// index
makeIndexFile();
// progression by skill
makeActionsBySkillGroupFile();
// Progression (phrases sorted by skill value)
makeActionsBySkillValueFile();
// Progression (phrases sorted by skill value + detail)
makeActionsBySkillValueDetailFile();
}
if( GenerateBrickProgression )
{
map<uint,map<string,set<string> > > levelToBrick;
map<string,string> phraseToSkill;
for ( map< uint, pair<string, string> >::const_iterator ip=Progression.begin(); ip!=Progression.end(); ++ip )
{
const string& phraseCode = (*ip).second.first;
string skillTmp = (*ip).second.second.c_str();
phraseToSkill.insert( make_pair(phraseCode,skillTmp) );
if(skillTmp.empty()==false)
{
// get skill
string skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
// get level
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
if(levelStr.find(".")!=-1) levelStr = levelStr.substr(0,levelStr.size()-1);
uint level = atoi(levelStr.c_str());
map<uint,map<string,set<string> > >::iterator itLvl = levelToBrick.find(level);
if( itLvl == levelToBrick.end() )
{
set<string> s;
map<string,set<string> > mp;
mp.insert(make_pair(skill,s));
levelToBrick.insert(make_pair(level,mp));
}
else
{
if( (*itLvl).second.find(skill) == (*itLvl).second.end() )
{
set<string> s;
(*itLvl).second.insert( make_pair(skill,s) );
}
}
msvs::iterator itPhrases = Phrases.find( phraseCode );
if( itPhrases != Phrases.end() )
{
string effect;
for( uint i = 0; i<(*itPhrases).second.size(); ++i )
{
string brick = (*itPhrases).second[i];
if( levelToBrick[level][skill].find(brick) == levelToBrick[level][skill].end() )
{
levelToBrick[level][skill].insert(brick);
}
}
}
}
}
// get family & color
map<string,string> brickToColor;
map<string,string> brickToFamily;
map<string, CBrickInfo>::iterator itBInf;
for( itBInf=BrickInfo.begin(); itBInf!=BrickInfo.end(); ++itBInf )
{
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
string color;
string family;
if( brk[brk.size()-getBrickTypeLetterRPos(brk)] =='M' )
{
color = "Blue";
family = "Modifier";
}
if( brk[brk.size()-getBrickTypeLetterRPos(brk)] =='C' )
{
color = "Red";
family = "Credit";
}
if( brk[brk.size()-getBrickTypeLetterRPos(brk)] =='O' )
{
color = "Green";
family = "Option";
}
if( brk[brk.size()-getBrickTypeLetterRPos(brk)] =='P' )
{
color = "Black";
family = "Root";
}
if( brk[brk.size()-getBrickTypeLetterRPos(brk)] =='E' )
{
color = "Brown";
family = "Effect";
}
brickToColor.insert(make_pair(brk,color));
brickToFamily.insert(make_pair(brk,family));
}
// get phrases where the brick can be found
map<string,map<string,string> > brickToPhrases;
msvs::iterator itPhrases;
for( itPhrases=Phrases.begin(); itPhrases!=Phrases.end(); ++itPhrases )
{
for( uint i = 0; i<(*itPhrases).second.size(); ++i )
{
string brick = (*itPhrases).second[i];
if( brickToPhrases.find(brick)==brickToPhrases.end() )
{
map<string,string> m;
m.insert(make_pair((*itPhrases).first,phraseToSkill[(*itPhrases).first]));
brickToPhrases.insert(make_pair(brick,m));
}
else
{
brickToPhrases[brick].insert(make_pair((*itPhrases).first,phraseToSkill[(*itPhrases).first]));
}
}
}
// get skill when a brick is learnt
map<string,string> brickToLearnSkill;
map<string,map<string,string> >::iterator itLearn;
for( itLearn=brickToPhrases.begin(); itLearn!=brickToPhrases.end(); ++itLearn )
{
string minSkill;
uint minLevel = 250;
mss::iterator itPh;
for( itPh=(*itLearn).second.begin(); itPh!=(*itLearn).second.end(); ++itPh )
{
string skillTmp = (*itPh).second;
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
uint level = atoi(levelStr.c_str());
if( level<minLevel || minSkill.empty() )
{
minSkill = skillTmp;
minLevel = level;
}
}
brickToLearnSkill.insert(make_pair((*itLearn).first,minSkill));
}
// PHRASES
// write header and title bar
string filename;
filename = DocFileNameRoot + "_m.html";
FILE * brickPhraseDocFile_m = nlfopen( filename, "wt" );
fprintf( brickPhraseDocFile_m,"<html><head>\n");
fprintf( brickPhraseDocFile_m,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickPhraseDocFile_m,"<title>Brick phrases</title>\n");
fprintf( brickPhraseDocFile_m,"</head><body>\n");
fprintf( brickPhraseDocFile_m,"<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n");
filename = DocFileNameRoot + "_c.html";
FILE * brickPhraseDocFile_c = nlfopen( filename, "wt" );
fprintf( brickPhraseDocFile_c,"<html><head>\n");
fprintf( brickPhraseDocFile_c,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickPhraseDocFile_c,"<title>Brick phrases</title>\n");
fprintf( brickPhraseDocFile_c,"</head><body>\n");
fprintf( brickPhraseDocFile_c,"<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n");
filename = DocFileNameRoot + "_o.html";
FILE * brickPhraseDocFile_o = nlfopen( filename, "wt" );
fprintf( brickPhraseDocFile_o,"<html><head>\n");
fprintf( brickPhraseDocFile_o,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickPhraseDocFile_o,"<title>Brick phrases</title>\n");
fprintf( brickPhraseDocFile_o,"</head><body>\n");
fprintf( brickPhraseDocFile_o,"<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n");
filename = DocFileNameRoot + "_p.html";
FILE * brickPhraseDocFile_p = nlfopen( filename, "wt" );
fprintf( brickPhraseDocFile_p,"<html><head>\n");
fprintf( brickPhraseDocFile_p,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickPhraseDocFile_p,"<title>Brick phrases</title>\n");
fprintf( brickPhraseDocFile_p,"</head><body>\n");
fprintf( brickPhraseDocFile_p,"<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n");
filename = DocFileNameRoot + "_e.html";
FILE * brickPhraseDocFile_e = nlfopen( filename, "wt" );
fprintf( brickPhraseDocFile_e,"<html><head>\n");
fprintf( brickPhraseDocFile_e,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickPhraseDocFile_e,"<title>Brick phrases</title>\n");
fprintf( brickPhraseDocFile_e,"</head><body>\n");
fprintf( brickPhraseDocFile_e,"<table cellpadding=\"0\" cellspacing=\"1\" border=\"0\" style=\"text-align: left;\"><tbody>\n");
for( itBInf=BrickInfo.begin(); itBInf!=BrickInfo.end(); ++itBInf )
{
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
string code = strlwr(brk.c_str());
if(brickToFamily[brk]=="Modifier")
fprintf( brickPhraseDocFile_m,"<tr><td><A NAME=\"%s\"><FONT COLOR=\"Blue\">%s</FONT></A></td><td></td></tr>\n",brk.c_str(),code.c_str());
if(brickToFamily[brk]=="Credit")
fprintf( brickPhraseDocFile_c,"<tr><td><A NAME=\"%s\"><FONT COLOR=\"Red\">%s</FONT></A></td><td></td></tr>\n",brk.c_str(),code.c_str());
if(brickToFamily[brk]=="Option")
fprintf( brickPhraseDocFile_o,"<tr><td><A NAME=\"%s\"><FONT COLOR=\"Green\">%s</FONT></A></td><td></td></tr>\n",brk.c_str(),code.c_str());
if(brickToFamily[brk]=="Effect")
fprintf( brickPhraseDocFile_e,"<tr><td><A NAME=\"%s\"><FONT COLOR=\"Brown\">%s</FONT></A></td><td></td></tr>\n",brk.c_str(),code.c_str());
if(brickToFamily[brk]=="Root")
fprintf( brickPhraseDocFile_p,"<tr><td><A NAME=\"%s\"><FONT COLOR=\"Black\">%s</FONT></A></td><td></td></tr>\n",brk.c_str(),code.c_str());
map<string,map<string,string> >::iterator itPhrases = brickToPhrases.find(brk);
if( itPhrases != brickToPhrases.end() )
{
map<string,string>::iterator itPh;
for( itPh=(*itPhrases).second.begin(); itPh!=(*itPhrases).second.end(); ++itPh )
{
if(brickToFamily[brk]=="Modifier")
fprintf( brickPhraseDocFile_m,"<tr><td></td><td><A HREF=\"%s_%c.html#%s\">%s</A></td></tr>\n",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
if(brickToFamily[brk]=="Credit")
fprintf( brickPhraseDocFile_c,"<tr><td></td><td><A HREF=\"%s_%c.html#%s\">%s</A></td></tr>\n",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
if(brickToFamily[brk]=="Option")
fprintf( brickPhraseDocFile_o,"<tr><td></td><td><A HREF=\"%s_%c.html#%s\">%s</A></td></tr>\n",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
if(brickToFamily[brk]=="Effect")
fprintf( brickPhraseDocFile_e,"<tr><td></td><td><A HREF=\"%s_%c.html#%s\">%s</A></td></tr>\n",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
if(brickToFamily[brk]=="Root")
fprintf( brickPhraseDocFile_p,"<tr><td></td><td><A HREF=\"%s_%c.html#%s\">%s</A></td></tr>\n",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
}
}
}
fprintf( brickPhraseDocFile_m, "</tbody><table></P>\n" );
fprintf( brickPhraseDocFile_m, "</body></html>\n" );
fclose( brickPhraseDocFile_m );
fprintf( brickPhraseDocFile_c, "</tbody><table></P>\n" );
fprintf( brickPhraseDocFile_c, "</body></html>\n" );
fclose( brickPhraseDocFile_c );
fprintf( brickPhraseDocFile_o, "</tbody><table></P>\n" );
fprintf( brickPhraseDocFile_o, "</body></html>\n" );
fclose( brickPhraseDocFile_o );
fprintf( brickPhraseDocFile_e, "</tbody><table></P>\n" );
fprintf( brickPhraseDocFile_e, "</body></html>\n" );
fclose( brickPhraseDocFile_e );
fprintf( brickPhraseDocFile_p, "</tbody><table></P>\n" );
fprintf( brickPhraseDocFile_p, "</body></html>\n" );
fclose( brickPhraseDocFile_p );
// CODE
// write header and title bar
filename = DocFileNameRoot + ".html";
FILE * brickDocFile = nlfopen( filename, "wt" );
fprintf( brickDocFile,"<html><head>\n");
fprintf( brickDocFile,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickDocFile,"<title>Bricks infos</title>\n");
fprintf( brickDocFile,"</head><body>\n");
fprintf( brickDocFile,"<table cellpadding=\"1\" cellspacing=\"1\" border=\"0\"><tbody>\n");
fprintf( brickDocFile,"<tr>\n");
fprintf( brickDocFile,"<td><b>*Code*</b></td>\n");
fprintf( brickDocFile,"<td><b><a href=\"%s_name.html\">Name</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickDocFile,"<td><b><a href=\"%s_family.html\">Family</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickDocFile,"<td><b>Required Skill Name</b></td>\n");
fprintf( brickDocFile,"<td><b><a href=\"%s_required_skill_value.html\">Required Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickDocFile,"<td><b>Learn Skill Name</b></td>\n");
fprintf( brickDocFile,"<td><b><a href=\"%s_learn_skill_value.html\">Learn Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickDocFile,"<td><b>Found In Phrases</b></td>\n");
fprintf( brickDocFile,"</tr>\n");
// write infos
for( itBInf=BrickInfo.begin(); itBInf!=BrickInfo.end(); ++itBInf )
{
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
string skillTmp = (*itBInf).second.LearnSkills;
string skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
CVectorSString dicoResult;
Dico.lookup( skill, dicoResult, true );
if(dicoResult.empty()) continue;
// color
string color = brickToColor[brk];
// code
string code = strlwr(brk.c_str());
fprintf( brickDocFile, "<tr><td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),code.c_str());
// name
string name = (*itBInf).second.Text;
fprintf( brickDocFile, "<td>%s</td>\n",name.c_str());
// family
string family = brickToFamily[brk];
fprintf( brickDocFile, "<td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),family.c_str());
// required skill name
fprintf( brickDocFile, "<td>%s</td>\n",dicoResult[0].c_str());
// required skill value
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickDocFile, "<td>%s</td>\n",levelStr.c_str());
// learn skill name
string learnSkillTmp = brickToLearnSkill[brk];
skill = learnSkillTmp.substr(0,learnSkillTmp.find_first_of(" "));
fprintf( brickDocFile, "<td>%s</td>\n",skill.c_str());
// learn skill value
if( learnSkillTmp.find(";") != -1 )
{
sint idx = learnSkillTmp.find_first_of(" ");
levelStr = learnSkillTmp.substr(idx+1,learnSkillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = learnSkillTmp.find_first_of(" ");
levelStr = learnSkillTmp.substr(idx+1,learnSkillTmp.size()-idx);
}
fprintf( brickDocFile, "<td>%s</td>\n",levelStr.c_str());
// phrase list
fprintf( brickDocFile, "<td>");
map<string,map<string,string> >::iterator itPhrases = brickToPhrases.find(brk);
if( itPhrases != brickToPhrases.end() )
{
map<string,string>::iterator itPh;
uint i;
for( itPh=(*itPhrases).second.begin(),i=0; itPh!=(*itPhrases).second.end() && i<2; ++itPh,++i )
{
if( MultipleDocFiles )
fprintf( brickDocFile,"<A HREF=\"%s_%c.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
else
fprintf( brickDocFile,"<A HREF=\"%s.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first.c_str(),(*itPh).first.c_str());
}
if( i==2 )
{
char type = family[0];
fprintf( brickDocFile,"[<A HREF=\"%s_%c.html#%s\">...</A>]",DocFileNameRoot.c_str(),type,brk.c_str());
}
}
fprintf( brickDocFile, "</td></tr>\n");
}
fprintf( brickDocFile, "</tbody><table></P>\n" );
fprintf( brickDocFile, "</body></html>\n" );
fclose( brickDocFile );
// NAME
// write header and title bar
filename = DocFileNameRoot + "_name.html";
FILE * brickNameDocFile = nlfopen( filename, "wt" );
fprintf( brickNameDocFile,"<html><head>\n");
fprintf( brickNameDocFile,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickNameDocFile,"<title>Bricks infos</title>\n");
fprintf( brickNameDocFile,"</head><body>\n");
fprintf( brickNameDocFile,"<table cellpadding=\"1\" cellspacing=\"1\" border=\"0\"><tbody>\n");
fprintf( brickNameDocFile,"<tr>\n");
fprintf( brickNameDocFile,"<td><b><a href=\"%s.html\">Code</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickNameDocFile,"<td><b>*Name*</b></td>\n");
fprintf( brickNameDocFile,"<td><b><a href=\"%s_family.html\">Family</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickNameDocFile,"<td><b>Required Skill Name</b></td>\n");
fprintf( brickNameDocFile,"<td><b><a href=\"%s_required_skill_value.html\">Required Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickNameDocFile,"<td><b>Learn Skill Name</b></td>\n");
fprintf( brickNameDocFile,"<td><b><a href=\"%s_learn_skill_value.html\">Learn Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickNameDocFile,"<td><b>Found In Phrases</b></td>\n");
fprintf( brickNameDocFile,"</tr>\n");
map<string,string> nameToCode;
for( itBInf=BrickInfo.begin(); itBInf!=BrickInfo.end(); ++itBInf )
{
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
// code
string code = strlwr(brk.c_str());
// name
string name = (*itBInf).second.Text;
if( !name.empty())
nameToCode.insert( make_pair(name,brk) );
}
mss::iterator itNTC;
for( itNTC=nameToCode.begin(); itNTC!=nameToCode.end(); ++itNTC )
{
itBInf=BrickInfo.find((*itNTC).second);
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
string skillTmp = (*itBInf).second.LearnSkills;
string skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
CVectorSString dicoResult;
Dico.lookup( skill, dicoResult, true );
if(dicoResult.empty()) continue;
// color
string color = brickToColor[brk];
// code
string code = strlwr(brk.c_str());
fprintf( brickNameDocFile, "<tr><td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),code.c_str());
// name
string name = (*itBInf).second.Text;
fprintf( brickNameDocFile, "<td>%s</td>\n",name.c_str());
// family
string family = brickToFamily[brk];
fprintf( brickNameDocFile, "<td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),family.c_str());
// required skill name
fprintf( brickNameDocFile, "<td>%s</td>\n",dicoResult[0].c_str());
// required skill value
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickNameDocFile, "<td>%s</td>\n",levelStr.c_str());
// learn skill name
skillTmp = brickToLearnSkill[brk];
skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
fprintf( brickNameDocFile, "<td>%s</td>\n",skill.c_str());
// learn skill value
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickNameDocFile, "<td>%s</td>\n",levelStr.c_str());
// phrase list
fprintf( brickNameDocFile, "<td>");
map<string,map<string,string> >::iterator itPhrases = brickToPhrases.find(brk);
if( itPhrases != brickToPhrases.end() )
{
map<string,string>::iterator itPh;
uint i;
for( itPh=(*itPhrases).second.begin(),i=0; itPh!=(*itPhrases).second.end() && i<2; ++itPh,++i )
{
if( MultipleDocFiles )
fprintf( brickNameDocFile,"<A HREF=\"%s_%c.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
else
fprintf( brickNameDocFile,"<A HREF=\"%s.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first.c_str(),(*itPh).first.c_str());
}
if( i==2 )
{
char type = family[0];
fprintf( brickNameDocFile,"[<A HREF=\"%s_%c.html#%s\">...</A>]",DocFileNameRoot.c_str(),type,brk.c_str());
}
}
fprintf( brickNameDocFile, "</td></tr>\n");
}
fprintf( brickNameDocFile, "</tbody><table></P>\n" );
fprintf( brickNameDocFile, "</body></html>\n" );
fclose( brickNameDocFile );
// FAMILY
// write header and title bar
filename = DocFileNameRoot + "_family.html";
FILE * brickFamilyDocFile = nlfopen( filename, "wt" );
fprintf( brickFamilyDocFile,"<html><head>\n");
fprintf( brickFamilyDocFile,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickFamilyDocFile,"<title>Bricks infos</title>\n");
fprintf( brickFamilyDocFile,"</head><body>\n");
fprintf( brickFamilyDocFile,"<table cellpadding=\"1\" cellspacing=\"1\" border=\"0\"><tbody>\n");
fprintf( brickFamilyDocFile,"<tr>\n");
fprintf( brickFamilyDocFile,"<td><b><a href=\"%s.html\">Code</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickFamilyDocFile,"<td><b><a href=\"%s_name.html\">Name</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickFamilyDocFile,"<td><b>*Family*</b></td>\n");
fprintf( brickFamilyDocFile,"<td><b>Required Skill Name</b></td>\n");
fprintf( brickFamilyDocFile,"<td><b><a href=\"%s_required_skill_value.html\">Required Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickFamilyDocFile,"<td><b>Learn Skill Name</b></td>\n");
fprintf( brickFamilyDocFile,"<td><b><a href=\"%s_learn_skill_value.html\">Learn Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickFamilyDocFile,"<td><b>Found In Phrases</b></td>\n");
fprintf( brickFamilyDocFile,"</tr>\n");
// write infos
multimap<string,string> familyToCode;
for( itBInf=BrickInfo.begin(); itBInf!=BrickInfo.end(); ++itBInf )
{
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
// family
string family = brickToFamily[brk];
familyToCode.insert( make_pair(family,brk) );
}
multimap<string,string>::iterator itFTC;
for( itFTC=familyToCode.begin(); itFTC!=familyToCode.end(); ++itFTC )
{
itBInf=BrickInfo.find((*itFTC).second);
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
string skillTmp = (*itBInf).second.LearnSkills;
string skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
CVectorSString dicoResult;
Dico.lookup( skill, dicoResult, true );
if(dicoResult.empty()) continue;
// color
string color = brickToColor[brk];
// code
string code = strlwr(brk.c_str());
fprintf( brickFamilyDocFile, "<tr><td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),code.c_str());
// name
string name = (*itBInf).second.Text;
fprintf( brickFamilyDocFile, "<td>%s</td>\n",name.c_str());
// family
string family = brickToFamily[brk];
fprintf( brickFamilyDocFile, "<td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),family.c_str());
// required skill name
fprintf( brickFamilyDocFile, "<td>%s</td>\n",dicoResult[0].c_str());
// required skill value
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickFamilyDocFile, "<td>%s</td>\n",levelStr.c_str());
// learn skill name
skillTmp = brickToLearnSkill[brk];
skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
fprintf( brickFamilyDocFile, "<td>%s</td>\n",skill.c_str());
// learn skill value
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickFamilyDocFile, "<td>%s</td>\n",levelStr.c_str());
// phrase list
fprintf( brickFamilyDocFile, "<td>");
map<string,map<string,string> >::iterator itPhrases = brickToPhrases.find(brk);
if( itPhrases != brickToPhrases.end() )
{
map<string,string>::iterator itPh;
uint i;
for( itPh=(*itPhrases).second.begin(),i=0; itPh!=(*itPhrases).second.end() && i<2; ++itPh,++i )
{
if( MultipleDocFiles )
fprintf( brickFamilyDocFile,"<A HREF=\"%s_%c.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
else
fprintf( brickFamilyDocFile,"<A HREF=\"%s.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first.c_str(),(*itPh).first.c_str());
}
if( i==2 )
{
char type = family[0];
fprintf( brickFamilyDocFile,"[<A HREF=\"%s_%c.html#%s\">...</A>]",DocFileNameRoot.c_str(),type,brk.c_str());
}
}
fprintf( brickFamilyDocFile, "</td></tr>\n");
}
fprintf( brickFamilyDocFile, "</tbody><table></P>\n" );
fprintf( brickFamilyDocFile, "</body></html>\n" );
fclose( brickFamilyDocFile );
// REQUIRED SKILL VALUE
// write header and title bar
filename = DocFileNameRoot + "_required_skill_value.html";
FILE * brickRequiredDocFile = nlfopen( filename, "wt" );
fprintf( brickRequiredDocFile,"<html><head>\n");
fprintf( brickRequiredDocFile,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickRequiredDocFile,"<title>Bricks infos</title>\n");
fprintf( brickRequiredDocFile,"</head><body>\n");
fprintf( brickRequiredDocFile,"<table cellpadding=\"1\" cellspacing=\"1\" border=\"0\"><tbody>\n");
fprintf( brickRequiredDocFile,"<tr>\n");
fprintf( brickRequiredDocFile,"<td><b><a href=\"%s.html\">Code</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickRequiredDocFile,"<td><b><a href=\"%s_name.html\">Name</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickRequiredDocFile,"<td><b><a href=\"%s_family.html\">Family</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickRequiredDocFile,"<td><b>Required Skill Name</b></td>\n");
fprintf( brickRequiredDocFile,"<td><b>*Required Skill Value*</b></td>\n");
fprintf( brickRequiredDocFile,"<td><b>Learn Skill Name</b></td>\n");
fprintf( brickRequiredDocFile,"<td><b><a href=\"%s_learn_skill_value.html\">Learn Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickRequiredDocFile,"<td><b>Found In Phrases</b></td>\n");
fprintf( brickRequiredDocFile,"</tr>\n");
// write infos
multimap<uint,string> requiredSkillValueToCode;
for( itBInf=BrickInfo.begin(); itBInf!=BrickInfo.end(); ++itBInf )
{
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
// required skill value
string skillTmp = (*itBInf).second.LearnSkills;
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
uint level = atoi(levelStr.c_str());
requiredSkillValueToCode.insert( make_pair(level,brk) );
}
multimap<uint,string>::iterator itRTC;
for( itRTC=requiredSkillValueToCode.begin(); itRTC!=requiredSkillValueToCode.end(); ++itRTC )
{
itBInf=BrickInfo.find((*itRTC).second);
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
string skillTmp = (*itBInf).second.LearnSkills;
string skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
CVectorSString dicoResult;
Dico.lookup( skill, dicoResult, true );
if(dicoResult.empty()) continue;
// color
string color = brickToColor[brk];
// code
string code = strlwr(brk.c_str());
fprintf( brickRequiredDocFile, "<tr><td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),code.c_str());
// name
string name = (*itBInf).second.Text;
fprintf( brickRequiredDocFile, "<td>%s</td>\n",name.c_str());
// family
string family = brickToFamily[brk];
fprintf( brickRequiredDocFile, "<td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),family.c_str());
// required skill name
fprintf( brickRequiredDocFile, "<td>%s</td>\n",dicoResult[0].c_str());
// required skill value
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickRequiredDocFile, "<td>%s</td>\n",levelStr.c_str());
// learn skill name
skillTmp = brickToLearnSkill[brk];
skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
fprintf( brickRequiredDocFile, "<td>%s</td>\n",skill.c_str());
// learn skill value
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickRequiredDocFile, "<td>%s</td>\n",levelStr.c_str());
// phrase list
fprintf( brickRequiredDocFile, "<td>");
map<string,map<string,string> >::iterator itPhrases = brickToPhrases.find(brk);
if( itPhrases != brickToPhrases.end() )
{
map<string,string>::iterator itPh;
uint i;
for( itPh=(*itPhrases).second.begin(),i=0; itPh!=(*itPhrases).second.end() && i<2; ++itPh,++i )
{
if( MultipleDocFiles )
fprintf( brickRequiredDocFile,"<A HREF=\"%s_%c.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
else
fprintf( brickRequiredDocFile,"<A HREF=\"%s.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first.c_str(),(*itPh).first.c_str());
}
if( i==2 )
{
char type = family[0];
fprintf( brickRequiredDocFile,"[<A HREF=\"%s_%c.html#%s\">...</A>]",DocFileNameRoot.c_str(),type,brk.c_str());
}
}
fprintf( brickRequiredDocFile, "</td></tr>\n");
}
fprintf( brickRequiredDocFile, "</tbody><table></P>\n" );
fprintf( brickRequiredDocFile, "</body></html>\n" );
fclose( brickRequiredDocFile );
// LEARN SKILL VALUE
// write header and title bar
filename = DocFileNameRoot + "_learn_skill_value.html";
FILE * brickLearnDocFile = nlfopen( filename, "wt" );
fprintf( brickLearnDocFile,"<html><head>\n");
fprintf( brickLearnDocFile,"<meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n");
fprintf( brickLearnDocFile,"<title>Bricks infos</title>\n");
fprintf( brickLearnDocFile,"</head><body>\n");
fprintf( brickLearnDocFile,"<table cellpadding=\"1\" cellspacing=\"1\" border=\"0\"><tbody>\n");
fprintf( brickLearnDocFile,"<tr>\n");
fprintf( brickLearnDocFile,"<td><b><a href=\"%s.html\">Code</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickLearnDocFile,"<td><b><a href=\"%s_name.html\">Name</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickLearnDocFile,"<td><b><a href=\"%s_family.html\">Family</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickLearnDocFile,"<td><b>Required Skill Name</b></td>\n");
fprintf( brickLearnDocFile,"<td><b><a href=\"%s_required_skill_value.html\">Required Skill Value</a></b></td>\n",DocFileNameRoot.c_str());
fprintf( brickLearnDocFile,"<td><b>Learn Skill Name</b></td>\n");
fprintf( brickLearnDocFile,"<td><b>*Learn Skill Value*</b></td>\n");
fprintf( brickLearnDocFile,"<td><b>Found In Phrases</b></td>\n");
fprintf( brickLearnDocFile,"</tr>\n");
// write infos
multimap<uint,string> learnSkillValueToCode;
for( itBInf=BrickInfo.begin(); itBInf!=BrickInfo.end(); ++itBInf )
{
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
// learn skill value
string skillTmp = brickToLearnSkill[brk];
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
uint level = atoi(levelStr.c_str());
learnSkillValueToCode.insert( make_pair(level,brk) );
}
multimap<uint,string>::iterator itLTC;
for( itLTC=learnSkillValueToCode.begin(); itLTC!=learnSkillValueToCode.end(); ++itLTC )
{
itBInf=BrickInfo.find((*itLTC).second);
string brk = (*itBInf).first;
if(!validateBrick(brk)) continue;
string skillTmp = (*itBInf).second.LearnSkills;
string skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
CVectorSString dicoResult;
Dico.lookup( skill, dicoResult, true );
if(dicoResult.empty()) continue;
// color
string color = brickToColor[brk];
// code
string code = strlwr(brk.c_str());
fprintf( brickLearnDocFile, "<tr><td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),code.c_str());
// name
string name = (*itBInf).second.Text;
fprintf( brickLearnDocFile, "<td>%s</td>\n",name.c_str());
// family
string family = brickToFamily[brk];
fprintf( brickLearnDocFile, "<td><FONT COLOR=\"%s\">%s</FONT></td>\n",color.c_str(),family.c_str());
// required skill name
fprintf( brickLearnDocFile, "<td>%s</td>\n",dicoResult[0].c_str());
// required skill value
string levelStr;
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickLearnDocFile, "<td>%s</td>\n",levelStr.c_str());
// learn skill name
skillTmp = brickToLearnSkill[brk];
skill = skillTmp.substr(0,skillTmp.find_first_of(" "));
fprintf( brickLearnDocFile, "<td>%s</td>\n",skill.c_str());
// learn skill value
if( skillTmp.find(";") != -1 )
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.find_first_of(";")-idx-1);
}
else
{
sint idx = skillTmp.find_first_of(" ");
levelStr = skillTmp.substr(idx+1,skillTmp.size()-idx);
}
fprintf( brickLearnDocFile, "<td>%s</td>\n",levelStr.c_str());
// phrase list
fprintf( brickLearnDocFile, "<td>");
map<string,map<string,string> >::iterator itPhrases = brickToPhrases.find(brk);
if( itPhrases != brickToPhrases.end() )
{
map<string,string>::iterator itPh;
uint i;
for( itPh=(*itPhrases).second.begin(),i=0; itPh!=(*itPhrases).second.end() && i<2; ++itPh,++i )
{
if( MultipleDocFiles )
fprintf( brickLearnDocFile,"<A HREF=\"%s_%c.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first[7],(*itPh).first.c_str(),(*itPh).first.c_str());
else
fprintf( brickLearnDocFile,"<A HREF=\"%s.html#%s\">%s</A>,&nbsp&nbsp",DocFileName.c_str(),(*itPh).first.c_str(),(*itPh).first.c_str());
}
if( i==2 )
{
char type = family[0];
fprintf( brickLearnDocFile,"[<A HREF=\"%s_%c.html#%s\">...</A>]",DocFileNameRoot.c_str(),type,brk.c_str());
}
}
fprintf( brickLearnDocFile, "</td></tr>\n");
}
fprintf( brickLearnDocFile, "</tbody><table></P>\n" );
fprintf( brickLearnDocFile, "</body></html>\n" );
fclose( brickLearnDocFile );
}
return 0;
} // main //