Example #1
0
int xmain( int argc, char* argv[] )
{
    StoreCmdArgs( argc, argv );
    if (FindArg2( "uodata=" ) != NULL)
    {
        config.uo_datafile_root = FindArg2( "uodata=" );
        config.uo_datafile_root = normalized_dir_form( config.uo_datafile_root );
    }
    else
    {
        cout << "Reading pol.cfg." << endl;
        ConfigFile cf( "pol.cfg" );
        ConfigElem elem;

        cf.readraw( elem );
        config.uo_datafile_root = elem.remove_string( "UoDataFileRoot" );
        config.uo_datafile_root = normalized_dir_form( config.uo_datafile_root );
        
        unsigned short max_tile = elem.remove_ushort( "MaxTileID", 0x3FFF );

		if (max_tile != 0x3FFF && max_tile != 0x7FFF)
			config.max_tile_id = 0x3FFF;
		else
			config.max_tile_id = max_tile;
    }


    string main_cfg = "uoconvert.cfg";
	if (FileExists( main_cfg.c_str() ) )
	{
        string temp;
        ConfigElem elem;
        cout << "Reading uoconvert.cfg." << endl;
		ConfigFile cf_main( main_cfg.c_str() );
	    while( cf_main.read( elem ) )
	    {
		    if (elem.type_is( "MultiTypes" ))
		    {
			    temp = elem.remove_string( "Boats" );
			    ISTRINGSTREAM is_boats( temp );
			    string graphicnum;
			    while (is_boats >> graphicnum)
				    BoatTypes.insert(strtoul(graphicnum.c_str(),NULL,0));

			    temp = elem.remove_string( "Houses" );
			    ISTRINGSTREAM is_houses( temp );
			    while (is_houses >> graphicnum)
				    HouseTypes.insert(strtoul(graphicnum.c_str(),NULL,0));

			    temp = elem.remove_string( "Stairs" );
			    ISTRINGSTREAM is_stairs( temp );
			    while (is_stairs >> graphicnum)
				    StairTypes.insert(strtoul(graphicnum.c_str(),NULL,0));
		    }
            else if (elem.type_is( "LOSOptions" ))
Example #2
0
	int LongHexArg2( const char *tag, int deflt )
	{
	  const char *parm = FindArg2( tag );
	  if( parm )
		return strtoul( parm, NULL, 16 );
	  else
		return deflt;
	}
Example #3
0
int defragstatics( int argc, char **argv )
{
    const char* realm = FindArg2( "realm=", "britannia" );
    RealmDescriptor descriptor = RealmDescriptor::Load( realm );

    uo_mapid = descriptor.uomapid;
    uo_usedif = descriptor.uodif;
    uo_map_width = static_cast<unsigned short>(descriptor.width);
    uo_map_height = static_cast<unsigned short>(descriptor.height);

    open_uo_data_files();
    read_uo_data();

    string statidx = "staidx"+tostring(uo_mapid)+".mul";
    string statics = "statics"+tostring(uo_mapid)+".mul";
    RemoveFile( statidx );
    RemoveFile( statics );

    FILE* fidx = fopen( statidx.c_str(), "wb" );
    FILE* fmul = fopen( statics.c_str(), "wb" );

    int lastprogress = -1;
    for( u16 x = 0; x < descriptor.width; x += STATICBLOCK_CHUNK )
    {
        int progress = x*100L/descriptor.width;
        if (progress != lastprogress)
        {
             cout << "\rRewriting statics files: " << progress << "%";
             lastprogress=progress;
        }
        for( u16 y = 0; y < descriptor.height; y += STATICBLOCK_CHUNK )
        {
            vector<USTRUCT_STATIC> pstat;
            int num;
            vector<USTRUCT_STATIC> tilelist;
            readstaticblock( &pstat, &num, x, y );
            if (num>0)
            {
                long currwritepos = ftell(fmul);
                for( int i = 0; i < num; ++i )
                {
                    USTRUCT_STATIC& tile =pstat[i];
                    if (tile.graphic < 0x4000)
                    {
                        bool first = true;
                        for( unsigned j = 0; j < tilelist.size(); ++j )
                        {
                            USTRUCT_STATIC& stile = tilelist[j];
                            if ((tile.graphic==stile.graphic)
                                && (tile.x_offset==stile.x_offset)
                                && (tile.y_offset==stile.y_offset)
                                && (tile.z==stile.z)
                                && (tile.hue==stile.hue))
                            {
                                first = false;
                                break;
                            }
                        }
                        if (first)
                        {
                            USTRUCT_STATIC newtile;
                            newtile.graphic=tile.graphic;
                            newtile.x_offset=tile.x_offset;
                            newtile.y_offset=tile.y_offset;
                            newtile.z=tile.z;
                            newtile.hue=tile.hue;
                            tilelist.push_back(newtile);
                        }
                    }
                }
                USTRUCT_IDX idx;
                idx.offset=~0uL;
                idx.length=~0uL;
                idx.unknown=~0uL;
                if (tilelist.size()>0)
                {
                    idx.offset=currwritepos;
                    for( unsigned i = 0; i < tilelist.size(); ++i )
                    {
                        fwrite( &tilelist[i],sizeof(USTRUCT_STATIC),1, fmul);
                    }
                    currwritepos=ftell(fmul)-currwritepos;
                    idx.length=currwritepos;
                    idx.unknown=0;
                    tilelist.clear();
                }
                fwrite( &idx, sizeof idx, 1, fidx );
            }
            else
            {
                USTRUCT_IDX idx;
                idx.offset = ~0uL;
                idx.length = ~0uL;
                idx.unknown = ~0uL;
                fwrite( &idx, sizeof idx, 1, fidx );
            }
        }
    }

    cout << "\rRewriting statics files: Complete" << endl;
    return 0;
}