private Objects.Location CentralizeMemoryLocation(Objects.Location memLoc, Map.Tile playerTile)
{
// 8,6 == center
int diffX = 8 - playerTile.RealMemoryLocation.X;
int diffY = 6 - playerTile.RealMemoryLocation.Y;
Objects.Location loc = memLoc.Offset(diffX, diffY);
int maxX = Constants.Map.MaxX, maxY = Constants.Map.MaxY;
if (loc.X >= maxX)
{
loc.X -= maxX;
}
else if (loc.X < 0)
{
loc.X += maxX;
}
if (loc.Y >= maxY)
{
loc.Y -= maxY;
}
else if (loc.Y < 0)
{
loc.Y += maxY;
}
return(loc);
}
/// <summary>
/// Gets a collection of tiles on the current floor.
/// </summary>
/// <returns></returns>
public Map.TileCollection GetTilesOnScreen()
{
List <Map.Tile> listTiles = new List <Map.Tile>();
Map.Tile playerTile = this.GetPlayerTile();
if (playerTile == null)
{
return(new Map.TileCollection(this.Client, listTiles));
}
byte floor = this.GetPlayerFloor((byte)playerTile.WorldLocation.Z);
ushort[] tileNumbers = this.Client.Memory.ReadUInt16Array(this.TileNumberStart +
floor * (Constants.Map.MaxTilesPerFloor * this.Client.Addresses.Map.TileNumberStep),
Constants.Map.MaxTilesPerFloor);
int mapStart = this.MapStart;
for (int i = 0; i < tileNumbers.Length; i++)
{
Map.Tile t = this.GetTile(tileNumbers[i], playerTile, mapStart);
if (t != null)
{
listTiles.Add(t);
}
}
return(new Map.TileCollection(this.Client, listTiles));
}
/// <summary>
/// Gets the player's tile.
/// </summary>
/// <returns></returns>
public Map.Tile GetPlayerTile()
{
byte playerZ = this.Client.Player.Z;
int floor = 0;
if (playerZ <= 7)
{
floor = 7 - playerZ;
}
else
{
floor = 2;
}
int tileNumber = this.Client.Memory.ReadInt32(this.TileNumberStart +
(Constants.Map.MaxTilesPerFloor * floor * 4) +
Constants.Map.TileNumberCenterOffset);
Map.Tile t = this.CachedTiles[tileNumber];
t.UpdateObjects();
uint id = this.Client.Player.ID;
if (!t.ContainsCreature(id))
{
return(null);
}
t.WorldLocation = this.Client.Player.Location;
t.RealMemoryLocation = this.TileNumberToMemoryLocation(t.TileNumber, t);
t.MemoryLocation = this.CentralizeMemoryLocation(t.RealMemoryLocation, t);
return(t);
}
/// <summary>
/// Gets a tile.
/// </summary>
/// <param name="tileNumber">The tile number to look for.</param>
/// <param name="playerTile">The player's tile, used to get memory location and world location.</param>
/// <param name="mapBegin">The memory address of the beginning of the map structure.</param>
/// <returns></returns>
public Map.Tile GetTile(int tileNumber, Map.Tile playerTile, int mapBegin = 0)
{
if (tileNumber < 0 || tileNumber >= this.CachedTiles.Length)
{
return(null);
}
if (playerTile == null)
{
playerTile = this.GetPlayerTile();
}
if (playerTile == null)
{
return(null);
}
if (mapBegin == 0)
{
mapBegin = this.MapStart;
}
Map.Tile t = this.CachedTiles[tileNumber];
t.Address = mapBegin + this.Client.Addresses.Map.TileStep * tileNumber;
t.UpdateObjects();
t.RealMemoryLocation = this.TileNumberToMemoryLocation(t.TileNumber, playerTile);
t.MemoryLocation = this.CentralizeMemoryLocation(t.RealMemoryLocation, playerTile);
t.WorldLocation = this.MemoryLocationToWorldLocation(t.MemoryLocation, playerTile);
return(t);
}
/// <summary>
/// Gets a tile number based on a memory location.
/// </summary>
/// <param name="tileNumber"></param>
/// <param name="playerTile">The player's tile to use as reference.</param>
/// <returns></returns>
private Objects.Location TileNumberToMemoryLocation(int tileNumber, Map.Tile playerTile)
{
int y = Constants.Map.MaxY,
x = Constants.Map.MaxX;
Objects.Location loc = new Objects.Location();
loc.Z = (int)(tileNumber / (y * x));
loc.Y = (int)((tileNumber - (loc.Z * y * x)) / x);
loc.X = (int)((tileNumber - (loc.Z * y * x)) - loc.Y * x);
return(loc);
}
/// <summary>
/// Gets a tile at a given world location.
/// </summary>
/// <param name="loc">The world location to look fopr.</param>
/// <param name="playerTile">The player's tile, used to get memory location and world location.</param>
/// <returns></returns>
public Map.Tile GetTile(Location loc, Map.Tile playerTile = null, int mapStart = 0)
{
if (playerTile == null)
{
playerTile = this.GetPlayerTile();
}
if (playerTile == null)
{
return(null);
}
// todo: figure this shit out
if (playerTile.WorldLocation.Z != loc.Z)
{
return(null);
}
Location diff = loc - playerTile.WorldLocation;
// set index to player index
int index = this.GetPlayerFloor((byte)playerTile.WorldLocation.Z) * Constants.Map.MaxTilesPerFloor +
Constants.Map.TileNumberCenterIndex;
// subtract instead of add Z as map is from bottom to top
//if (diff.Z != 0) index -= diff.Z * Constants.Map.MaxTilesPerFloor;
if (diff.Y != 0)
{
index += diff.Y * Constants.Map.MaxX;
}
if (diff.X != 0)
{
index += diff.X;
}
if (index < 0 || index >= Constants.Map.MaxTiles)
{
return(null);
}
ushort tileNumber = this.Client.Memory.ReadUInt16(this.TileNumberStart +
this.Client.Addresses.Map.TileNumberStep * index);
return(this.GetTile(tileNumber, playerTile, mapStart));
}
public Map.TileObject GetTopUseItem(Location worldLocation, bool useOn, Map.Tile playerTile = null)
{
Map.Tile pTile = playerTile;
if (pTile == null)
{
pTile = this.GetPlayerTile();
}
if (pTile == null)
{
return(null);
}
Map.Tile tile = this.GetTile(worldLocation, pTile);
if (tile == null)
{
return(null);
}
return(tile.GetTopUseItem(useOn));
}
/// <summary>
/// Gets a world location based on a memory location.
/// </summary>
/// <param name="worldLocation">The world location to use as reference.</param>
/// <param name="playerTile">The player's tile to use as reference.</param>
/// <returns></returns>
private Objects.Location WorldLocationToMemoryLocation(Objects.Location worldLocation, Map.Tile playerTile)
{
// get and apply diffs
int diffX = worldLocation.X - playerTile.WorldLocation.X;
int diffY = worldLocation.Y - playerTile.WorldLocation.Y;
int diffZ = worldLocation.Z - playerTile.WorldLocation.Z;
Objects.Location memLoc = playerTile.RealMemoryLocation.Offset(diffX, diffY, diffZ);
// re-align values if they're out of range
if (memLoc.X < 0)
{
memLoc.X += Constants.Map.MaxX;
}
else if (memLoc.X >= Constants.Map.MaxX)
{
memLoc.X -= Constants.Map.MaxX;
}
if (memLoc.Y < 0)
{
memLoc.Y += Constants.Map.MaxY;
}
else if (memLoc.Y >= Constants.Map.MaxY)
{
memLoc.Y -= Constants.Map.MaxY;
}
return(memLoc);
}
/// <summary>
/// Gets a collection of nearby tiles from a given tile.
/// </summary>
/// <param name="tile">The tile to get the nearby tiles from.</param>
/// <param name="range">At what range to get nearby tiles from.</param>
/// <returns></returns>
public Map.TileCollection GetNearbyTiles(Map.Tile tile, byte range)
{
return(this.GetNearbyTiles(tile.WorldLocation, range));
}
