techtree_t::techtree_t(fs_t& fs,const std::string& name):
mgr_t(fs), xml_loadable_t(name),
path(fs.canocial(std::string("techs")+"/"+name)) {
{
const strings_t subdirs = fs.list_dirs(path+"/factions");
for(strings_t::const_iterator i=subdirs.begin(); i!=subdirs.end(); i++)
if(fs.exists(path+"/factions/"+*i+"/"+*i+".xml")) {
factions.push_back(*i);
faction_refs.push_back(ref_t(*this,FACTION,*i));
}
if(!factions.size())
data_error("techtree "<<name<<" contains no factions");
}{
const strings_t subdirs = fs.list_dirs(path+"/resources");
for(strings_t::const_iterator i=subdirs.begin(); i!=subdirs.end(); i++)
if(fs.exists(path+"/resources/"+*i+"/"+*i+".xml")) {
resources.push_back(*i);
resource_refs.push_back(ref_t(*this,RESOURCE,*i));
}
if(!resources.size())
data_error("techtree "<<name<<" contains no resources");
}
fs_file_t::ptr_t f(fs.get(path+"/"+name+".xml"));
istream_t::ptr_t in(f->reader());
load_xml(*in);
}
void load(fs_t& fs) {
// this is just some silly test code - find a random model
std::auto_ptr<techtrees_t> techtrees(new techtrees_t(fs));
const strings_t techtrees_ = techtrees->get_techtrees();
const std::string techtree_ = techtrees_[rand()%techtrees_.size()];
techtree.reset(new techtree_t(fs,techtree_));
const strings_t factions = techtree->get_factions();
const std::string faction_ = factions[rand()%factions.size()];
faction_t& faction = techtree->get_faction(faction_);
const strings_t units = fs.list_dirs(faction.path+"/units");
const std::string unit_ = units[rand()%units.size()];
const std::string unit = faction.path+"/units/"+unit_;
const std::string xml_name = unit+"/"+unit_+".xml";
const strings_t models = fs.list_files(unit+"/models");
std::string g3d;
for(strings_t::const_iterator i=models.begin(); i!=models.end(); i++)
if(i->find(".g3d") == (i->size()-4)) {
g3d = unit + "/models/" + *i;
break;
}
if(!g3d.size()) data_error("no G3D models in "<<unit<<"/models");
std::cout << "loading "<<g3d<<std::endl;
fs_file_t::ptr_t g3d_file(fs.get(g3d));
istream_t::ptr_t gstream(g3d_file->reader());
model = std::auto_ptr<model_g3d_t>(new model_g3d_t(*gstream));
// and load it
std::cout << "loading "<<xml_name<<std::endl;
fs_file_t::ptr_t xml_file(fs.get(xml_name));
istream_t::ptr_t xstream(xml_file->reader());
unit_type = std::auto_ptr<unit_type_t>(new unit_type_t(faction,unit_));
unit_type->load_xml(*xstream);
//new ui_xml_editor_t(*unit_type);
}
static void sendEstateOwnerMessage(
LLMessageSystem* msg,
const std::string& request,
const LLUUID& invoice,
const strings_t& strings)
{
llinfos << "Sending estate request '" << request << "'" << llendl;
msg->newMessage("EstateOwnerMessage");
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->addUUIDFast(_PREHASH_TransactionID, LLUUID::null); //not used
msg->nextBlock("MethodData");
msg->addString("Method", request);
msg->addUUID("Invoice", invoice);
if(strings.empty())
{
msg->nextBlock("ParamList");
msg->addString("Parameter", NULL);
}
else
{
strings_t::const_iterator it = strings.begin();
strings_t::const_iterator end = strings.end();
for(; it != end; ++it)
{
msg->nextBlock("ParamList");
msg->addString("Parameter", *it);
}
}
msg->sendReliable(gAgent.getRegion()->getHost());
}
static size_t _index_of(const strings_t& c,const std::string& s,const char* ctx) {
const size_t i = std::distance(c.begin(),std::find(c.begin(),c.end(),s));
if(i == c.size()) data_error("could not find "<<ctx<<" "<<s);
return i;
}
techtrees_t::techtrees_t(fs_t& fs): fs_handle_t(fs) {
const strings_t subdirs = fs.list_dirs("techs");
for(strings_t::const_iterator i=subdirs.begin(); i!=subdirs.end(); i++)
if(fs.exists(std::string("techs")+"/"+*i+"/"+*i+".xml"))
techtrees.push_back(*i);
}
int main(int argc,const char* argv[])
{
int result=0;
const char* program = argv[0];
const char* types[typeMax];
types[typeUnknown ] = "unknown";
types[typeDirectory] = "directory";
types[typeImage ] = "image";
types[typeXML ] = "xml";
types[typeDoc ] = "doc";
types[typeCode ] = "code";
types[typeFile ] = "file";
char const* keywords[kwMAX];
memset(keywords,0,sizeof(keywords));
keywords[kwHELP ] = "help";
keywords[kwVERSION ] = "version";
keywords[kwVERBOSE ] = "verbose";
keywords[kwDRYRUN ] = "dryrun";
keywords[kwDST ] = "dst";
keywords[kwADJUST ] = "adjust";
keywords[kwTZ ] = "tz";
keywords[kwDELTA ] = "delta";
map<std::string,string> shorts;
shorts["-?"] = "-help";
shorts["-h"] = "-help";
shorts["-v"] = "-verbose";
shorts["-V"] = "-version";
shorts["-d"] = "-dst";
shorts["-a"] = "-adjust";
shorts["-t"] = "-tz";
shorts["-D"] = "-delta";
shorts["-s"] = "-delta";
shorts["-X"] = "-dryrun";
Options options ;
options.help = sina(keywords[kwHELP ],argv) || argc < 2;
options.verbose = sina(keywords[kwVERBOSE],argv);
options.dryrun = sina(keywords[kwDRYRUN ],argv);
options.version = sina(keywords[kwVERSION],argv);
options.dst = sina(keywords[kwDST ],argv);
options.dryrun = sina(keywords[kwDRYRUN ],argv);
for ( int i = 1 ; !result && i < argc ; i++ ) {
const char* arg = argv[i++];
if ( shorts.count(arg) ) arg = shorts[arg].c_str();
const char* value = argv[i ];
int ivalue = ::atoi(value?value:"0");
int key = ::find(arg,keywords,kwMAX);
int needv = key < kwMAX && key > (-kwNOVALUE);
if (!needv ) i--;
if ( needv && !value) key = kwNEEDVALUE;
switch ( key ) {
case kwDST : options.dst = true ; break;
case kwHELP : options.help = true ; break;
case kwVERSION : options.version = true ; break;
case kwDRYRUN : options.dryrun = true ; break;
case kwVERBOSE : options.verbose = true ; break;
case kwTZ : Position::tz_ = parseTZ(value);break;
case kwADJUST : Position::adjust_ = ivalue;break;
case kwDELTA : Position::deltaMax_= ivalue;break;
case kwNEEDVALUE: fprintf(stderr,"error: %s requires a value\n",arg); result = resultSyntaxError ; break ;
case kwSYNTAX : default:
{
int type = getFileType(arg,options) ;
if ( options.verbose ) printf("%s %s ",arg,types[type]) ;
if ( type == typeImage ) {
time_t t = readImageTime(std::string(arg)) ;
char* path = realpath(arg,NULL);
if ( t && path ) {
if ( options.verbose) printf("%s %ld %s",path,(long int)t,asctime(localtime(&t)));
gFiles.push_back(path);
}
if ( path ) :: free((void*) path);
}
if ( type == typeUnknown ) {
fprintf(stderr,"error: illegal syntax %s\n",arg);
result = resultSyntaxError ;
}
if ( options.verbose ) printf("\n") ;
}break;
}
}
if ( options.help ) ::help(program,keywords,kwMAX,options.verbose);
if ( options.version ) ::version(program);
if ( !result ) {
sort(gFiles.begin(),gFiles.end(),mySort);
if ( options.dst ) Position::dst_ = 3600;
if ( options.verbose ) {
int t = Position::tz();
int d = Position::dst();
int a = Position::adjust();
int A = Position::Adjust();
int s = A ;
int h = s/3600;
s-= h*3600;
s = abs(s);
int m = s/60 ;
s-= m*60 ;
printf("tz,dsl,adjust = %d,%d,%d total = %dsecs (= %d:%d:%d)\n",t,d,a,A,h,m,s);
}
for ( size_t p = 0 ; !options.dryrun && p < gFiles.size() ; p++ ) {
std::string arg = gFiles[p] ;
std::string stamp ;
try {
time_t t = readImageTime(arg,&stamp) ;
Position* pPos = searchTimeDict(gTimeDict,t,Position::deltaMax_);
Exiv2::Image::AutoPtr image = Exiv2::ImageFactory::open(gFiles[p]);
if ( image.get() ) {
image->readMetadata();
Exiv2::ExifData& exifData = image->exifData();
#if 0
/*
char* keys[]={ "Exif.Image.GPSTag"
, "Exif.GPSInfo.GPSProcessingMethod"
, "Exif.GPSInfo.GPSAltitudeRef"
, "Exif.GPSInfo.GPSVersionID"
, "Exif.GPSInfo.GPSProcessingMethod"
, "Exif.GPSInfo.GPSVersionID"
, "Exif.GPSInfo.GPSMapDatum"
, "Exif.GPSInfo.GPSLatitude"
, "Exif.GPSInfo.GPSLongitude"
, "Exif.GPSInfo.GPSAltitude"
, "Exif.GPSInfo.GPSAltitudeRef"
, "Exif.GPSInfo.GPSLatitudeRef"
, "Exif.GPSInfo.GPSLongitudeRef"
, "Exif.GPSInfo.GPSDateStamp"
, "Exif.GPSInfo.GPSTimeStamp"
};
static int bPrint = true ;
for ( int k = 0 ; k < 15 ; k++ ) {
try {
if ( bPrint ) printf("erasing %s\n",keys[k]);
Exiv2::ExifKey key = Exiv2::ExifKey(keys[k]);
Exiv2::ExifData::iterator kk = exifData.findKey(key);
if ( kk != exifData.end() ) exifData.erase(kk);
} catch (...) {};
}
bPrint = false;
*/
#endif
#if 0
Exiv2::ExifData::const_iterator end = exifData.end();
for (Exiv2::ExifData::iterator i = exifData.begin(); i != end; ++i) {
char name[100];
strcpy(name,i->key().c_str());
// std::cout << "sniff " << i->key() << std::endl;
if ( strstr(name,"GPS") ) {
Exiv2::ExifData::iterator pos;
Exiv2::ExifKey exifKey = Exiv2::ExifKey(name);
pos = exifData.findKey(exifKey);
while( pos != exifData.end()) {
exifData.erase(pos);
}
}
}
#endif
if ( pPos ) {
/*
struct _stat buf;
int result;
char timebuf[26];
char* filename = "crt_stat.c";
errno_t err;
// Get data associated with "crt_stat.c":
result = _stat( filename, &buf );
int _utime(
const char *filename,
struct _utimbuf *times
);
*/
exifData["Exif.GPSInfo.GPSProcessingMethod" ] = "65 83 67 73 73 0 0 0 72 89 66 82 73 68 45 70 73 88"; // ASCII HYBRID-FIX
exifData["Exif.GPSInfo.GPSVersionID" ] = "2 2 0 0";
exifData["Exif.GPSInfo.GPSMapDatum" ] = "WGS-84";
exifData["Exif.GPSInfo.GPSLatitude" ] = Position::toExifString(pPos->lat(),true,true);
exifData["Exif.GPSInfo.GPSLongitude" ] = Position::toExifString(pPos->lon(),true,false);
exifData["Exif.GPSInfo.GPSAltitude" ] = Position::toExifString(pPos->ele());
exifData["Exif.GPSInfo.GPSAltitudeRef" ] = pPos->ele()<0.0?"1":"0";
exifData["Exif.GPSInfo.GPSLatitudeRef" ] = pPos->lat()>0?"N":"S";
exifData["Exif.GPSInfo.GPSLongitudeRef" ] = pPos->lon()>0?"E":"W";
exifData["Exif.GPSInfo.GPSDateStamp" ] = stamp;
exifData["Exif.GPSInfo.GPSTimeStamp" ] = Position::toExifTimeStamp(stamp);
exifData["Exif.Image.GPSTag" ] = 4908;
printf("%s %s % 2d\n",arg.c_str(),pPos->toString().c_str(),pPos->delta());
} else {
printf("%s *** not in time dict ***\n",arg.c_str());
}
image->writeMetadata();
}
} catch ( ... ) {};
}
}
return result ;
}
string_t
shift( strings_t & strs ) {
string_t first = strs.front();
strs.erase( strs.begin() );
return first;
} // shift
