public static void Freeze( Mobile from, Map targetMap, Point3D start3d, Point3D end3d )
{
Hashtable mapTable = new Hashtable();
if ( start3d == NullP3D && end3d == NullP3D )
{
if ( targetMap == null )
CommandLogging.WriteLine( from, "{0} {1} invoking freeze for every item in every map", from.AccessLevel, CommandLogging.Format( from ) );
else
CommandLogging.WriteLine( from, "{0} {1} invoking freeze for every item in {0}", from.AccessLevel, CommandLogging.Format( from ), targetMap );
foreach ( Item item in World.Items.Values )
{
if ( targetMap != null && item.Map != targetMap )
continue;
if ( item.Parent != null )
continue;
if ( item is Static || item is BaseFloor || item is BaseWall )
{
Map itemMap = item.Map;
if ( itemMap == null || itemMap == Map.Internal )
continue;
Hashtable table = (Hashtable)mapTable[itemMap];
if ( table == null )
mapTable[itemMap] = table = new Hashtable();
Point2D p = new Point2D( item.X >> 3, item.Y >> 3 );
DeltaState state = (DeltaState)table[p];
if ( state == null )
table[p] = state = new DeltaState( p );
state.m_List.Add( item );
}
}
}
else if ( targetMap != null )
{
Point2D start = targetMap.Bound( new Point2D( start3d ) ), end = targetMap.Bound( new Point2D( end3d ) );
CommandLogging.WriteLine( from, "{0} {1} invoking freeze from {2} to {3} in {4}", from.AccessLevel, CommandLogging.Format( from ), start, end, targetMap );
IPooledEnumerable eable = targetMap.GetItemsInBounds( new Rectangle2D( start.X, start.Y, end.X - start.X + 1, end.Y - start.Y + 1 ) );
foreach ( Item item in eable )
{
if ( item is Static || item is BaseFloor || item is BaseWall )
{
Map itemMap = item.Map;
if ( itemMap == null || itemMap == Map.Internal )
continue;
Hashtable table = (Hashtable)mapTable[itemMap];
if ( table == null )
mapTable[itemMap] = table = new Hashtable();
Point2D p = new Point2D( item.X >> 3, item.Y >> 3 );
DeltaState state = (DeltaState)table[p];
if ( state == null )
table[p] = state = new DeltaState( p );
state.m_List.Add( item );
}
}
eable.Free();
}
if ( mapTable.Count == 0 )
{
from.SendGump( new NoticeGump( 1060637, 30720, "No freezable items were found. Only the following item types are frozen:<br> - Static<br> - BaseFloor<br> - BaseWall", 0xFFC000, 320, 240, null, null ) );
return;
}
bool badDataFile = false;
int totalFrozen = 0;
foreach ( DictionaryEntry de in mapTable )
{
Map map = (Map)de.Key;
Hashtable table = (Hashtable)de.Value;
TileMatrix matrix = map.Tiles;
using ( FileStream idxStream = OpenWrite( matrix.IndexStream ) )
{
using ( FileStream mulStream = OpenWrite( matrix.DataStream ) )
{
if ( idxStream == null || mulStream == null )
{
badDataFile = true;
continue;
}
BinaryReader idxReader = new BinaryReader( idxStream );
BinaryWriter idxWriter = new BinaryWriter( idxStream );
BinaryWriter mulWriter = new BinaryWriter( mulStream );
foreach ( DeltaState state in table.Values )
{
int oldTileCount;
StaticTile[] oldTiles = ReadStaticBlock( idxReader, mulStream, state.m_X, state.m_Y, matrix.BlockWidth, matrix.BlockHeight, out oldTileCount );
if ( oldTileCount < 0 )
continue;
int newTileCount = 0;
StaticTile[] newTiles = new StaticTile[state.m_List.Count];
for ( int i = 0; i < state.m_List.Count; ++i )
{
Item item = (Item)state.m_List[i];
int xOffset = item.X - (state.m_X * 8);
int yOffset = item.Y - (state.m_Y * 8);
if ( xOffset < 0 || xOffset >= 8 || yOffset < 0 || yOffset >= 8 )
continue;
StaticTile newTile = new StaticTile();
newTile.m_ID = (short)(item.ItemID & 0x3FFF);
newTile.m_X = (byte)xOffset;
newTile.m_Y = (byte)yOffset;
newTile.m_Z = (sbyte)item.Z;
newTile.m_Hue = (short)item.Hue;
newTiles[newTileCount++] = newTile;
item.Delete();
++totalFrozen;
}
int mulPos = -1;
int length = -1;
int extra = 0;
if ( (oldTileCount + newTileCount) > 0 )
{
mulWriter.Seek( 0, SeekOrigin.End );
mulPos = (int)mulWriter.BaseStream.Position;
length = (oldTileCount + newTileCount) * 7;
extra = 1;
for ( int i = 0; i < oldTileCount; ++i )
{
StaticTile toWrite = oldTiles[i];
mulWriter.Write( (short) toWrite.m_ID );
mulWriter.Write( (byte) toWrite.m_X );
mulWriter.Write( (byte) toWrite.m_Y );
mulWriter.Write( (sbyte) toWrite.m_Z );
mulWriter.Write( (short) toWrite.m_Hue );
}
for ( int i = 0; i < newTileCount; ++i )
{
StaticTile toWrite = newTiles[i];
mulWriter.Write( (short) toWrite.m_ID );
mulWriter.Write( (byte) toWrite.m_X );
mulWriter.Write( (byte) toWrite.m_Y );
mulWriter.Write( (sbyte) toWrite.m_Z );
mulWriter.Write( (short) toWrite.m_Hue );
}
mulWriter.Flush();
}
int idxPos = ((state.m_X * matrix.BlockHeight) + state.m_Y) * 12;
idxWriter.Seek( idxPos, SeekOrigin.Begin );
idxWriter.Write( mulPos );
idxWriter.Write( length );
idxWriter.Write( extra );
idxWriter.Flush();
matrix.SetStaticBlock( state.m_X, state.m_Y, null );
}
}
}
}
if ( totalFrozen == 0 && badDataFile )
from.SendGump( new NoticeGump( 1060637, 30720, "Output data files could not be opened and the freeze operation has been aborted.<br><br>This probably means your server and client are using the same data files. Instructions on how to resolve this can be found in the first warning window.", 0xFFC000, 320, 240, null, null ) );
else
from.SendGump( new NoticeGump( 1060637, 30720, String.Format( "Freeze operation completed successfully.<br><br>{0} item{1} frozen.<br><br>You must restart your client and update it's data files to see the changes.", totalFrozen, totalFrozen != 1 ? "s were" : " was" ), 0xFFC000, 320, 240, null, null ) );
}
private static void DoUnfreeze( Map map, Point2D start, Point2D end, ref bool badDataFile, ref int totalUnfrozen )
{
start = map.Bound( start );
end = map.Bound( end );
int xStartBlock = start.X >> 3;
int yStartBlock = start.Y >> 3;
int xEndBlock = end.X >> 3;
int yEndBlock = end.Y >> 3;
int xTileStart = start.X, yTileStart = start.Y;
int xTileWidth = end.X - start.X + 1, yTileHeight = end.Y - start.Y + 1;
TileMatrix matrix = map.Tiles;
using ( FileStream idxStream = OpenWrite( matrix.IndexStream ) )
{
using ( FileStream mulStream = OpenWrite( matrix.DataStream ) )
{
if ( idxStream == null || mulStream == null )
{
badDataFile = true;
return;
}
BinaryReader idxReader = new BinaryReader( idxStream );
BinaryWriter idxWriter = new BinaryWriter( idxStream );
BinaryWriter mulWriter = new BinaryWriter( mulStream );
for ( int x = xStartBlock; x <= xEndBlock; ++x )
{
for ( int y = yStartBlock; y <= yEndBlock; ++y )
{
int oldTileCount;
StaticTile[] oldTiles = ReadStaticBlock( idxReader, mulStream, x, y, matrix.BlockWidth, matrix.BlockHeight, out oldTileCount );
if ( oldTileCount < 0 )
continue;
int newTileCount = 0;
StaticTile[] newTiles = new StaticTile[oldTileCount];
int baseX = (x << 3) - xTileStart, baseY = (y << 3) - yTileStart;
for ( int i = 0; i < oldTileCount; ++i )
{
StaticTile oldTile = oldTiles[i];
int px = baseX + oldTile.m_X;
int py = baseY + oldTile.m_Y;
if ( px < 0 || px >= xTileWidth || py < 0 || py >= yTileHeight )
{
newTiles[newTileCount++] = oldTile;
}
else
{
++totalUnfrozen;
Item item = new Static( oldTile.m_ID & 0x3FFF );
item.Hue = oldTile.m_Hue;
item.MoveToWorld( new Point3D( px + xTileStart, py + yTileStart, oldTile.m_Z ), map );
}
}
int mulPos = -1;
int length = -1;
int extra = 0;
if ( newTileCount > 0 )
{
mulWriter.Seek( 0, SeekOrigin.End );
mulPos = (int)mulWriter.BaseStream.Position;
length = newTileCount * 7;
extra = 1;
for ( int i = 0; i < newTileCount; ++i )
{
StaticTile toWrite = newTiles[i];
mulWriter.Write( (short) toWrite.m_ID );
mulWriter.Write( (byte) toWrite.m_X );
mulWriter.Write( (byte) toWrite.m_Y );
mulWriter.Write( (sbyte) toWrite.m_Z );
mulWriter.Write( (short) toWrite.m_Hue );
}
mulWriter.Flush();
}
int idxPos = ((x * matrix.BlockHeight) + y) * 12;
idxWriter.Seek( idxPos, SeekOrigin.Begin );
idxWriter.Write( mulPos );
idxWriter.Write( length );
idxWriter.Write( extra );
idxWriter.Flush();
matrix.SetStaticBlock( x, y, null );
}
}
}
}
}
public static void Freeze(Mobile from, Map targetMap, Point3D start3d, Point3D end3d)
{
Hashtable mapTable = new Hashtable();
if (start3d == NullP3D && end3d == NullP3D)
{
if (targetMap == null)
{
CommandLogging.WriteLine(from, "{0} {1} invoking freeze for every item in every map", from.AccessLevel, CommandLogging.Format(from));
}
else
{
CommandLogging.WriteLine(from, "{0} {1} invoking freeze for every item in {0}", from.AccessLevel, CommandLogging.Format(from), targetMap);
}
foreach (Item item in World.Items.Values)
{
if (targetMap != null && item.Map != targetMap)
{
continue;
}
if (item.Parent != null)
{
continue;
}
if (item is Static || item is BaseFloor || item is BaseWall)
{
Map itemMap = item.Map;
if (itemMap == null || itemMap == Map.Internal)
{
continue;
}
Hashtable table = (Hashtable)mapTable[itemMap];
if (table == null)
{
mapTable[itemMap] = table = new Hashtable();
}
Point2D p = new Point2D(item.X >> 3, item.Y >> 3);
DeltaState state = (DeltaState)table[p];
if (state == null)
{
table[p] = state = new DeltaState(p);
}
state.m_List.Add(item);
}
}
}
else if (targetMap != null)
{
Point2D start = targetMap.Bound(new Point2D(start3d)), end = targetMap.Bound(new Point2D(end3d));
CommandLogging.WriteLine(from, "{0} {1} invoking freeze from {2} to {3} in {4}", from.AccessLevel, CommandLogging.Format(from), start, end, targetMap);
IPooledEnumerable eable = targetMap.GetItemsInBounds(new Rectangle2D(start.X, start.Y, end.X - start.X + 1, end.Y - start.Y + 1));
foreach (Item item in eable)
{
if (item is Static || item is BaseFloor || item is BaseWall)
{
Map itemMap = item.Map;
if (itemMap == null || itemMap == Map.Internal)
{
continue;
}
Hashtable table = (Hashtable)mapTable[itemMap];
if (table == null)
{
mapTable[itemMap] = table = new Hashtable();
}
Point2D p = new Point2D(item.X >> 3, item.Y >> 3);
DeltaState state = (DeltaState)table[p];
if (state == null)
{
table[p] = state = new DeltaState(p);
}
state.m_List.Add(item);
}
}
eable.Free();
}
if (mapTable.Count == 0)
{
from.SendGump(new NoticeGump(1060637, 30720, "No freezable items were found. Only the following item types are frozen:<br> - Static<br> - BaseFloor<br> - BaseWall", 0xFFC000, 320, 240, null, null));
return;
}
bool badDataFile = false;
int totalFrozen = 0;
foreach (DictionaryEntry de in mapTable)
{
Map map = (Map)de.Key;
Hashtable table = (Hashtable)de.Value;
TileMatrix matrix = map.Tiles;
using (FileStream idxStream = OpenWrite(matrix.IndexStream))
{
using (FileStream mulStream = OpenWrite(matrix.DataStream))
{
if (idxStream == null || mulStream == null)
{
badDataFile = true;
continue;
}
BinaryReader idxReader = new BinaryReader(idxStream);
BinaryWriter idxWriter = new BinaryWriter(idxStream);
BinaryWriter mulWriter = new BinaryWriter(mulStream);
foreach (DeltaState state in table.Values)
{
int oldTileCount;
StaticTile[] oldTiles = ReadStaticBlock(idxReader, mulStream, state.m_X, state.m_Y, matrix.BlockWidth, matrix.BlockHeight, out oldTileCount);
if (oldTileCount < 0)
{
continue;
}
int newTileCount = 0;
StaticTile[] newTiles = new StaticTile[state.m_List.Count];
for (int i = 0; i < state.m_List.Count; ++i)
{
Item item = state.m_List[i];
int xOffset = item.X - (state.m_X * 8);
int yOffset = item.Y - (state.m_Y * 8);
if (xOffset < 0 || xOffset >= 8 || yOffset < 0 || yOffset >= 8)
{
continue;
}
StaticTile newTile = new StaticTile((ushort)item.ItemID, (byte)xOffset, (byte)yOffset, (sbyte)item.Z, (short)item.Hue);
newTiles[newTileCount++] = newTile;
item.Delete();
++totalFrozen;
}
int mulPos = -1;
int length = -1;
int extra = 0;
if ((oldTileCount + newTileCount) > 0)
{
mulWriter.Seek(0, SeekOrigin.End);
mulPos = (int)mulWriter.BaseStream.Position;
length = (oldTileCount + newTileCount) * 7;
extra = 1;
for (int i = 0; i < oldTileCount; ++i)
{
StaticTile toWrite = oldTiles[i];
mulWriter.Write((ushort)toWrite.ID);
mulWriter.Write((byte)toWrite.X);
mulWriter.Write((byte)toWrite.Y);
mulWriter.Write((sbyte)toWrite.Z);
mulWriter.Write((short)toWrite.Hue);
}
for (int i = 0; i < newTileCount; ++i)
{
StaticTile toWrite = newTiles[i];
mulWriter.Write((ushort)toWrite.ID);
mulWriter.Write((byte)toWrite.X);
mulWriter.Write((byte)toWrite.Y);
mulWriter.Write((sbyte)toWrite.Z);
mulWriter.Write((short)toWrite.Hue);
}
mulWriter.Flush();
}
int idxPos = ((state.m_X * matrix.BlockHeight) + state.m_Y) * 12;
idxWriter.Seek(idxPos, SeekOrigin.Begin);
idxWriter.Write(mulPos);
idxWriter.Write(length);
idxWriter.Write(extra);
idxWriter.Flush();
matrix.SetStaticBlock(state.m_X, state.m_Y, null);
}
}
}
}
if (totalFrozen == 0 && badDataFile)
{
from.SendGump(new NoticeGump(1060637, 30720, "Output data files could not be opened and the freeze operation has been aborted.<br><br>This probably means your server and client are using the same data files. Instructions on how to resolve this can be found in the first warning window.", 0xFFC000, 320, 240, null, null));
}
else
{
from.SendGump(new NoticeGump(1060637, 30720, String.Format("Freeze operation completed successfully.<br><br>{0} item{1} frozen.<br><br>You must restart your client and update it's data files to see the changes.", totalFrozen, totalFrozen != 1 ? "s were" : " was"), 0xFFC000, 320, 240, null, null));
}
}
private static void DoUnfreeze(Map map, Point2D start, Point2D end, ref bool badDataFile, ref int totalUnfrozen)
{
start = map.Bound(start);
end = map.Bound(end);
int xStartBlock = start.X >> 3;
int yStartBlock = start.Y >> 3;
int xEndBlock = end.X >> 3;
int yEndBlock = end.Y >> 3;
int xTileStart = start.X, yTileStart = start.Y;
int xTileWidth = end.X - start.X + 1, yTileHeight = end.Y - start.Y + 1;
TileMatrix matrix = map.Tiles;
using (FileStream idxStream = OpenWrite(matrix.IndexStream))
{
using (FileStream mulStream = OpenWrite(matrix.DataStream))
{
if (idxStream == null || mulStream == null)
{
badDataFile = true;
return;
}
BinaryReader idxReader = new BinaryReader(idxStream);
BinaryWriter idxWriter = new BinaryWriter(idxStream);
BinaryWriter mulWriter = new BinaryWriter(mulStream);
for (int x = xStartBlock; x <= xEndBlock; ++x)
{
for (int y = yStartBlock; y <= yEndBlock; ++y)
{
int oldTileCount;
StaticTile[] oldTiles = ReadStaticBlock(idxReader, mulStream, x, y, matrix.BlockWidth, matrix.BlockHeight, out oldTileCount);
if (oldTileCount < 0)
{
continue;
}
int newTileCount = 0;
StaticTile[] newTiles = new StaticTile[oldTileCount];
int baseX = (x << 3) - xTileStart, baseY = (y << 3) - yTileStart;
for (int i = 0; i < oldTileCount; ++i)
{
StaticTile oldTile = oldTiles[i];
int px = baseX + oldTile.X;
int py = baseY + oldTile.Y;
if (px < 0 || px >= xTileWidth || py < 0 || py >= yTileHeight)
{
newTiles[newTileCount++] = oldTile;
}
else
{
++totalUnfrozen;
Item item = new Static(oldTile.ID)
{
Hue = oldTile.Hue
};
item.MoveToWorld(new Point3D(px + xTileStart, py + yTileStart, oldTile.Z), map);
}
}
int mulPos = -1;
int length = -1;
int extra = 0;
if (newTileCount > 0)
{
mulWriter.Seek(0, SeekOrigin.End);
mulPos = (int)mulWriter.BaseStream.Position;
length = newTileCount * 7;
extra = 1;
for (int i = 0; i < newTileCount; ++i)
{
StaticTile toWrite = newTiles[i];
mulWriter.Write((ushort)toWrite.ID);
mulWriter.Write((byte)toWrite.X);
mulWriter.Write((byte)toWrite.Y);
mulWriter.Write((sbyte)toWrite.Z);
mulWriter.Write((short)toWrite.Hue);
}
mulWriter.Flush();
}
int idxPos = ((x * matrix.BlockHeight) + y) * 12;
idxWriter.Seek(idxPos, SeekOrigin.Begin);
idxWriter.Write(mulPos);
idxWriter.Write(length);
idxWriter.Write(extra);
idxWriter.Flush();
matrix.SetStaticBlock(x, y, null);
}
}
}
}
}
public void Register()
{
if (m_Registered)
{
return;
}
OnRegister();
m_Registered = true;
if (m_Parent != null)
{
m_Parent.m_Children.Add(this);
m_Parent.OnChildAdded(this);
}
m_Regions.Add(this);
m_Map.RegisterRegion(this);
m_IndexedName = IndexedRegionName.NotIndexed;
if (m_Name != null)
{
IndexedRegionName temp;
if (m_NameToIndexLookup.TryGetValue(m_Name, out temp))
{
m_IndexedName = temp;
}
}
List <Sector> sectors = new List <Sector>();
for (int i = 0; i < m_Area.Length; i++)
{
Rectangle3D rect = m_Area[i];
Point2D start = m_Map.Bound(new Point2D(rect.Start));
Point2D end = m_Map.Bound(new Point2D(rect.End));
Sector startSector = m_Map.GetSector(start);
Sector endSector = m_Map.GetSector(end);
for (int x = startSector.X; x <= endSector.X; x++)
{
for (int y = startSector.Y; y <= endSector.Y; y++)
{
Sector sector = m_Map.GetRealSector(x, y);
sector.OnEnter(this, rect);
if (!sectors.Contains(sector))
{
sectors.Add(sector);
}
}
}
}
m_Sectors = sectors.ToArray();
}
