uoconvert/uoconvert.cpp

Go to the documentation of this file.

/*
History
=======
2005/01/13 Shinigami: added support for Samurai Empire Map Tokuno
processsolidblock - can handle maps without 16 tile bounds
create_tiles_cfg - will handle tile names with 20 chars too
2005/07/05 Shinigami: added uoconvert.cfg option *StaticsPerBlock (hard limit is set to 10000)
2005/07/16 Shinigami: added uoconvert.cfg flag ShowIllegalGraphicWarning
2006/04/09 Shinigami: added uoconvert.cfg flag ShowRoofAndPlatformWarning
2006/05/26 Shinigami: there was another part with ShowRoofAndPlatformWarning-check, commented out
2009/12/02 Turley:    added config.max_tile_id & termur support - Tomi

Notes
=======

*/


#include "../pol/uofile.h"
#include "../pol/objtype.h"
#include "../pol/polcfg.h"
#include "../pol/udatfile.h"
#include "../pol/polfile.h"
#include "../pol/uofilei.h"

#include "../plib/mapcell.h"
#include "../plib/mapblock.h"
#include "../plib/mapsolid.h"
#include "../plib/mapfunc.h"
#include "../plib/mapserver.h"
#include "../plib/mapshape.h"
#include "../plib/mapwriter.h"
#include "../plib/realmdescriptor.h"
#include "../plib/systemstate.h"

#include "../clib/stlutil.h"
#include "../clib/cfgelem.h"
#include "../clib/cfgfile.h"
#include "../clib/cmdargs.h"
#include "../clib/fileutil.h"
#include "../clib/logfacility.h"
#include "../clib/passert.h"
#include "../clib/timer.h"

#include <string>
#include <set>
#include <vector>
#include <stdexcept>
#include <limits>

#ifdef _MSC_VER
#pragma warning(disable:4996) // deprecation warning for fopen
#endif

namespace Pol {
  namespace Plib {
    std::string flagstr( unsigned char flags );
  }
  namespace Core{
    void safe_getmapinfo( unsigned short x, unsigned short y, short* z, USTRUCT_MAPINFO* mi );
  }
  namespace UOConvert {
    using namespace Core;
    using namespace Plib;

    bool cfg_use_no_shoot = 0;
    bool cfg_LOS_through_windows = 0;

    std::set<unsigned int> HouseTypes;
    std::set<unsigned int> BoatTypes;
    std::set<unsigned int> StairTypes;
    std::set<unsigned int> MountTypes;

    
    
    void generate_map();
    void create_map(const std::string& realm, unsigned short width, unsigned short height);
    void update_map(const std::string& realm, unsigned short x, unsigned short y);
    
    void create_multis_cfg();
    void create_tiles_cfg();
    void create_landtiles_cfg();
    void create_maptile(const std::string& realmname);

    void display_flags()
    {
      for ( unsigned blocking = 0; blocking <= 1; ++blocking )
      {
        for ( unsigned platform = 0; platform <= 1; ++platform )
        {
          for ( unsigned walk = 0; walk <= 1; ++walk )
          {
            for ( unsigned wall = 0; wall <= 1; ++wall )
            {
              for ( unsigned half = 0; half <= 1; ++half )
              {
                for ( unsigned floor = 0; floor <= 1; ++floor )
                {
                  unsigned flags = 0;
                  if ( blocking ) flags |= Core::USTRUCT_TILE::FLAG_BLOCKING;
                  if ( platform ) flags |= Core::USTRUCT_TILE::FLAG_PLATFORM;
                  if ( walk ) flags |= Core::USTRUCT_TILE::FLAG__WALK;
                  if ( wall ) flags |= Core::USTRUCT_TILE::FLAG_WALL;
                  if ( half ) flags |= Core::USTRUCT_TILE::FLAG_HALF_HEIGHT;
                  if ( floor ) flags |= Core::USTRUCT_TILE::FLAG_FLOOR;

                  unsigned int polflags = Plib::polflags_from_tileflags( 0x4000, flags, cfg_use_no_shoot, cfg_LOS_through_windows );
                  unsigned moveland = ( polflags & Plib::FLAG::MOVELAND ) ? 1 : 0;
                  INFO_PRINT.Format( "{} {} {} {} {} {}: {}\n" ) << blocking << platform << walk << wall << half << floor << moveland;
                }
              }
            }
          }
        }
      }
    }

    


    unsigned char polmap_flags_from_landtile( unsigned short landtile )
    {

      unsigned int uoflags = landtile_uoflags( landtile );

      unsigned int polflags = Plib::polflags_from_tileflags( landtile, uoflags, cfg_use_no_shoot, cfg_LOS_through_windows );
      return static_cast<unsigned char>( polflags );
    }


    void create_maptile(const std::string& realmname)
    {
      Plib::RealmDescriptor descriptor = Plib::RealmDescriptor::Load( realmname );
      uo_map_height = static_cast<unsigned short>( descriptor.height );
      uo_map_width = static_cast<unsigned short>( descriptor.width );

      INFO_PRINT << "Creating maptile file.\n"
        << "  Realm: " << realmname << "\n"
        << "  Map ID: " << descriptor.uomapid << "\n"
        << "  Use Dif files: " << ( descriptor.uodif ? "Yes" : "No" ) << "\n"
        << "  Size: " << uo_map_width << "x" << uo_map_height << "\n";

      auto writer = new Plib::MapWriter();
      writer->OpenExistingFiles( realmname );

      for ( unsigned short y_base = 0; y_base < uo_map_height; y_base += Plib::MAPTILE_CHUNK )
      {
        for ( unsigned short x_base = 0; x_base < uo_map_width; x_base += Plib::MAPTILE_CHUNK )
        {
          for ( unsigned short x_add = 0; x_add < Plib::MAPTILE_CHUNK; ++x_add )
          {
            for ( unsigned short y_add = 0; y_add < Plib::MAPTILE_CHUNK; ++y_add )
            {
              unsigned short x = x_base + x_add;
              unsigned short y = y_base + y_add;

              short z;
              Core::USTRUCT_MAPINFO mi;

              safe_getmapinfo( x, y, &z, &mi );

              if ( mi.landtile > 0x3FFF )
                INFO_PRINT.Format("Tile 0x{:X} at ({},{},{}) is an invalid ID!\n") << mi.landtile << x << y << z;

              // for water, don't average with surrounding tiles.
              if ( landtile_uoflags( mi.landtile ) & Core::USTRUCT_TILE::FLAG_LIQUID )
                z = mi.z;

              Plib::MAPTILE_CELL cell;
              cell.landtile = mi.landtile;
              cell.z = static_cast<signed char>( z );
              writer->SetMapTile( x, y, cell );

            }
          }
        }
        INFO_PRINT << "\rConverting: " << y_base * 100 / uo_map_height << "%";
      }
      writer->Flush();
      delete writer;
      INFO_PRINT << "\rConversion complete.\n";
    }

    class StaticsByZ
    {
    public:
      bool operator()( const StaticRec& a, const StaticRec& b )
      {
        return ( a.z < b.z ) ||
          ( ( a.z == b.z && a.height < b.height ) );
      }
    };

    bool flags_match( unsigned int f1, unsigned int f2, unsigned char bits_compare )
    {
      return ( f1 & bits_compare )
        ==
        ( f2 & bits_compare );
    }

    bool otherflags_match( unsigned char f1, unsigned char f2, unsigned char bits_exclude )
    {
      return ( f1 & ~bits_exclude )
        ==
        ( f2 & ~bits_exclude );
    }

    bool differby_exactly( unsigned char f1, unsigned char f2, unsigned char bits )
    {
      return ( ( f1 ^ f2 ) == bits );
    }

    void ProcessSolidBlock( unsigned short x_base, unsigned short y_base, MapWriter& mapwriter );

    unsigned empty = 0, nonempty = 0;
    unsigned total_statics = 0;
    unsigned with_more_solids = 0;

    void update_map(const std::string& realm, unsigned short x, unsigned short y)
    {
      auto mapwriter = new MapWriter();
      mapwriter->OpenExistingFiles( realm );
      rawmapfullread();
      rawstaticfullread();
      unsigned short x_base = x / SOLIDX_X_SIZE * SOLIDX_X_SIZE;
      unsigned short y_base = y / SOLIDX_Y_SIZE * SOLIDX_Y_SIZE;

      ProcessSolidBlock( x_base, y_base, *mapwriter );
      delete mapwriter;
      INFO_PRINT << "empty=" << empty << ", nonempty=" << nonempty << "\n"
        << "with more_solids: " << with_more_solids << "\n"
        << "total statics=" << total_statics << "\n";
    }

    void create_map(const std::string& realm, unsigned short width, unsigned short height)
    {
      auto mapwriter = new MapWriter();
      INFO_PRINT << "Creating map base and solids files.\n"
        << "  Realm: " << realm << "\n"
        << "  Map ID: " << uo_mapid << "\n"
        << "  Use Dif files: " << ( uo_usedif ? "Yes" : "No" ) << "\n"
        << "  Size: " << uo_map_width << "x" << uo_map_height << "\n"
        << "Initializing files: ";
      mapwriter->CreateNewFiles( realm, width, height );
      INFO_PRINT << "Done.\n";
      Tools::Timer<> timer;
      rawmapfullread();
      rawstaticfullread();
      INFO_PRINT << "  Reading mapfiles time: " << timer.ellapsed() << " ms.\n";
      for ( unsigned short y_base = 0; y_base < height; y_base += SOLIDX_Y_SIZE )
      {
        for ( unsigned short x_base = 0; x_base < width; x_base += SOLIDX_X_SIZE )
        {
          ProcessSolidBlock( x_base, y_base, *mapwriter );
        }
        INFO_PRINT << "\rConverting: " << y_base * 100 / height << "%";
      }
      timer.stop();

      mapwriter->WriteConfigFile();
      delete mapwriter;

      INFO_PRINT << "\rConversion complete.              \n"
        << "Conversion details:\n"
        << "  Total blocks: " << empty + nonempty << "\n"
        << "  Blocks with solids: " << nonempty << " (" << ( nonempty * 100 / ( empty + nonempty ) ) << "%)" << "\n"
        << "  Blocks without solids: " << empty << " (" << ( empty * 100 / ( empty + nonempty ) ) << "%)" << "\n"
        << "  Locations with solids: " << with_more_solids << "\n"
        << "  Total number of solids: " << total_statics << "\n"
        << "  Elapsed time: " << timer.ellapsed() << " ms.\n";
    }

    bool is_no_draw( USTRUCT_MAPINFO& mi )
    {
      return ( mi.landtile == 0x2 );
    }

    bool is_cave_exit( USTRUCT_MAPINFO& mi )
    {
      return ( mi.landtile == 0x7ec ||
               mi.landtile == 0x7ed ||
               mi.landtile == 0x7ee ||
               mi.landtile == 0x7ef ||
               mi.landtile == 0x7f0 ||
               mi.landtile == 0x7f1 ||
               mi.landtile == 0x834 ||
               mi.landtile == 0x835 ||
               mi.landtile == 0x836 ||
               mi.landtile == 0x837 ||
               mi.landtile == 0x838 ||
               mi.landtile == 0x839 ||
               mi.landtile == 0x1d3 ||
               mi.landtile == 0x1d4 ||
               mi.landtile == 0x1d5 ||
               mi.landtile == 0x1d6 ||
               mi.landtile == 0x1d7 ||
               mi.landtile == 0x1d8 ||
               mi.landtile == 0x1d9 ||
               mi.landtile == 0x1da
               );
    }

    bool is_cave_shadow( USTRUCT_MAPINFO& mi )
    {
      return ( mi.landtile == 0x1db || // shadows above caves
               mi.landtile == 0x1ae || // more shadows above caves
               mi.landtile == 0x1af ||
               mi.landtile == 0x1b0 ||
               mi.landtile == 0x1b1 ||
               mi.landtile == 0x1b2 ||
               mi.landtile == 0x1b3 ||
               mi.landtile == 0x1b4 ||
               mi.landtile == 0x1b5
               );
    }

    short get_lowestadjacentz( unsigned short x, unsigned short y, short z )
    {
      USTRUCT_MAPINFO mi;
      short z0;
      short lowest_z = z;
      bool cave_override = false;

      if ( ( x - 1 >= 0 ) && ( y - 1 >= 0 ) )
      {
        safe_getmapinfo( x - 1, y - 1, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( x - 1 >= 0 )
      {
        safe_getmapinfo( x - 1, y, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( ( x - 1 >= 0 ) && ( y + 1 < uo_map_height ) )
      {
        safe_getmapinfo( x - 1, y + 1, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( y - 1 >= 0 )
      {
        safe_getmapinfo( x, y - 1, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( ( y - 1 >= 0 ) && ( x + 1 < uo_map_width ) )
      {
        safe_getmapinfo( x + 1, y - 1, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( x + 1 < uo_map_width )
      {
        safe_getmapinfo( x + 1, y, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( ( x + 1 < uo_map_width ) && ( y + 1 < uo_map_height ) )
      {
        safe_getmapinfo( x + 1, y + 1, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( y + 1 < uo_map_height )
      {
        safe_getmapinfo( x, y + 1, &z0, &mi );

        if ( is_cave_shadow( mi ) || is_cave_exit( mi ) )
          z0 = z;

        if ( is_no_draw( mi ) )
          cave_override = true;

        if ( z0 < lowest_z )
        {
          lowest_z = z0;
        }
      }

      if ( cave_override )
        return z;
      else
        return lowest_z;
    }

    void ProcessSolidBlock( unsigned short x_base, unsigned short y_base, MapWriter& mapwriter )
    {
      unsigned int idx2_offset = 0;
      SOLIDX2_ELEM idx2_elem;
      memset( &idx2_elem, 0, sizeof idx2_elem );
      idx2_elem.baseindex = mapwriter.NextSolidIndex();

      unsigned short x_add_max = SOLIDX_X_SIZE, y_add_max = SOLIDX_Y_SIZE;
      if ( x_base + x_add_max > uo_map_width )
        x_add_max = uo_map_width - x_base;
      if ( y_base + y_add_max > uo_map_height )
        y_add_max = uo_map_height - y_base;

      for ( unsigned short x_add = 0; x_add < x_add_max; ++x_add )
      {
        for ( unsigned short y_add = 0; y_add < y_add_max; ++y_add )
        {
          unsigned short x = x_base + x_add;
          unsigned short y = y_base + y_add;

          StaticList statics;

          // read the map, and treat it like a static.
          short z;
          USTRUCT_MAPINFO mi;

          safe_getmapinfo( x, y, &z, &mi );

          if ( mi.landtile > 0x3FFF )
            INFO_PRINT.Format( "Tile 0x{:X} at ({},{},{}) is an invalid ID!\n" ) << mi.landtile << x << y << z;

          // for water, don't average with surrounding tiles.
          if ( landtile_uoflags( mi.landtile ) & USTRUCT_TILE::FLAG_LIQUID )
            z = mi.z;
          short low_z = get_lowestadjacentz( x, y, z );

          short lt_height = z - low_z;
          z = low_z;

          if ( mi.landtile > 0x3FFF )
            INFO_PRINT.Format( "Tile 0x{:X} at ({},{},{}) is an invalid ID!\n" ) << mi.landtile << x << y << z;

          unsigned int lt_flags = landtile_uoflags( mi.landtile );
          if ( ~lt_flags & USTRUCT_TILE::FLAG_BLOCKING )
          { // this seems to be the default.
            lt_flags |= USTRUCT_TILE::FLAG_PLATFORM;
          }
          lt_flags |= USTRUCT_TILE::FLAG_NO_SHOOT;    // added to make sure people using noshoot will have shapes
          // generated by this tile in future block LOS, shouldn't
          // affect people using old LOS method one way or another.
          lt_flags |= USTRUCT_TILE::FLAG_FLOOR;
          lt_flags |= USTRUCT_TILE::FLAG_HALF_HEIGHT; // the entire map is this way

          if ( lt_flags & USTRUCT_TILE::FLAG_WALL )
            lt_height = 20;

          readstatics( statics, x, y,
                       USTRUCT_TILE::FLAG_BLOCKING |
                       USTRUCT_TILE::FLAG_PLATFORM |
                       USTRUCT_TILE::FLAG_HALF_HEIGHT |
                       USTRUCT_TILE::FLAG_LIQUID |
                       USTRUCT_TILE::FLAG_HOVEROVER
                       //USTRUCT_TILE::FLAG__WALK
                       );

          for ( unsigned i = 0; i < statics.size(); ++i )
          {
            StaticRec srec = statics[i];

            unsigned int polflags = polflags_from_tileflags( srec.graphic, srec.flags, cfg_use_no_shoot, cfg_LOS_through_windows );

            if ( ( ~polflags & FLAG::MOVELAND ) &&
                 ( ~polflags & FLAG::MOVESEA ) &&
                 ( ~polflags & FLAG::BLOCKSIGHT ) &&
                 ( ~polflags & FLAG::BLOCKING ) &&
                 ( ~polflags & FLAG::OVERFLIGHT ) )
            {
              // remove it.  we'll re-sort later.
              statics.erase( statics.begin() + i );
              --i; // do-over
            }
            if ( ( ~srec.flags & USTRUCT_TILE::FLAG_BLOCKING ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_PLATFORM ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_HALF_HEIGHT ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_LIQUID ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_HOVEROVER ) )
                 /*(~srec.flags & USTRUCT_TILE::FLAG__WALK)*/
            {
              // remove it.  we'll re-sort later.
              statics.erase( statics.begin() + i );
              --i; // do-over
            }
          }

          bool addMap = true;

          for ( const auto &srec : statics )
          {
            // Look for water tiles.  If there are any, discard the map (which is usually at -15 anyway)
            if ( z + lt_height <= srec.z && ( ( srec.z - ( z + lt_height ) ) <= 10 ) && // only where the map is below or same Z as the static
                 srec.graphic >= 0x1796 && srec.graphic <= 0x17B2 ) // FIXME hardcoded
            {
              // arr, there be water here
              addMap = false;
            }

            // if there's a static on top of one of these "wall" landtiles, make it override.
            if ( ( lt_flags & USTRUCT_TILE::FLAG_WALL ) && // wall?
                 z <= srec.z &&
                 srec.z - z <= lt_height )
            {

              lt_height = srec.z - z;
            }
          }
          // shadows above caves
          if ( is_cave_shadow( mi ) && !statics.empty() )
          {
            addMap = false;
          }



          // If the map is a NODRAW tile, and there are statics, discard the map tile
          if ( mi.landtile == 2 && !statics.empty() )
            addMap = false;

          if ( addMap )
            statics.push_back( StaticRec( 0, static_cast<signed char>( z ), lt_flags, static_cast<char>( lt_height ) ) );

          sort( statics.begin(), statics.end(), StaticsByZ() );
          reverse( statics.begin(), statics.end() );

          std::vector<MapShape> shapes;

          // try to consolidate like shapes, and discard ones we don't care about.
          while ( !statics.empty() )
          {
            StaticRec srec = statics.back();
            statics.pop_back();

            unsigned int polflags = polflags_from_tileflags( srec.graphic, srec.flags, cfg_use_no_shoot, cfg_LOS_through_windows );
            if ( ( ~polflags & FLAG::MOVELAND ) &&
                 ( ~polflags & FLAG::MOVESEA ) &&
                 ( ~polflags & FLAG::BLOCKSIGHT ) &&
                 ( ~polflags & FLAG::BLOCKING ) &&
                 ( ~polflags & FLAG::OVERFLIGHT ) )
            {
              passert_always( 0 );
              continue;
            }
            if ( ( ~srec.flags & USTRUCT_TILE::FLAG_BLOCKING ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_PLATFORM ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_HALF_HEIGHT ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_LIQUID ) &&
                 ( ~srec.flags & USTRUCT_TILE::FLAG_HOVEROVER ) )
                 /*(~srec.flags & USTRUCT_TILE::FLAG__WALK)*/
            {
              passert_always( 0 );
              continue;
            }

            if ( shapes.empty() )
            {
              // this, whatever it is, is the map base.
              //TODO: look for water statics and use THOSE as the map.
              MapShape shape;
              shape.z = srec.z;      //these will be converted below to
              shape.height = 0;      //make the map "solid"
              shape.flags = static_cast<unsigned char>( polflags );
              // no matter what, the lowest level is gradual
              shape.flags |= FLAG::GRADUAL;
              shapes.push_back( shape );

              //for wall flag - map tile always height 0, at bottom. if map tile has height, add it as a static
              if ( srec.height != 0 )
              {
                MapShape _shape;
                _shape.z = srec.z;
                _shape.height = srec.height;
                _shape.flags = polflags;
                shapes.push_back( _shape );

              }
              continue;
            }

            MapShape& prev = shapes.back();
            // we're adding it.
            MapShape shape;
            shape.z = srec.z;
            shape.height = srec.height;
            shape.flags = polflags;

            //always add the map shape seperately
            if ( shapes.size() == 1 )
            {
              shapes.push_back( shape );
              continue;
            }

            if ( shape.z < prev.z + prev.height )
            {
              // things can't exist in the same place.
              // shrink the bottom part of this shape.
              // if that would give it negative height, then skip it.
              short height_remove = prev.z + prev.height - shape.z;
              if ( height_remove <= shape.height )
              {
                shape.z += height_remove;
                shape.height -= height_remove;
              }
              else
              { // example: 5530, 14
                continue;
              }
            }

            // sometimes water has "sand" a couple z-coords above it.
            // We'll try to detect this (really, anything that is up to 4 dist from water)
            // and extend the thing above downward.
            if ( ( prev.flags & FLAG::MOVESEA ) &&
                 ( shape.z > prev.z + prev.height ) &&
                 ( shape.z <= prev.z + prev.height + 4 ) )
            {
              short height_add = shape.z - prev.z - prev.height;
              shape.z -= height_add;
              shape.height += height_add;
            }
            if ( ( prev.flags & FLAG::MOVESEA ) &&
                 ( prev.z + prev.height == -5 ) &&
                 ( shape.flags & FLAG::MOVESEA ) &&
                 ( shape.z == 25 ) )
            {
              // oddly, there are some water tiles at z=25 in some places...I don't get it
              continue;
            }

            //string prevflags_s = flagstr(prev.flags);
            //const char* prevflags = prevflags_s.c_str();
            //string shapeflags_s = flagstr(shape.flags);
            //const char* shapeflags = shapeflags_s.c_str();

            if ( shape.z > prev.z + prev.height )
            {
              //
              // elevated above what's below, must include separately
              //

              shapes.push_back( shape );
              continue;
            }

            passert_always( shape.z == prev.z + prev.height );

            if ( shape.z == prev.z + prev.height )
            {
              //
              // sitting right on top of the previous solid
              //

              // standable atop non-standable: standable
              // nonstandable atop standable: nonstandable
              // etc
              bool can_combine = flags_match( prev.flags, shape.flags, FLAG::BLOCKSIGHT | FLAG::BLOCKING );
              if ( prev.flags & FLAG::MOVELAND &&
                   ~shape.flags & FLAG::BLOCKING &&
                   ~shape.flags & FLAG::MOVELAND )
              {
                can_combine = false;
              }

              if ( can_combine )
              {
                prev.flags = shape.flags;
                prev.height += shape.height;
              }
              else // if one blocks LOS, but not the other, they can't be combined this way.
              {
                shapes.push_back( shape );
                continue;
              }
            }
          }

          // the first StaticShape is the map base.
          MapShape base = shapes[0];
          shapes.erase( shapes.begin() );
          MAPCELL cell;
          passert_always( base.height == 0 );
          cell.z = static_cast<signed char>( base.z ); //assume now map has height=1. a static was already added if it was >0
          cell.flags = static_cast<u8>( base.flags );
          if ( !shapes.empty() )
            cell.flags |= FLAG::MORE_SOLIDS;

          mapwriter.SetMapCell( x, y, cell );

          if ( !shapes.empty() )
          {
            ++with_more_solids;
            total_statics += static_cast<unsigned int>( shapes.size() );
            if ( idx2_offset == 0 )
              idx2_offset = mapwriter.NextSolidx2Offset();

            unsigned int addindex = mapwriter.NextSolidIndex() - idx2_elem.baseindex;
            if ( addindex > std::numeric_limits<unsigned short>::max() )
                throw std::runtime_error("addoffset overflow");
            idx2_elem.addindex[x_add][y_add] = static_cast<unsigned short>( addindex );
            int count = static_cast<int>( shapes.size() );
            for ( int j = 0; j < count; ++j )
            {
              MapShape shape = shapes[j];
              char _z, height, flags;
              _z = static_cast<char>( shapes[j].z );
              height = static_cast<char>( shape.height );
              flags = static_cast<u8>( shape.flags );
              if ( !height )//make 0 height solid
              {
                --_z;
                ++height;
              }

              if ( j != count - 1 )
                flags |= FLAG::MORE_SOLIDS;
              SOLIDS_ELEM solid;
              solid.z = _z;
              solid.height = height;
              solid.flags = flags;
              mapwriter.AppendSolid( solid );
            }
          }
        }
      }
      if ( idx2_offset )
      {
        ++nonempty;
        mapwriter.AppendSolidx2Elem( idx2_elem );
      }
      else
      {
        ++empty;
      }
      mapwriter.SetSolidx2Offset( x_base, y_base, idx2_offset );
    }

    void write_multi( FILE* multis_cfg, unsigned id, FILE* multi_mul, unsigned int offset, unsigned int length )
    {
      USTRUCT_MULTI_ELEMENT elem;
      unsigned int count;
      if ( cfg_use_new_hsa_format )
        count = length / sizeof( USTRUCT_MULTI_ELEMENT_HSA );
      else
        count = length / sizeof elem;

      std::string type, mytype;
      if ( BoatTypes.count( id ) )
        type = "Boat";
      else if ( HouseTypes.count( id ) )
        type = "House";
      else if ( StairTypes.count( id ) )
        type = "Stairs";
      else
      {
        ERROR_PRINT << "Type 0x" << fmt::hexu( id ) << " not found in uoconvert.cfg, assuming \"House\" type.\n";
        type = "House";
      }
      mytype = type;

      fprintf( multis_cfg, "%s 0x%x\n", type.c_str(), id );
      fprintf( multis_cfg, "{\n" );

      if (fseek(multi_mul, offset, SEEK_SET) != 0)
      {
          throw std::runtime_error("write_multi(): fseek() failed");
      }


      bool first = true;
      while ( count-- )
      {
          if (fread(&elem, sizeof elem, 1, multi_mul) != 1) {
              throw std::runtime_error("write_multi(): fread() failed");
          }

          if (cfg_use_new_hsa_format) {
              if (fseek(multi_mul, 4, SEEK_CUR) != 0)
                  throw std::runtime_error("write_multi(): fseek() failed");
          }

        if ( elem.graphic == GRAPHIC_NODRAW )
          continue;

        if ( elem.flags )
          type = "static";
        else
          type = "dynamic";

        // boats typically have as their first element the "mast", but flagged as dynamic.
        if ( mytype == "Boat" )
        {
          if ( first && elem.graphic != 1 )
            type = "static";
        }
        std::string comment;
        if ( cfg_use_new_hsa_format )
        {
          USTRUCT_TILE_HSA tile;
          readtile( elem.graphic, &tile );
          comment.assign( tile.name, sizeof( tile.name ) );
        }
        else
        {
          USTRUCT_TILE tile;
          readtile( elem.graphic, &tile );
          comment.assign( tile.name, sizeof( tile.name ) );
        }
        fprintf( multis_cfg, "    %-7s 0x%04x %4d %4d %4d   // %s\n", type.c_str(), elem.graphic, elem.x, elem.y, elem.z, comment.c_str() );
        first = false;
      }
      fprintf( multis_cfg, "}\n" );
      fprintf( multis_cfg, "\n" );
    }

    void create_multis_cfg( FILE* multi_idx, FILE* multi_mul, FILE* multis_cfg )
    {
      if ( fseek( multi_idx, 0, SEEK_SET ) != 0 )
          throw std::runtime_error("create_multis_cfg: fseek failed");
      unsigned count = 0;
      USTRUCT_IDX idxrec;
      for ( int i = 0; fread( &idxrec, sizeof idxrec, 1, multi_idx ) == 1; ++i )
      {
        const USTRUCT_VERSION* vrec = NULL;

        if ( check_verdata( VERFILE_MULTI_MUL, i, vrec ) )
        {
          write_multi( multis_cfg, i, verfile, vrec->filepos, vrec->length );
          ++count;
        }
        else
        {
          if ( idxrec.offset == 0xFFffFFffLu )
            continue;

          write_multi( multis_cfg, i, multi_mul, idxrec.offset, idxrec.length );
          ++count;
        }
      }
      INFO_PRINT << count << " multi definitions written to multis.cfg\n";
    }

    void create_multis_cfg()
    {
      FILE *multi_idx = open_uo_file( "multi.idx" );
      FILE *multi_mul = open_uo_file( "multi.mul" );

      FILE* multis_cfg = fopen( "multis.cfg", "wt" );

      create_multis_cfg( multi_idx, multi_mul, multis_cfg );

      fclose( multis_cfg );

      fclose( multi_idx );
      fclose( multi_mul );
    }
    void write_flags( FILE* fp, unsigned int flags )
    {
      if ( flags & FLAG::MOVELAND )    fprintf( fp, "    MoveLand 1\n" );
      if ( flags & FLAG::MOVESEA )     fprintf( fp, "    MoveSea 1\n" );
      if ( flags & FLAG::BLOCKSIGHT )  fprintf( fp, "    BlockSight 1\n" );
      if ( ~flags & FLAG::OVERFLIGHT ) fprintf( fp, "    OverFlight 0\n" );
      if ( flags & FLAG::ALLOWDROPON ) fprintf( fp, "    AllowDropOn 1\n" );
      if ( flags & FLAG::GRADUAL )     fprintf( fp, "    Gradual 1\n" );
      if ( flags & FLAG::STACKABLE )   fprintf( fp, "    Stackable 1\n" );
      if ( flags & FLAG::BLOCKING )    fprintf( fp, "    Blocking 1\n" );
      if ( flags & FLAG::MOVABLE )     fprintf( fp, "    Movable 1\n" );
      if ( flags & FLAG::EQUIPPABLE )  fprintf( fp, "    Equippable 1\n" );
      if ( flags & FLAG::DESC_PREPEND_A ) fprintf( fp, "    DescPrependA 1\n" );
      if ( flags & FLAG::DESC_PREPEND_AN ) fprintf( fp, "    DescPrependAn 1\n" );
    }

    void create_tiles_cfg()
    {
      FILE* fp = fopen( "tiles.cfg", "wt" );
      int mountCount;
      char name[21];

      unsigned count = 0;
      for ( unsigned int graphic_i = 0; graphic_i <= Plib::systemstate.config.max_tile_id; ++graphic_i )
      {
        u16 graphic = static_cast<u16>( graphic_i );
        USTRUCT_TILE tile;
        if ( cfg_use_new_hsa_format )
        {
          USTRUCT_TILE_HSA newtile;
          read_objinfo( graphic, newtile );
          tile.anim = newtile.anim;
          tile.flags = newtile.flags;
          tile.height = newtile.height;
          tile.layer = newtile.layer;
          memcpy( tile.name, newtile.name, sizeof tile.name );
          tile.unk14 = newtile.unk14;
          tile.unk15 = newtile.unk15;
          tile.unk6 = newtile.unk6;
          tile.unk7 = newtile.unk7;
          tile.unk8 = newtile.unk8;
          tile.unk9 = newtile.unk9;
          tile.weight = newtile.weight;
        }
        else
          read_objinfo( graphic, tile );
        mountCount = static_cast<int>( MountTypes.count( graphic ) );

        if ( tile.name[0] == '\0' &&
             tile.flags == 0 &&
             tile.layer == 0 &&
             tile.height == 0 &&
             mountCount == 0
             )
        {
          continue;
        }
        unsigned int flags = polflags_from_tileflags( graphic, tile.flags, cfg_use_no_shoot, cfg_LOS_through_windows );
        if ( mountCount != 0 )
        {
          tile.layer = 25;
          flags |= FLAG::EQUIPPABLE;
        }

        memset( name, 0, sizeof name );
        memcpy( name, tile.name, sizeof tile.name );

        fprintf( fp, "tile 0x%x\n", graphic );
        fprintf( fp, "{\n" );
        fprintf( fp, "    Desc %s\n", name );
        fprintf( fp, "    UoFlags 0x%08lx\n", static_cast<unsigned long>( tile.flags ) );
        if ( tile.layer )
          fprintf( fp, "    Layer %u\n", tile.layer );
        fprintf( fp, "    Height %u\n", tile.height );
        fprintf( fp, "    Weight %u\n", tile.weight );
        write_flags( fp, flags );
        fprintf( fp, "}\n" );
        fprintf( fp, "\n" );
        ++count;
      }
      fclose( fp );

      INFO_PRINT << count << " tile definitions written to tiles.cfg\n";
    }

    void create_landtiles_cfg()
    {
      FILE* fp = fopen( "landtiles.cfg", "wt" );
      unsigned count = 0;

      for ( u16 i = 0; i <= 0x3FFF; ++i )
      {
        USTRUCT_LAND_TILE landtile;
        if ( cfg_use_new_hsa_format )
        {
          USTRUCT_LAND_TILE_HSA newlandtile;
          readlandtile( i, &newlandtile );
          landtile.flags = newlandtile.flags;
          landtile.unk = newlandtile.unk;
          memcpy( landtile.name, newlandtile.name, sizeof landtile.name );
        }
        else
          readlandtile( i, &landtile );

        if ( landtile.name[0] || landtile.flags )
        {
          fprintf( fp, "landtile 0x%x\n", i );
          fprintf( fp, "{\n" );
          fprintf( fp, "    Name %s\n", landtile.name );
          fprintf( fp, "    UoFlags 0x%08lx\n", static_cast<unsigned long>( landtile.flags ) );

          unsigned int flags = polflags_from_landtileflags( i, landtile.flags );
          flags &= ~FLAG::MOVABLE; // movable makes no sense for landtiles
          write_flags( fp, flags );
          fprintf( fp, "}\n" );
          fprintf( fp, "\n" );
          ++count;
        }
      }
      fclose( fp );

      INFO_PRINT << count << " landtile definitions written to landtiles.cfg\n";
    }
  }

  int xmain( int argc, char* argv[] )
  {

    Clib::StoreCmdArgs( argc, argv );
    Plib::systemstate.config.max_tile_id = UOBJ_DEFAULT_MAX; //default

    if ( Clib::FindArg2( "uodata=" ) != NULL )
    {
      Plib::systemstate.config.uo_datafile_root = Clib::FindArg2( "uodata=" );
      Plib::systemstate.config.uo_datafile_root = Clib::normalized_dir_form( Plib::systemstate.config.uo_datafile_root );
    }
    else
    {
      INFO_PRINT << "Reading pol.cfg.\n";
      Clib::ConfigFile cf( "pol.cfg" );
      Clib::ConfigElem elem;

      cf.readraw( elem );
      Plib::systemstate.config.uo_datafile_root = elem.remove_string( "UoDataFileRoot" );
      Plib::systemstate.config.uo_datafile_root = Clib::normalized_dir_form( Plib::systemstate.config.uo_datafile_root );

      unsigned short max_tile = elem.remove_ushort( "MaxTileID", UOBJ_DEFAULT_MAX );

      if ( max_tile == UOBJ_DEFAULT_MAX || max_tile == UOBJ_SA_MAX || max_tile == UOBJ_HSA_MAX )
        Plib::systemstate.config.max_tile_id = max_tile;
    }

    if ( Clib::FindArg2( "maxtileid=" ) != NULL )
    {
      unsigned short max_tile = static_cast<unsigned short>( Clib::LongHexArg2( "maxtileid=", UOBJ_DEFAULT_MAX ) );
      if ( max_tile == UOBJ_DEFAULT_MAX || max_tile == UOBJ_SA_MAX || max_tile == UOBJ_HSA_MAX )
        Plib::systemstate.config.max_tile_id = max_tile;
    }


    std::string main_cfg = "uoconvert.cfg";
    if ( Clib::FileExists( main_cfg.c_str( ) ) )
    {
      std::string temp;
      Clib::ConfigElem elem;
      INFO_PRINT << "Reading uoconvert.cfg.\n";
      Clib::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 );
          std::string graphicnum;
          while ( is_boats >> graphicnum )
            UOConvert::BoatTypes.insert( strtoul( graphicnum.c_str( ), NULL, 0 ) );

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

          temp = elem.remove_string( "Stairs" );
          ISTRINGSTREAM is_stairs( temp );
          while ( is_stairs >> graphicnum )
            UOConvert::StairTypes.insert( strtoul( graphicnum.c_str( ), NULL, 0 ) );
        }
        else if ( elem.type_is( "LOSOptions" ) )
        {
          if ( elem.has_prop( "UseNoShoot" ) )
            UOConvert::cfg_use_no_shoot = elem.remove_bool( "UseNoShoot" );

          if ( elem.has_prop( "LOSThroughWindows" ) )
            UOConvert::cfg_LOS_through_windows = elem.remove_bool( "LOSThroughWindows" );
        }
        else if ( elem.type_is( "Mounts" ) )
        {
          std::string graphicnum;
          temp = elem.remove_string( "Tiles" );
          ISTRINGSTREAM is_mounts( temp );
          while ( is_mounts >> graphicnum )
          {
            UOConvert::MountTypes.insert( strtoul( graphicnum.c_str( ), NULL, 0 ) );
          }
        }
        else if ( elem.type_is( "StaticOptions" ) )
        {
          if ( elem.has_prop( "MaxStaticsPerBlock" ) )
          {
            UOConvert::cfg_max_statics_per_block = elem.remove_int( "MaxStaticsPerBlock" );

            if ( UOConvert::cfg_max_statics_per_block > MAX_STATICS_PER_BLOCK )
            {
              UOConvert::cfg_max_statics_per_block = MAX_STATICS_PER_BLOCK;
              INFO_PRINT << "max. Statics per Block limited to " << UOConvert::cfg_max_statics_per_block << " Items\n";
            }
            else if ( UOConvert::cfg_max_statics_per_block < 0 )
              UOConvert::cfg_max_statics_per_block = 1000;
          }

          if ( elem.has_prop( "WarningStaticsPerBlock" ) )
          {
            UOConvert::cfg_warning_statics_per_block = elem.remove_int( "WarningStaticsPerBlock" );

            if ( UOConvert::cfg_warning_statics_per_block > MAX_STATICS_PER_BLOCK )
            {
              UOConvert::cfg_warning_statics_per_block = MAX_STATICS_PER_BLOCK;
              INFO_PRINT << "max. Statics per Block for Warning limited to "
                << UOConvert::cfg_warning_statics_per_block << " Items\n";
            }
            else if ( UOConvert::cfg_warning_statics_per_block < 0 )
              UOConvert::cfg_warning_statics_per_block = 1000;
          }

          if ( elem.has_prop( "ShowIllegalGraphicWarning" ) )
            UOConvert::cfg_show_illegal_graphic_warning = elem.remove_bool( "ShowIllegalGraphicWarning" );
        }
        else if ( elem.type_is( "TileOptions" ) )
        {
          if ( elem.has_prop( "ShowRoofAndPlatformWarning" ) )
            Core::cfg_show_roof_and_platform_warning = elem.remove_bool( "ShowRoofAndPlatformWarning" );
        }
        else if ( elem.type_is( "ClientOptions" ) )
        {
          if ( elem.has_prop( "UseNewHSAFormat" ) )
            UOConvert::cfg_use_new_hsa_format = elem.remove_bool( "UseNewHSAFormat" );
        }
      }
    }

    std::string command = "map";
    if ( argc > 1 )
    {
      command = argv[1];
      ++argv;
      --argc;
    }

    if ( command == "map" )
    {
      UOConvert::uo_mapid = Clib::LongArg2( "mapid=", 0 );
      UOConvert::uo_usedif = Clib::LongArg2( "usedif=", 0 );

      const char* realm = Clib::FindArg2( "realm=", "britannia" );
      int default_width = 6144;
      int default_height = 4096;
      switch ( UOConvert::uo_mapid )
      {
        case 0:
        case 1:
          break;
        case 2: // ilshenar:
          default_width = 2304;
          default_height = 1600;
          break;
        case 3: // malas
          default_width = 2560;
          default_height = 2048;
          break;
        case 4: // tokuno
          default_width = 1448;
          default_height = 1448;
          break;
        case 5: // termur
          default_width = 1280;
          default_height = 4096;
          break;
      }
      int width = Clib::LongArg2( "width=", default_width );
      int height = Clib::LongArg2( "height=", default_height );
      UOConvert::uo_map_width = static_cast<unsigned short>( width );
      UOConvert::uo_map_height = static_cast<unsigned short>( height );

      UOConvert::open_uo_data_files( );
      UOConvert::read_uo_data( );

      int x = Clib::LongArg2( "x=", -1 );
      int y = Clib::LongArg2( "y=", -1 );

      // brittania: realm=main mapid=0 width=6144 height=4096
      // ilshenar: realm=ilshenar mapid=2 width=2304 height=1600
      // malas: realm=malas mapid=3 width=2560 height=2048
      // tokuno: realm=tokuno mapid=4 width=1448 height=1448
      // termur: realm=termur mapid=5 width=1280 height=4096

      if ( x >= 0 && y >= 0 )
      {
        UOConvert::update_map( realm, static_cast<u16>( x ), static_cast<u16>( y ) );
      }
      else
      {
        UOConvert::create_map( realm, static_cast<unsigned short>( width ), static_cast<unsigned short>( height ) );
      }
    }
    else if ( command == "statics" )
    {
      const char* realm = Clib::FindArg2( "realm=", "britannia" );
      Plib::RealmDescriptor descriptor = Plib::RealmDescriptor::Load( realm );

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

      UOConvert::open_uo_data_files( );
      UOConvert::read_uo_data( );

      Core::write_pol_static_files( realm );
    }
    else if ( command == "multis" )
    {
      UOConvert::open_uo_data_files( );
      UOConvert::read_uo_data( );
      UOConvert::create_multis_cfg( );
    }
    else if ( command == "tiles" )
    {
      UOConvert::open_uo_data_files( );
      UOConvert::read_uo_data( );
      UOConvert::create_tiles_cfg( );
    }
    else if ( command == "landtiles" )
    {
      UOConvert::open_uo_data_files( );
      UOConvert::read_uo_data( );
      UOConvert::create_landtiles_cfg( );
    }
    else if ( command == "maptile" )
    {
      const char* realm = Clib::FindArg2( "realm=", "britannia" );
      Plib::RealmDescriptor descriptor = Plib::RealmDescriptor::Load( realm );

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

      UOConvert::open_uo_data_files( );
      UOConvert::read_uo_data( );

      UOConvert::create_maptile( realm );
    }
    else if ( command == "flags" )
    {
      UOConvert::display_flags( );
    }
    else
    {
      ERROR_PRINT << "Usage: uoconvert [command] [options]\n"
        << "Commands: \n"
        << "  map {uodata=Dir} {maxtileid=0x3FFF/0x7FFF} {realm=realmname} {width=Width} {height=Height} {x=X} {y=Y}\n"
        << "  statics {uodata=Dir} {maxtileid=0x3FFF/0x7FFF} {realm=realmname}\n"
        << "  maptile {uodata=Dir} {maxtileid=0x3FFF/0x7FFF} {realm=realmname}\n"
        << "  multis {uodata=Dir} {maxtileid=0x3FFF/0x7FFF}\n"
        << "  tiles {uodata=Dir} {maxtileid=0x3FFF/0x7FFF}\n"
        << "  landtiles {uodata=Dir} {maxtileid=0x3FFF/0x7FFF}\n";
      return 1;
    }
    UOConvert::clear_tiledata( );
    return 0;
  }

}