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;
}
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;
}
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;
}
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";
}
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> </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 << " 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;
}
