/// <summary>
/// Gets the distance squared.
/// </summary>
/// <param name="point">The point.</param>
/// <returns>System.Int32.</returns>
public int GetDistanceSquared(Vector2D point)
{
int num = X - point.X;
int num2 = Y - point.Y;
return num * num + num2 * num2;
}
/// <summary>
/// Finds the path.
/// </summary>
/// <param name="user">The user.</param>
/// <param name="diag">if set to <c>true</c> [diag].</param>
/// <param name="map">The map.</param>
/// <param name="start">The start.</param>
/// <param name="end">The end.</param>
/// <returns>List<Vector2D>.</returns>
public static List<Vector2D> FindPath(RoomUser user, bool diag, Gamemap map, Vector2D start, Vector2D end)
{
List<Vector2D> list = new List<Vector2D>();
PathFinderNode pathFinderNode = FindPathReversed(user, diag, map, start, end);
if (pathFinderNode != null)
{
list.Add(end);
while (pathFinderNode.Next != null)
{
list.Add(pathFinderNode.Next.Position);
pathFinderNode = pathFinderNode.Next;
}
}
return list;
}
/// <summary>
/// Finds the path reversed.
/// </summary>
/// <param name="roomUserable">The user.</param>
/// <param name="whatIsDiag">if set to <c>true</c> [diag].</param>
/// <param name="gameLocalMap">The map.</param>
/// <param name="startMap">The start.</param>
/// <param name="endMap">The end.</param>
/// <returns>PathFinderNode.</returns>
public static PathFinderNode FindPathReversed(RoomUser roomUserable, bool whatIsDiag, Gamemap gameLocalMap, Vector2D startMap, Vector2D endMap)
{
MinHeap<PathFinderNode> minSpanTreeCost = new MinHeap<PathFinderNode>(256);
PathFinderNode[,] pathFinderMap = new PathFinderNode[gameLocalMap.Model.MapSizeX, gameLocalMap.Model.MapSizeY];
PathFinderNode pathFinderStart = new PathFinderNode(startMap) {Cost = 0};
PathFinderNode pathFinderEnd = new PathFinderNode(endMap);
pathFinderMap[pathFinderStart.Position.X, pathFinderStart.Position.Y] = pathFinderStart;
minSpanTreeCost.Add(pathFinderStart);
while (minSpanTreeCost.Count > 0)
{
pathFinderStart = minSpanTreeCost.ExtractFirst();
pathFinderStart.InClosed = true;
for (int index = 0; (whatIsDiag ? (index < DiagMovePoints.Length ? 1 : 0) : (index < NoDiagMovePoints.Length ? 1 : 0)) != 0; index++)
{
Vector2D realEndPosition = pathFinderStart.Position + (whatIsDiag ? DiagMovePoints[index] : NoDiagMovePoints[index]);
bool isEndOfPath = (realEndPosition.X == endMap.X) && (realEndPosition.Y == endMap.Y);
if (gameLocalMap.IsValidStep(roomUserable, new Vector2D(pathFinderStart.Position.X, pathFinderStart.Position.Y), realEndPosition, isEndOfPath, roomUserable.AllowOverride))
{
PathFinderNode pathFinderSecondNodeCalculation;
if (pathFinderMap[realEndPosition.X, realEndPosition.Y] == null)
{
pathFinderSecondNodeCalculation = new PathFinderNode(realEndPosition);
pathFinderMap[realEndPosition.X, realEndPosition.Y] = pathFinderSecondNodeCalculation;
}
else
pathFinderSecondNodeCalculation = pathFinderMap[realEndPosition.X, realEndPosition.Y];
if (!pathFinderSecondNodeCalculation.InClosed)
{
int internalSpanTreeCost = 0;
if (pathFinderStart.Position.X != pathFinderSecondNodeCalculation.Position.X)
internalSpanTreeCost++;
if (pathFinderStart.Position.Y != pathFinderSecondNodeCalculation.Position.Y)
internalSpanTreeCost++;
int loopTotalCost = pathFinderStart.Cost + internalSpanTreeCost + pathFinderSecondNodeCalculation.Position.GetDistanceSquared(endMap);
if (loopTotalCost < pathFinderSecondNodeCalculation.Cost)
{
pathFinderSecondNodeCalculation.Cost = loopTotalCost;
pathFinderSecondNodeCalculation.Next = pathFinderStart;
}
if (!pathFinderSecondNodeCalculation.InOpen)
{
if (pathFinderSecondNodeCalculation.Equals(pathFinderEnd))
{
pathFinderSecondNodeCalculation.Next = pathFinderStart;
return pathFinderSecondNodeCalculation;
}
pathFinderSecondNodeCalculation.InOpen = true;
minSpanTreeCost.Add(pathFinderSecondNodeCalculation);
}
}
}
}
}
return null;
}
internal void UserSetPositionData(RoomUser roomUsers, Vector2D nextStep)
{
// Check if the User is in a Horse or Not..
if (roomUsers.RidingHorse && !roomUsers.IsPet)
{
RoomUser horseRidingPet = GetRoomUserByVirtualId(Convert.ToInt32(roomUsers.HorseId));
// If exists a Horse and is Ridding.. Let's Create data for they..
if (horseRidingPet != null)
{
roomUsers.RotBody = horseRidingPet.RotBody;
roomUsers.RotHead = horseRidingPet.RotHead;
roomUsers.SetStep = true;
roomUsers.SetX = nextStep.X;
roomUsers.SetY = nextStep.Y;
roomUsers.SetZ = _userRoom.GetGameMap().SqAbsoluteHeight(nextStep.X, nextStep.Y) + 1;
horseRidingPet.SetX = roomUsers.SetX;
horseRidingPet.SetY = roomUsers.SetY;
horseRidingPet.SetZ = _userRoom.GetGameMap().SqAbsoluteHeight(roomUsers.SetX, roomUsers.SetY);
}
}
else
{
// Is a Normal User, Let's Create Data for They.
roomUsers.RotBody = Rotation.Calculate(roomUsers.X, roomUsers.Y, nextStep.X, nextStep.Y,
roomUsers.IsMoonwalking);
roomUsers.RotHead = Rotation.Calculate(roomUsers.X, roomUsers.Y, nextStep.X, nextStep.Y,
roomUsers.IsMoonwalking);
roomUsers.SetStep = true;
roomUsers.SetX = nextStep.X;
roomUsers.SetY = nextStep.Y;
roomUsers.SetZ = _userRoom.GetGameMap().SqAbsoluteHeight(nextStep.X, nextStep.Y);
}
}
/// <summary>
/// Determines whether [is valid step3] [the specified user].
/// </summary>
/// <param name="user">The user.</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
/// <param name="endOfPath">if set to <c>true</c> [end of path].</param>
/// <param name="Override">if set to <c>true</c> [override].</param>
/// <param name="client">The client.</param>
/// <returns><c>true</c> if [is valid step3] [the specified user]; otherwise, <c>false</c>.</returns>
internal bool IsValidStep3(RoomUser user, Vector2D @from, Vector2D to, bool endOfPath, bool Override,
GameClient client)
{
if (user == null)
return false;
Point square = new Point(to.X, to.Y);
if (GuildGates.ContainsKey(square) && user.GetClient() != null && user.GetClient().GetHabbo() != null &&
user.GetClient().GetHabbo().UserGroups != null)
{
RoomItem roomItem = GuildGates[square];
uint guildId = roomItem.GroupId;
if (guildId > 0 &&
user.GetClient().GetHabbo().UserGroups.Any(member => member != null && member.GroupId == guildId))
{
roomItem.ExtraData = "1";
roomItem.UpdateState();
return true;
}
}
if (!ValidTile(to.X, to.Y))
return false;
if (Override)
return true;
if ((GameMap[to.X, to.Y] == 3 && !endOfPath) || GameMap[to.X, to.Y] == 0 ||
(GameMap[to.X, to.Y] == 2 && !endOfPath))
{
user.Path.Clear();
user.PathRecalcNeeded = false;
return false;
}
RoomUser userRoom = _room.GetRoomUserManager().GetUserForSquare(to.X, to.Y);
if (userRoom != null && !userRoom.IsWalking && endOfPath)
return false;
return SqAbsoluteHeight(to.X, to.Y) - SqAbsoluteHeight(@from.X, @from.Y) <= 1.5;
}
/// <summary>
/// Determines whether [is valid step] [the specified user].
/// </summary>
/// <param name="user">The user.</param>
/// <param name="from">From.</param>
/// <param name="to">To.</param>
/// <param name="endOfPath">if set to <c>true</c> [end of path].</param>
/// <param name="Override">if set to <c>true</c> [override].</param>
/// <returns><c>true</c> if [is valid step] [the specified user]; otherwise, <c>false</c>.</returns>
internal bool IsValidStep(RoomUser user, Vector2D @from, Vector2D to, bool endOfPath, bool Override)
{
if (user == null)
return false;
Point square = new Point(to.X, to.Y);
if (user.IsBot == false && user.GetClient() != null)
{
if (GuildGates.ContainsKey(square))
{
uint guildId = GuildGates[square].GroupId;
if (guildId > 0 &&
user.GetClient()
.GetHabbo()
.UserGroups.Any(member => member != null && member.GroupId == guildId)) return true;
}
}
if (!ValidTile(to.X, to.Y))
return false;
if (Override)
return true;
if (GameMap[to.X, to.Y] == 3 && !endOfPath || GameMap[to.X, to.Y] == 0 ||
GameMap[to.X, to.Y] == 2 && !endOfPath)
return false;
RoomUser userForSquare = _room.GetRoomUserManager().GetUserForSquare(to.X, to.Y);
if (userForSquare != null && endOfPath && !_room.RoomData.AllowWalkThrough)
{
user.HasPathBlocked = true;
user.Path.Clear();
user.IsWalking = false;
user.RemoveStatus("mv");
_room.GetRoomUserManager().UpdateUserStatus(user, false);
if (!user.RidingHorse || user.IsPet || user.IsBot)
return true;
RoomUser roomUserByVirtualId =
_room.GetRoomUserManager().GetRoomUserByVirtualId(Convert.ToInt32(user.HorseId));
ServerMessage message = new ServerMessage(LibraryParser.OutgoingRequest("UpdateUserStatusMessageComposer"));
message.AppendInteger(1);
if (roomUserByVirtualId != null)
{
roomUserByVirtualId.IsWalking = false;
roomUserByVirtualId.ClearMovement();
roomUserByVirtualId.RemoveStatus("mv");
roomUserByVirtualId.SerializeStatus(message, "");
}
user.GetClient().GetHabbo().CurrentRoom.SendMessage(message);
}
else if (userForSquare != null && !_room.RoomData.AllowWalkThrough && !userForSquare.IsWalking)
return false;
return SqAbsoluteHeight(to.X, to.Y) - SqAbsoluteHeight(@from.X, @from.Y) <= 1.5;
}
