public override bool CanMoveTo(Point2D newLocation, ref string err)
{
if ( ! base.CanMoveTo (newLocation, ref err) )
return false;
// Care only about absolutes for knights
int dx = Math.Abs( newLocation.X - m_Position.X );
int dy = Math.Abs( newLocation.Y - m_Position.Y );
if ( ! ( ( dx == 1 && dy == 2 ) || ( dx == 2 && dy == 1 ) ) )
{
err = "Knights can only make L shaped moves (2-3 tiles length)";
return false; // Wrong move
}
// Verify target piece
BaseChessPiece piece = m_BChessboard[ newLocation ];
if ( piece == null || piece.Color != m_Color )
return true;
else
{
err = "You can't capture pieces of your same color";
return false;
}
}
public override ArrayList GetMoves(bool capture)
{
ArrayList moves = new ArrayList();
for ( int dx = -2; dx <= 2; dx++ )
{
for ( int dy = -2; dy <= 2; dy++ )
{
if ( ! ( ( Math.Abs( dx ) == 1 && Math.Abs( dy ) == 2 ) || ( Math.Abs( dx ) == 2 && Math.Abs( dy ) == 1 ) ) )
continue;
Point2D p = new Point2D( m_Position.X + dx, m_Position.Y + dy );
if ( ! m_BChessboard.IsValid( p ) )
continue;
BaseChessPiece piece = m_BChessboard[ p ];
if ( piece == null )
moves.Add( p );
else if ( capture && piece.Color != m_Color )
moves.Add( p );
}
}
return moves;
}
/// <summary>
/// Creates a new Move object without capturing a piece
/// </summary>
/// <param name="piece">The chess piece performing the move</param>
/// <param name="target">The target location of the move</param>
public Move( BaseChessPiece piece, Point2D target )
{
m_Piece = piece;
m_From = m_Piece.Position;
m_To = target;
m_Captured = m_Piece.GetCaptured( target, ref m_EnPassant );
}
public static MahjongPieceDim GetDimensions( Point2D position, MahjongPieceDirection direction )
{
if ( direction == MahjongPieceDirection.Up || direction == MahjongPieceDirection.Down )
return new MahjongPieceDim( position, 40, 20 );
else
return new MahjongPieceDim( position, 20, 40 );
}
public MultiComponentList( MultiComponentList toCopy )
{
m_Min = toCopy.m_Min;
m_Max = toCopy.m_Max;
m_Center = toCopy.m_Center;
m_Width = toCopy.m_Width;
m_Height = toCopy.m_Height;
m_Tiles = new StaticTile[m_Width][][];
for ( int x = 0; x < m_Width; ++x )
{
m_Tiles[x] = new StaticTile[m_Height][];
for ( int y = 0; y < m_Height; ++y )
{
m_Tiles[x][y] = new StaticTile[toCopy.m_Tiles[x][y].Length];
for ( int i = 0; i < m_Tiles[x][y].Length; ++i )
m_Tiles[x][y][i] = toCopy.m_Tiles[x][y][i];
}
}
m_List = new MultiTileEntry[toCopy.m_List.Length];
for ( int i = 0; i < m_List.Length; ++i )
m_List[i] = toCopy.m_List[i];
}
private static void LoadLocations()
{
string filePath = Path.Combine(Core.BaseDirectory, "Data/treasure.cfg");
ArrayList list = new ArrayList();
ArrayList havenList = new ArrayList();
if (File.Exists(filePath))
{
using (StreamReader ip = new StreamReader(filePath))
{
string line;
while ((line = ip.ReadLine()) != null)
{
try
{
string[] split = line.Split(' ');
int x = Convert.ToInt32(split[0]), y = Convert.ToInt32(split[1]);
Point2D loc = new Point2D(x, y);
list.Add(loc);
}
catch
{
}
}
}
}
m_Locations = (Point2D[])list.ToArray(typeof(Point2D));
}
public MahjongDealerIndicator( MahjongGame game, Point2D position, MahjongPieceDirection direction, MahjongWind wind )
{
m_Game = game;
m_Position = position;
m_Direction = direction;
m_Wind = wind;
}
public TrackingInfo( Mobile tracker, Mobile target )
{
m_Tracker = tracker;
m_Target = target;
m_Location = new Point2D( target.X, target.Y );
m_Map = target.Map;
}
public MahjongWallBreakIndicator( MahjongGame game, GenericReader reader )
{
m_Game = game;
int version = reader.ReadInt();
m_Position = reader.ReadPoint2D();
}
public TreasureMessage( int level, Map map )
{
Name = "a handwritten message";
Hue = 0x2EF;
m_Level = level;
m_Map = map;
m_MessageIndex = Utility.Random( MessageEntry.Entries.Length );
m_Location = GetRandomLocation();
}
//----------------------------------------------------------------------
// Here, we are going to search the quadrant that it is ahead of the player, because
// he is running
//----------------------------------------------------------------------
public static bool FindAhead(
PlayerMobile pm,
Point3D centerPoint,
ref Point3D spawnPoint,
LandType landType,
int distance,
EffectType effectType,
int effectHue
)
{
Direction dir = (Direction)((int)pm.Direction & 0x0f);
Point3D foundPoint = new Point3D();
Tour tour = delegate( Map map, int x, int y )
{
if( Utility.RandomDouble() < .5 ) return false; // break it up a little.
Point2D currentPoint = new Point2D( pm.Location.X + x, pm.Location.Y + y );
if( FindSpawnTileInternal(
pm,
centerPoint,
currentPoint,
ref foundPoint,
landType,
effectType,
effectHue
)
)
{
return true;
}
return false;
};
bool found = Search.Octant(
pm.Map,
dir,
distance,
SearchDirection.Inwards,
tour
);
if( found )
{
spawnPoint.X = foundPoint.X;
spawnPoint.Y = foundPoint.Y;
spawnPoint.Z = foundPoint.Z;
return true;
}
return false;
}
public MahjongDealerIndicator( MahjongGame game, GenericReader reader )
{
m_Game = game;
int version = reader.ReadInt();
m_Position = reader.ReadPoint2D();
m_Direction = (MahjongPieceDirection) reader.ReadInt();
m_Wind = (MahjongWind) reader.ReadInt();
}
public MahjongTile( MahjongGame game, int number, MahjongTileType value, Point2D position, int stackLevel, MahjongPieceDirection direction, bool flipped )
{
m_Game = game;
m_Number = number;
m_Value = value;
m_Position = position;
m_StackLevel = stackLevel;
m_Direction = direction;
m_Flipped = flipped;
}
public void EndCastle( Point2D location )
{
m_HasMoved = true;
m_Move = new Move( this, location );
Point2D worldLocation = m_BChessboard.BoardToWorld( location );
m_Piece.GoTo( worldLocation );
}
public StudyObjective( Point2D point, int range, Map map, string[] messages, int seconds ) : base( 1, seconds )
{
Point = point;
Range = range;
Map = map;
Messages = messages;
OnMessage = 0;
CheckTimer();
}
public void Move( Point2D position )
{
MahjongPieceDim dim = GetDimensions( position );
if ( !dim.IsValid() )
return;
m_Position = position;
m_Game.Players.SendGeneralPacket( true, true );
}
public MahjongTile( MahjongGame game, GenericReader reader )
{
m_Game = game;
int version = reader.ReadInt();
m_Number = reader.ReadInt();
m_Value = (MahjongTileType) reader.ReadInt();
m_Position = reader.ReadPoint2D();
m_StackLevel = reader.ReadInt();
m_Direction = (MahjongPieceDirection) reader.ReadInt();
m_Flipped = reader.ReadBool();
}
public ToolbarInfo(
Point2D dimensions, List<string> entries, int skin, List<Point3D> points, int font, bool[] switches)
{
_Dimensions = dimensions;
_Entries = entries;
_Skin = skin;
_Points = points;
_Font = font;
_Phantom = switches[0];
_Stealth = switches[1];
_Reverse = switches[2];
_Lock = switches[3];
}
public void Move( Point2D position, MahjongPieceDirection direction, MahjongWind wind )
{
MahjongPieceDim dim = GetDimensions( position, direction );
if ( !dim.IsValid() )
{
return;
}
m_Position = position;
m_Direction = direction;
m_Wind = wind;
m_Game.Players.SendGeneralPacket( true, true );
}
public override void Deserialize( GenericReader reader )
{
base.Deserialize( reader );
int version = reader.ReadEncodedInt();
Point = reader.ReadPoint2D();
Range = reader.ReadInt();
Map = reader.ReadMap();
int count = reader.ReadInt();
Messages = new string[ count ];
for ( int i = 0; i < count; i++ )
Messages[i] = reader.ReadString();
OnMessage = reader.ReadInt();
}
public void Move( Point2D position, MahjongPieceDirection direction, bool flip, int validHandArea )
{
MahjongPieceDim dim = GetDimensions( position, direction );
int curHandArea = Dimensions.GetHandArea();
int newHandArea = dim.GetHandArea();
if ( !IsMovable || !dim.IsValid() || ( validHandArea >= 0 && ((curHandArea >= 0 && curHandArea != validHandArea) || (newHandArea >= 0 && newHandArea != validHandArea)) ) )
return;
m_Position = position;
m_Direction = direction;
m_StackLevel = -1; // Avoid self interference
m_StackLevel = m_Game.GetStackLevel( dim ) + 1;
m_Flipped = flip;
m_Game.Players.SendTilePacket( this, true, true );
}
public override bool CanMoveTo(Point2D newLocation, ref string err)
{
if ( ! base.CanMoveTo (newLocation, ref err) )
return false;
int dx = newLocation.X - m_Position.X;
int dy = newLocation.Y - m_Position.Y;
if ( Math.Abs( dx ) != Math.Abs( dy ) )
{
err = "Bishops can move only on diagonals";
return false; // Not a diagonal movement
}
int xDirection = dx > 0 ? 1 : -1;
int yDirection = dy > 0 ? 1 : -1;
if ( Math.Abs( dx ) > 1 )
{
// Verify that the path to target is empty
for ( int i = 1; i < Math.Abs( dx ); i++ ) // Skip the bishop square and stop before target
{
int xOffset = xDirection * i;
int yOffset = yDirection * i;
if ( m_BChessboard[ m_Position.X + xOffset, m_Position.Y + yOffset ] != null )
{
err = "Bishops can't move over other pieces";
return false;
}
}
}
// Verify target piece
BaseChessPiece piece = m_BChessboard[ newLocation ];
if ( piece == null || piece.Color != m_Color )
{
return true;
}
else
{
err = "You can't capture pieces of your own color";
return false;
}
}
/// <summary>
/// Moves the NPC to the specified location
/// </summary>
/// <param name="to">The location the NPC should move to</param>
public void GoTo( Point2D to )
{
AI = AIType.AI_Melee;
m_NextMove = new Point3D( to, Z );
if ( m_Piece is Knight )
{
WayPoint end = new WayPoint();
WayPoint start = new WayPoint();
end.MoveToWorld( m_NextMove, Map );
// This is a knight, so do L shaped move
int dx = to.X - X;
int dy = to.Y - Y;
Point3D p = Location; // Point3D is a value type
if ( Math.Abs( dx ) == 1 )
p.X += dx;
else
p.Y += dy;
start.MoveToWorld( p, Map );
start.NextPoint = end;
CurrentWayPoint = start;
m_WayPoints.Add( start );
m_WayPoints.Add( end );
}
else
{
WayPoint wp = new WayPoint();
wp.MoveToWorld( m_NextMove, Map );
CurrentWayPoint = wp;
m_WayPoints.Add( wp );
}
Paralyzed = false;
}
protected override void OnTarget(Mobile from, object targ)
{
if (targ is IPoint2D)
{
Point2D p = new Point2D((IPoint2D)targ);
if (!from.CheckSkill(SkillName.Musicianship, 0.0, 120.0))
{
from.SendLocalizedMessage(502472); // You don't seem to be able to persuade that to move.
m_Flute.PlayInstrumentBadly(from);
}
else if (!m_Snake.InRange(p, 10))
{
from.SendLocalizedMessage(500643); // Target is too far away.
}
else
{
m_Snake.BeginCharm(from, p);
from.SendLocalizedMessage(502479); // The animal walks where it was instructed to.
from.BeginAction(typeof(SnakeCharmerFlute));
Timer.DelayCall(TimeSpan.FromSeconds(5.0), new TimerCallback(
delegate { from.EndAction(typeof(SnakeCharmerFlute)); }));
m_Flute.PlayInstrumentWell(from);
m_Flute.UsesRemaining--;
if (m_Flute.UsesRemaining == 0)
{
from.SendLocalizedMessage(1112177); // You broke your snake charmer flute.
m_Flute.Delete();
}
}
}
}
public override bool CanMoveTo(Point2D newLocation, ref string err)
{
if ( ! base.CanMoveTo (newLocation, ref err) )
return false;
// Verify if this is a castle
BaseChessPiece rook = m_BChessboard[ newLocation ];
if ( rook is Rook && rook.Color == m_Color )
{
// Trying to castle
return m_BChessboard.AllowCastle( this, rook, ref err );
}
int dx = newLocation.X - m_Position.X;
int dy = newLocation.Y - m_Position.Y;
if ( Math.Abs( dx ) > 1 || Math.Abs( dy ) > 1 )
{
err = "The can king can move only 1 tile at a time";
return false; // King can move only 1 tile away from its position
}
// Verify target piece
BaseChessPiece piece = m_BChessboard[ newLocation ];
if ( piece == null || piece.Color != m_Color )
{
return true;
}
else
{
err = "You can't capture pieces of your same color";
return false;
}
}
public static bool InUpdateRange(Point2D p1, Point2D p2)
{
return((p1.m_X >= (p2.m_X - 18)) && (p1.m_X <= (p2.m_X + 18)) && (p1.m_Y >= (p2.m_Y - 18)) &&
(p1.m_Y <= (p2.m_Y + 18)));
}
public override void Write(Point2D value)
{
Write(value.m_X);
Write(value.m_Y);
}
public void Transform(ref Point2D p, double offset)
{
Transform(ref p, this, offset);
}
public static Triangle2D Parse(string value)
{
var param = value.Split('+');
if (param.Length >= 3 && param.All(p => p.Contains(',')))
{
return(new Triangle2D(Point2D.Parse(param[0]), Point2D.Parse(param[1]), Point2D.Parse(param[2])));
}
throw new FormatException(
"The specified triangle must be represented by three Point2D coords using the format " + //
"'(x1,y1)+(x2,y2)+(x3,y3)'");
}
public MultiComponentList(BinaryReader reader, int count)
{
MultiTileEntry[] allTiles = m_List = new MultiTileEntry[count];
for (int i = 0; i < count; ++i)
{
allTiles[i].m_ItemID = reader.ReadUInt16();
allTiles[i].m_OffsetX = reader.ReadInt16();
allTiles[i].m_OffsetY = reader.ReadInt16();
allTiles[i].m_OffsetZ = reader.ReadInt16();
if (PostHSFormat)
{
allTiles[i].m_Flags = (TileFlag)reader.ReadUInt64();
}
else
{
allTiles[i].m_Flags = (TileFlag)reader.ReadUInt32();
}
MultiTileEntry e = allTiles[i];
if (i == 0 || e.m_Flags != 0)
{
if (e.m_OffsetX < m_Min.m_X)
{
m_Min.m_X = e.m_OffsetX;
}
if (e.m_OffsetY < m_Min.m_Y)
{
m_Min.m_Y = e.m_OffsetY;
}
if (e.m_OffsetX > m_Max.m_X)
{
m_Max.m_X = e.m_OffsetX;
}
if (e.m_OffsetY > m_Max.m_Y)
{
m_Max.m_Y = e.m_OffsetY;
}
}
}
m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
m_Width = m_Max.m_X - m_Min.m_X + 1;
m_Height = m_Max.m_Y - m_Min.m_Y + 1;
TileList[][] tiles = new TileList[m_Width][];
m_Tiles = new StaticTile[m_Width][][];
for (int x = 0; x < m_Width; ++x)
{
tiles[x] = new TileList[m_Height];
m_Tiles[x] = new StaticTile[m_Height][];
for (int y = 0; y < m_Height; ++y)
{
tiles[x][y] = new TileList();
}
}
for (int i = 0; i < allTiles.Length; ++i)
{
if (i == 0 || allTiles[i].m_Flags != 0)
{
int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
int itemID = (allTiles[i].m_ItemID & TileData.MaxItemValue) | 0x10000;
tiles[xOffset][yOffset].Add((ushort)itemID, (sbyte)allTiles[i].m_OffsetZ);
}
}
for (int x = 0; x < m_Width; ++x)
{
for (int y = 0; y < m_Height; ++y)
{
m_Tiles[x][y] = tiles[x][y].ToArray();
}
}
}
public MultiComponentList(List <MultiTileEntry> list)
{
MultiTileEntry[] allTiles = m_List = new MultiTileEntry[list.Count];
for (int i = 0; i < list.Count; ++i)
{
allTiles[i].m_ItemID = list[i].m_ItemID;
allTiles[i].m_OffsetX = list[i].m_OffsetX;
allTiles[i].m_OffsetY = list[i].m_OffsetY;
allTiles[i].m_OffsetZ = list[i].m_OffsetZ;
allTiles[i].m_Flags = list[i].m_Flags;
MultiTileEntry e = allTiles[i];
if (i == 0 || e.m_Flags != 0)
{
if (e.m_OffsetX < m_Min.m_X)
{
m_Min.m_X = e.m_OffsetX;
}
if (e.m_OffsetY < m_Min.m_Y)
{
m_Min.m_Y = e.m_OffsetY;
}
if (e.m_OffsetX > m_Max.m_X)
{
m_Max.m_X = e.m_OffsetX;
}
if (e.m_OffsetY > m_Max.m_Y)
{
m_Max.m_Y = e.m_OffsetY;
}
}
}
m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
m_Width = m_Max.m_X - m_Min.m_X + 1;
m_Height = m_Max.m_Y - m_Min.m_Y + 1;
TileList[][] tiles = new TileList[m_Width][];
m_Tiles = new StaticTile[m_Width][][];
for (int x = 0; x < m_Width; ++x)
{
tiles[x] = new TileList[m_Height];
m_Tiles[x] = new StaticTile[m_Height][];
for (int y = 0; y < m_Height; ++y)
{
tiles[x][y] = new TileList();
}
}
for (int i = 0; i < allTiles.Length; ++i)
{
if (i == 0 || allTiles[i].m_Flags != 0)
{
int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
int itemID = (allTiles[i].m_ItemID & TileData.MaxItemValue) | 0x10000;
tiles[xOffset][yOffset].Add((ushort)itemID, (sbyte)allTiles[i].m_OffsetZ);
}
}
for (int x = 0; x < m_Width; ++x)
{
for (int y = 0; y < m_Height; ++y)
{
m_Tiles[x][y] = tiles[x][y].ToArray();
}
}
}
public override void Write(Point2D value)
{
this.Write(value.m_X);
this.Write(value.m_Y);
}
public MultiComponentList(GenericReader reader)
{
int version = reader.ReadInt();
m_Min = reader.ReadPoint2D();
m_Max = reader.ReadPoint2D();
m_Center = reader.ReadPoint2D();
m_Width = reader.ReadInt();
m_Height = reader.ReadInt();
int length = reader.ReadInt();
MultiTileEntry[] allTiles = m_List = new MultiTileEntry[length];
if (version == 0)
{
for (int i = 0; i < length; ++i)
{
int id = reader.ReadShort();
if (id >= 0x4000)
{
id -= 0x4000;
}
allTiles[i].m_ItemID = (ushort)id;
allTiles[i].m_OffsetX = reader.ReadShort();
allTiles[i].m_OffsetY = reader.ReadShort();
allTiles[i].m_OffsetZ = reader.ReadShort();
allTiles[i].m_Flags = reader.ReadInt();
}
}
else
{
for (int i = 0; i < length; ++i)
{
allTiles[i].m_ItemID = reader.ReadUShort();
allTiles[i].m_OffsetX = reader.ReadShort();
allTiles[i].m_OffsetY = reader.ReadShort();
allTiles[i].m_OffsetZ = reader.ReadShort();
allTiles[i].m_Flags = reader.ReadInt();
}
}
TileList[][] tiles = new TileList[m_Width][];
m_Tiles = new StaticTile[m_Width][][];
for (int x = 0; x < m_Width; ++x)
{
tiles[x] = new TileList[m_Height];
m_Tiles[x] = new StaticTile[m_Height][];
for (int y = 0; y < m_Height; ++y)
{
tiles[x][y] = new TileList();
}
}
for (int i = 0; i < allTiles.Length; ++i)
{
if (i == 0 || allTiles[i].m_Flags != 0)
{
int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
tiles[xOffset][yOffset].Add((ushort)allTiles[i].m_ItemID, (sbyte)allTiles[i].m_OffsetZ);
}
}
for (int x = 0; x < m_Width; ++x)
{
for (int y = 0; y < m_Height; ++y)
{
m_Tiles[x][y] = tiles[x][y].ToArray();
}
}
}
public void Resize(int newWidth, int newHeight)
{
int oldWidth = m_Width, oldHeight = m_Height;
Tile[][][] oldTiles = m_Tiles;
int totalLength = 0;
Tile[][][] newTiles = new Tile[newWidth][][];
for (int x = 0; x < newWidth; ++x)
{
newTiles[x] = new Tile[newHeight][];
for (int y = 0; y < newHeight; ++y)
{
if (x < oldWidth && y < oldHeight)
{
newTiles[x][y] = oldTiles[x][y];
}
else
{
newTiles[x][y] = new Tile[0];
}
totalLength += newTiles[x][y].Length;
}
}
m_Tiles = newTiles;
m_List = new MultiTileEntry[totalLength];
m_Width = newWidth;
m_Height = newHeight;
m_Min = Point2D.Zero;
m_Max = Point2D.Zero;
int index = 0;
for (int x = 0; x < newWidth; ++x)
{
for (int y = 0; y < newHeight; ++y)
{
Tile[] tiles = newTiles[x][y];
for (int i = 0; i < tiles.Length; ++i)
{
Tile tile = tiles[i];
int vx = x - m_Center.X;
int vy = y - m_Center.Y;
if (vx < m_Min.m_X)
{
m_Min.m_X = vx;
}
if (vy < m_Min.m_Y)
{
m_Min.m_Y = vy;
}
if (vx > m_Max.m_X)
{
m_Max.m_X = vx;
}
if (vy > m_Max.m_Y)
{
m_Max.m_Y = vy;
}
m_List[index++] = new MultiTileEntry((short)tile.ID, (short)vx, (short)vy, (short)tile.Z, 1);
}
}
}
}
public MultiComponentList(GenericReader reader)
{
int version = reader.ReadInt();
switch (version)
{
case 0:
{
m_Min = reader.ReadPoint2D();
m_Max = reader.ReadPoint2D();
m_Center = reader.ReadPoint2D();
m_Width = reader.ReadInt();
m_Height = reader.ReadInt();
int length = reader.ReadInt();
MultiTileEntry[] allTiles = m_List = new MultiTileEntry[length];
for (int i = 0; i < length; ++i)
{
allTiles[i].m_ItemID = reader.ReadShort();
allTiles[i].m_OffsetX = reader.ReadShort();
allTiles[i].m_OffsetY = reader.ReadShort();
allTiles[i].m_OffsetZ = reader.ReadShort();
allTiles[i].m_Flags = reader.ReadInt();
}
TileList[][] tiles = new TileList[m_Width][];
m_Tiles = new Tile[m_Width][][];
for (int x = 0; x < m_Width; ++x)
{
tiles[x] = new TileList[m_Height];
m_Tiles[x] = new Tile[m_Height][];
for (int y = 0; y < m_Height; ++y)
{
tiles[x][y] = new TileList();
}
}
for (int i = 0; i < allTiles.Length; ++i)
{
if (i == 0 || allTiles[i].m_Flags != 0)
{
int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
tiles[xOffset][yOffset].Add((short)((allTiles[i].m_ItemID & 0x3FFF) | 0x4000), (sbyte)allTiles[i].m_OffsetZ);
}
}
for (int x = 0; x < m_Width; ++x)
{
for (int y = 0; y < m_Height; ++y)
{
m_Tiles[x][y] = tiles[x][y].ToArray();
}
}
break;
}
}
}
public MultiComponentList(BinaryReader reader, int count)
{
MultiTileEntry[] allTiles = m_List = new MultiTileEntry[count];
for (int i = 0; i < count; ++i)
{
allTiles[i].m_ItemID = reader.ReadInt16();
allTiles[i].m_OffsetX = reader.ReadInt16();
allTiles[i].m_OffsetY = reader.ReadInt16();
allTiles[i].m_OffsetZ = reader.ReadInt16();
allTiles[i].m_Flags = reader.ReadInt32();
MultiTileEntry e = allTiles[i];
if (i == 0 || e.m_Flags != 0)
{
if (e.m_OffsetX < m_Min.m_X)
{
m_Min.m_X = e.m_OffsetX;
}
if (e.m_OffsetY < m_Min.m_Y)
{
m_Min.m_Y = e.m_OffsetY;
}
if (e.m_OffsetX > m_Max.m_X)
{
m_Max.m_X = e.m_OffsetX;
}
if (e.m_OffsetY > m_Max.m_Y)
{
m_Max.m_Y = e.m_OffsetY;
}
}
}
m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
m_Width = (m_Max.m_X - m_Min.m_X) + 1;
m_Height = (m_Max.m_Y - m_Min.m_Y) + 1;
TileList[][] tiles = new TileList[m_Width][];
m_Tiles = new Tile[m_Width][][];
for (int x = 0; x < m_Width; ++x)
{
tiles[x] = new TileList[m_Height];
m_Tiles[x] = new Tile[m_Height][];
for (int y = 0; y < m_Height; ++y)
{
tiles[x][y] = new TileList();
}
}
for (int i = 0; i < allTiles.Length; ++i)
{
if (i == 0 || allTiles[i].m_Flags != 0)
{
int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
tiles[xOffset][yOffset].Add((short)((allTiles[i].m_ItemID & 0x3FFF) | 0x4000), (sbyte)allTiles[i].m_OffsetZ);
}
}
for (int x = 0; x < m_Width; ++x)
{
for (int y = 0; y < m_Height; ++y)
{
m_Tiles[x][y] = tiles[x][y].ToArray();
}
}
}
private static void ProcessDisplayCase( Map map, StaticTile[] tiles, int x, int y )
{
ShopFlags flags = ShopFlags.None;
for ( int i = 0; i < tiles.Length; ++i )
flags |= ProcessDisplayedItem( tiles[i].ID );
if ( flags != ShopFlags.None )
{
Point2D p = new Point2D( x, y );
ShopInfo si = (ShopInfo)m_ShopTable[p];
if ( si == null )
{
ArrayList floor = new ArrayList();
RecurseFindFloor( map, x, y, floor );
if ( floor.Count == 0 )
return;
si = new ShopInfo();
si.m_Flags = flags;
si.m_Floor = floor;
m_ShopList.Add( si );
for ( int i = 0; i < floor.Count; ++i )
m_ShopTable[(Point2D)floor[i]] = si;
}
else
{
si.m_Flags |= flags;
}
}
}
public abstract void Write(Point2D value);
public DeltaState( Point2D p )
{
m_X = p.X;
m_Y = p.Y;
m_List = new ArrayList();
}
public static bool Mobile_SkillCheckDirectLocation( Mobile from, SkillName skillName, double chance )
{
Skill skill = from.Skills[skillName];
if ( skill == null )
return false;
if ( chance < 0.0 )
return false; // Too difficult
else if ( chance >= 1.0 )
return true; // No challenge
Point2D loc = new Point2D( from.Location.X / LocationSize, from.Location.Y / LocationSize );
return CheckSkill( from, skill, loc, chance );
}
private static void RecurseFindFloor( Map map, int x, int y, ArrayList floor )
{
Point2D p = new Point2D( x, y );
if ( floor.Contains( p ) )
return;
floor.Add( p );
for ( int xo = -1; xo <= 1; ++xo )
{
for ( int yo = -1; yo <= 1; ++yo )
{
if ( (xo != 0 || yo != 0) && IsFloor( map, x + xo, y + yo, false ) )
RecurseFindFloor( map, x + xo, y + yo, floor );
}
}
}
public MultiComponentList(BinaryReader reader, int count)
{
var allTiles = m_List = new MultiTileEntry[count];
for (int i = 0; i < count; ++i)
{
allTiles[i].m_ItemID = reader.ReadUInt16();
allTiles[i].m_OffsetX = reader.ReadInt16();
allTiles[i].m_OffsetY = reader.ReadInt16();
allTiles[i].m_OffsetZ = reader.ReadInt16();
allTiles[i].m_Flags = reader.ReadInt32();
if (_PostHSFormat)
{
reader.ReadInt32(); // ??
}
MultiTileEntry e = allTiles[i];
if (i == 0 || e.m_Flags != 0)
{
if (e.m_OffsetX < m_Min.m_X)
{
m_Min.m_X = e.m_OffsetX;
}
if (e.m_OffsetY < m_Min.m_Y)
{
m_Min.m_Y = e.m_OffsetY;
}
if (e.m_OffsetX > m_Max.m_X)
{
m_Max.m_X = e.m_OffsetX;
}
if (e.m_OffsetY > m_Max.m_Y)
{
m_Max.m_Y = e.m_OffsetY;
}
}
}
m_Center = new Point2D(-m_Min.m_X, -m_Min.m_Y);
m_Width = (m_Max.m_X - m_Min.m_X) + 1;
m_Height = (m_Max.m_Y - m_Min.m_Y) + 1;
var tiles = new TileList[m_Width][];
m_Tiles = new StaticTile[m_Width][][];
for (int x = 0; x < m_Width; ++x)
{
tiles[x] = new TileList[m_Height];
m_Tiles[x] = new StaticTile[m_Height][];
for (int y = 0; y < m_Height; ++y)
{
tiles[x][y] = new TileList();
}
}
for (int i = 0; i < allTiles.Length; ++i)
{
if (i == 0 || allTiles[i].m_Flags != 0)
{
int xOffset = allTiles[i].m_OffsetX + m_Center.m_X;
int yOffset = allTiles[i].m_OffsetY + m_Center.m_Y;
#region Stygian Abyss
//tiles[xOffset][yOffset].Add( (ushort)allTiles[i].m_ItemID, (sbyte)allTiles[i].m_OffsetZ );
tiles[xOffset][yOffset].Add(
(ushort)((allTiles[i].m_ItemID & TileData.MaxItemValue) | 0x10000), (sbyte)allTiles[i].m_OffsetZ);
#endregion
}
}
for (int x = 0; x < m_Width; ++x)
{
for (int y = 0; y < m_Height; ++y)
{
m_Tiles[x][y] = tiles[x][y].ToArray();
}
}
}
public static bool Mobile_SkillCheckLocation( Mobile from, SkillName skillName, double minSkill, double maxSkill )
{
Skill skill = from.Skills[skillName];
if ( skill == null )
return false;
double value = skill.Value;
if ( value < minSkill )
return false; // Too difficult
else if ( value >= maxSkill )
return true; // No challenge
double chance = (value - minSkill) / (maxSkill - minSkill);
Point2D loc = new Point2D( from.Location.X / LocationSize, from.Location.Y / LocationSize );
return CheckSkill( from, skill, loc, chance );
}
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();
}