Beispiel #1
0
int test_new_statics()
{
    cout << "Reading UO data.." << endl;
    open_uo_data_files();
    read_uo_data();
    load_pol_static_files();

    for( unsigned x = 0; x < 6144; ++x )
    {
        for( unsigned y = 0; y < 4096; ++y )
        {
            StaticList list1, list2;
            readstatics( list1, x, y );
            readstatics2( list2, x, y );

			for( unsigned i = 0; i < list1.size(); ++i )
            {
                StaticRec& r1 = list1[i];
                // see if this is represented
                // really should check that there aren't any extras, too!
                bool found = false;
                for( unsigned j = 0; j < list2.size(); ++j )
                {
                    StaticRec& r2 = list2[j];
                    if (tileheight(r1.graphic) == tileheight(r2.graphic) &&
                        r1.z == r2.z)
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    cout << "elem not found: x=" << x << ", y=" << y << ",i=" << i
                         << ", r1.graphic=" << r1.graphic << ", r1.z=" << int(r1.z)
                         << endl;
                    cout << "list1:" << endl;
                    for( unsigned j = 0; j < list1.size(); ++j )
                    {
                        cout << "gid=" << list1[j].graphic 
                             << " z=" << int(list1[j].z) 
                             << " ht=" << int(tileheight(list1[j].graphic))
                             << endl;
                    }
                    cout << "list2:" << endl;
                    for( unsigned j = 0; j < list2.size(); ++j )
                    {
                        cout << "gid=" << list2[j].graphic 
                             << " z=" << int(list2[j].z) 
                             << " ht=" << int(tileheight(list2[j].graphic))
                             << endl;
                    }
                }
            }
        }
    }
	clear_tiledata();
    return 0;
}
Beispiel #2
0
bool has_water( u16 x, u16 y )
{
    StaticList vec;
    vec.clear();
    readstatics( vec, x, y );
    for( StaticList::iterator itr = vec.begin(), end = vec.end(); itr != end; ++itr )
    {
        const StaticRec& rec = *itr;
        if (is_water(rec.graphic))
            return true;
    }
    return false;
}
Beispiel #3
0
static int contour()
{
  Core::open_uo_data_files();
  Core::read_uo_data();

  auto mc = new MapContour;
  for (u16 y = 0; y < 4095; ++y)
  {
    for (u16 x = 0; x < 6143; ++x)
    {
      static Core::StaticList vec;

      vec.clear();

      readstatics(vec, x, y);

      bool result;
      short newz;
      standheight(Core::MOVEMODE_LAND, vec, x, y, 127, &result, &newz);
      if (result)
      {
        mc->z[x][y] = static_cast<signed char>(newz);
      }
      else
      {
        mc->z[x][y] = 127;
      }
    }
  }

  std::ofstream ofs("contour.dat",
                    std::ios::trunc | std::ios::out | std::ios::binary);
  ofs.write(reinterpret_cast<const char*>(mc), sizeof(MapContour));
  Core::clear_tiledata();
  delete mc;
  return 0;
}
Beispiel #4
0
int contour( int argc, char **argv )
{
    open_uo_data_files();
    read_uo_data();

    MapContour* mc = new MapContour;
    for( u16 y = 0; y < 4095; ++y )
    {
        for( u16 x = 0; x < 6143; ++x )
        {
            static StaticList vec;
    
            vec.clear();
    
            readstatics( vec, x, y );

            bool result;
            short newz;
            standheight(MOVEMODE_LAND, vec, x, y, 127, 
                        &result, &newz);
            if (result)
            {
                mc->z[x][y] = static_cast<signed char>(newz);
            }
            else
            {
                mc->z[x][y] = 127;
            }
        }
    }

    ofstream ofs( "contour.dat", ios::trunc|ios::out|ios::binary );
    ofs.write( reinterpret_cast<const char*>(mc), sizeof(MapContour) );
	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 );
	}