Beispiel #1
0
static int findlandtileflags(int /*argc*/, char** argv)
{
  unsigned int flags = strtoul(argv[1], NULL, 0);
  Core::open_uo_data_files();
  Core::read_uo_data();

  for (u16 y = 0; y < 4095; ++y)
  {
    for (u16 x = 0; x < 6143; ++x)
    {
      short z;
      Core::USTRUCT_MAPINFO mi;
      safe_getmapinfo(x, y, &z, &mi);
      if (Core::landtile_uoflags(mi.landtile) & flags)
      {
        INFO_PRINT << x << "," << y << "," << (int) mi.z
                   << ": landtile 0x" << fmt::hexu(mi.landtile)
                   << ", flags 0x"
                   << fmt::hexu(Core::landtile_uoflags(mi.landtile))
                   << "\n";
      }
    }
  }

  Core::clear_tiledata();
  return 0;
}
Beispiel #2
0
int findlandtile( int argc, char **argv )
{
    int landtile = strtoul( argv[1], NULL, 0 );
    open_uo_data_files();
    read_uo_data();

    for( u16 y = 0; y < 4095; ++y )
    {
        for( u16 x = 0; x < 6143; ++x )
        {
            short z;
            USTRUCT_MAPINFO mi;
            safe_getmapinfo( x, y, &z, &mi );
            if (mi.landtile == landtile)
            {
                cout << x << "," << y << "," << (int) mi.z;
                if (mi.z != z)
                    cout << " (" << z << ")";
                cout << endl;
            }
        }
    }

	clear_tiledata();
    return 0;
}
Beispiel #3
0
static int findlandtile(int /*argc*/, char** argv)
{
  int landtile = strtoul(argv[1], NULL, 0);
  Core::open_uo_data_files();
  Core::read_uo_data();

  for (u16 y = 0; y < 4095; ++y)
  {
    for (u16 x = 0; x < 6143; ++x)
    {
      short z;
      Core::USTRUCT_MAPINFO mi;
      safe_getmapinfo(x, y, &z, &mi);
      if (mi.landtile == landtile)
      {
        INFO_PRINT << x << "," << y << "," << (int) mi.z;
        if (mi.z != z)
          INFO_PRINT << " (" << z << ")";
        INFO_PRINT << "\n";
      }
    }
  }

  Core::clear_tiledata();
  return 0;
}
Beispiel #4
0
int findlandtileflags( int argc, char **argv )
{
    unsigned long flags = strtoul( argv[1], NULL, 0 );
    open_uo_data_files();
    read_uo_data();

    for( u16 y = 0; y < 4095; ++y )
    {
        for( u16 x = 0; x < 6143; ++x )
        {
            short z;
            USTRUCT_MAPINFO mi;
            safe_getmapinfo( x, y, &z, &mi );
            if (landtile_uoflags( mi.landtile ) & flags)
            {
                cout << x << "," << y << "," << (int) mi.z;
                cout << ": landtile " << hexint(mi.landtile)
                     << ", flags " << hexint( landtile_uoflags( mi.landtile ) );
                cout << endl;
            }
        }
    }

	clear_tiledata();
    return 0;
}
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";
}
Beispiel #6
0
static int mapdump(int argc, char* argv[])
{
  u16 wxl = 5485, wxh = 5500, wyl = 0, wyh = 30;

  if (argc >= 4)
  {
    wxl = wxh = static_cast<u16>(atoi(argv[2]));
    wyl = wyh = static_cast<u16>(atoi(argv[3]));
  }
  if (argc >= 6)
  {
    wxh = static_cast<u16>(atoi(argv[4]));
    wyh = static_cast<u16>(atoi(argv[5]));
  }

  Core::open_uo_data_files();
  Core::read_uo_data();

  std::ofstream ofs("mapdump.html");

  ofs << "<table border=1 cellpadding=5 cellspacing=0>" << std::endl;
  ofs << "<tr><td>&nbsp;</td>";
  for (u16 x = wxl; x <= wxh; ++x)
  {
    ofs << "<td align=center>" << x << "</td>";
  }
  ofs << "</tr>" << std::endl;
  for (u16 y = wyl; y <= wyh; ++y)
  {
    ofs << "<tr><td valign=center>" << y << "</td>" << std::endl;
    for (u16 x = wxl; x <= wxh; ++x)
    {
      ofs << "<td align=left valign=top>";
      short z;
      Core::USTRUCT_MAPINFO mi;
      safe_getmapinfo(x, y, &z, &mi);
      Core::USTRUCT_LAND_TILE landtile;
      readlandtile(mi.landtile, &landtile);
      ofs << "z=" << z << "<br>";
      ofs << "landtile=" << Clib::hexint(mi.landtile) << " "
          << landtile.name << "<br>";
      ofs << "&nbsp;flags=" << Clib::hexint(landtile.flags) << "<br>";
      ofs << "mapz=" << (int) mi.z << "<br>";

      Core::StaticList statics;
      readallstatics(statics, x, y);
      if (!statics.empty())
      {
        ofs << "<table border=1 cellpadding=5 cellspacing=0>"
            << std::endl;
        ofs << "<tr><td>graphic</td><td>z</td><td>flags</td><td>ht</td>"
            << std::endl;
        for (const auto& rec : statics)
        {
          ofs << "<tr>";
          ofs << "<td>" << Clib::hexint(rec.graphic) << "</td>";
          ofs << "<td>" << int(rec.z) << "</td>";
          ofs << "<td>" << Clib::hexint(rec.flags) << "</td>";
          ofs << "<td>" << int(rec.height) << "</td>";
          ofs << "</tr>" << std::endl;
        }
        ofs << "</table>" << std::endl;
      }
      ofs << "</td>" << std::endl;
    }
    ofs << "</tr>" << std::endl;
  }
  ofs << "</table>" << std::endl;
  Core::clear_tiledata();
  return 0;
}
	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 );
	}
	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;
	}