public void AddPacketList(Client client, PacketList packetList)
{
foreach (TcpPacket packet in packetList.Packets)
{
AddPacket(client, packet);
}
}
public void AddPacket(Client client, TcpPacket packet, bool skipCaching)
{
if (client != null && packet != null)
{
if (!cachingEnabled || skipCaching)
{
// Caching is disabled, add directly to the client's packetlist
lock (lockObject)
{
int index = HitList.IndexOfKey(client);
PacketList packetList = null;
if (index == -1)
{
packetList = new PacketList();
HitList.Add(client, packetList);
}
else
{
packetList = HitList.ValueByIndex(index);
}
packetList.AddPacket(packet);
}
}
else
{
// Caching is enabled, add to the cache
hitListCache.AddCacheItem(new object[] { PacketHitListTargets.Client, client, packet });
}
}
}
public void AddPacketList(Client client, PacketList packetList)
{
foreach (TcpPacket packet in packetList.Packets) {
AddPacket(client, packet);
}
}
public void AddPacket(Client client, TcpPacket packet, bool skipCaching)
{
if (client != null && packet != null) {
if (!cachingEnabled || skipCaching) {
// Caching is disabled, add directly to the client's packetlist
lock (lockObject) {
int index = HitList.IndexOfKey(client);
PacketList packetList = null;
if (index == -1) {
packetList = new PacketList();
HitList.Add(client, packetList);
} else {
packetList = HitList.ValueByIndex(index);
}
packetList.AddPacket(packet);
}
} else {
// Caching is enabled, add to the cache
hitListCache.AddCacheItem(new object[] { PacketHitListTargets.Client, client, packet });
}
}
}
public static void AppendPlayerDir(Client client, PacketList packetList)
{
packetList.AddPacket(CreatePlayerDir(client));
}
public static void SendDataTo(Client client, PacketList packetList)
{
SendDataTo(client, packetList.CombinePackets(), false, false, true);
}
internal static void ProcessMovement(Client client, Enums.Direction direction, Enums.Speed speed, bool critical)
{
PacketHitList hitlist = null;
PacketHitList.MethodStart(ref hitlist);
try {
Player player = client.Player;
IMap map = player.GetCurrentMap();
map.ProcessingPaused = false;
int X = player.X;
int Y = player.Y;
if (!NetworkManager.IsPlaying(client)) {
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (Ranks.IsDisallowed(client, Enums.Rank.Moniter) || client.Player.ProtectionOff) {
player.Hunted = true;
PacketBuilder.AppendHunted(client, hitlist);
}
PacketList packetListToOthers = new PacketList();
#region Mobility Checking
if (player.MovementLocked) {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (player.LoadingStory) {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (player.Dead) {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (player.GetActiveRecruit().StatusAilment == Enums.StatusAilment.Freeze || player.GetActiveRecruit().StatusAilment == Enums.StatusAilment.Sleep) {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
player.Direction = direction;
PacketBuilder.AppendPlayerDir(client, packetListToOthers);
//PacketBuilder.AppendPlayerDirExcept(client, hitlist);
//if (player.GetActiveRecruit().StatusAilment == Enums.StatusAilment.Paralyze && speed > Enums.Speed.Walking) {
// PacketBuilder.AppendOwnXY(client, hitlist);
// PacketHitList.MethodEnded(ref hitlist);
// return;
//}
if (player.SpeedLimit < speed && player.Map.Tile[player.X, player.Y].Type != Enums.TileType.Slippery) {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (player.Map.Tile[player.X, player.Y].Type == Enums.TileType.Slow && (Enums.Speed)player.Map.Tile[player.X, player.Y].Data2 > speed) {
int mobilityList = map.Tile[player.X, player.Y].Data1;
for (int i = 0; i < 16; i++) {
if (mobilityList % 2 == 1 && !client.Player.GetActiveRecruit().Mobility[i]) {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
mobilityList /= 2;
}
}
#endregion Mobility Checking
#region X/Y Checking
if (map.MaxX <= 0)
map.MaxX = 19;
if (map.MaxY <= 0)
map.MaxY = 14;
if (player.X > map.MaxX) {
player.X = map.MaxX;
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (player.Y > map.MaxY) {
player.Y = map.MaxY;
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (player.X < 0) {
player.X = 0;
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (player.Y < 0) {
player.Y = 0;
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
#endregion
#region Block Checking
switch (direction) {
case Enums.Direction.Up:
if (player.Y > 0) {
if (IsBlocked(client, map, player.X, player.Y - 1) == false) {
if (map.Tile[player.X, player.Y - 1].Type != Enums.TileType.Key && map.Tile[player.X, player.Y - 1].Type != Enums.TileType.Door) {
player.Y -= 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (map.Tile[player.X, player.Y - 1].DoorOpen == true) {
player.Y -= 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
} else {
if (SeamlessWorldHelper.IsMapSeamless(map, Enums.MapID.Up)) {
SeamlessWorldHelper.SwitchSeamlessMaps(client, map.Up, player.X, Constants.MAX_MAP_Y);
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
} else if (map.Up > 0) {
Messenger.PlayerWarp(client, map.Up, player.X, Constants.MAX_MAP_Y);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
break;
case Enums.Direction.Down:
if (player.Y < map.MaxY) {
if (IsBlocked(client, map, player.X, player.Y + 1) == false) {
if (map.Tile[player.X, player.Y + 1].Type != Enums.TileType.Key && map.Tile[player.X, player.Y + 1].Type != Enums.TileType.Door) {
player.Y += 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (map.Tile[player.X, player.Y + 1].DoorOpen == true) {
player.Y += 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
} else {
if (SeamlessWorldHelper.IsMapSeamless(map, Enums.MapID.Down)) {
SeamlessWorldHelper.SwitchSeamlessMaps(client, map.Down, player.X, 0);
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
} else if (map.Down > 0) {
Messenger.PlayerWarp(client, map.Down, player.X, 0);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
break;
case Enums.Direction.Left:
if (player.X > 0) {
if (IsBlocked(client, map, player.X - 1, player.Y) == false) {
if (map.Tile[player.X - 1, player.Y].Type != Enums.TileType.Key && map.Tile[player.X - 1, player.Y].Type != Enums.TileType.Door) {
player.X -= 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (map.Tile[player.X - 1, player.Y].DoorOpen == true) {
player.X -= 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
} else {
if (SeamlessWorldHelper.IsMapSeamless(map, Enums.MapID.Left)) {
SeamlessWorldHelper.SwitchSeamlessMaps(client, map.Left, Constants.MAX_MAP_X, player.Y);
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
} else if (map.Left > 0) {
Messenger.PlayerWarp(client, map.Left, Constants.MAX_MAP_X, player.Y);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
break;
case Enums.Direction.Right:
if (player.X < map.MaxX) {
if (IsBlocked(client, map, player.X + 1, player.Y) == false) {
if (map.Tile[player.X + 1, player.Y].Type != Enums.TileType.Key && map.Tile[player.X + 1, player.Y].Type != Enums.TileType.Door) {
player.X += 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (map.Tile[player.X + 1, player.Y].DoorOpen == true) {
player.X += 1;
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
} else {
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketBuilder.AppendOwnXY(client, hitlist);
PacketHitList.MethodEnded(ref hitlist);
return;
}
} else {
if (SeamlessWorldHelper.IsMapSeamless(map, Enums.MapID.Right)) {
SeamlessWorldHelper.SwitchSeamlessMaps(client, map.Right, 0, player.Y);
PacketBuilder.AppendPlayerMove(client, hitlist, direction, speed);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
} else if (map.Right > 0) {
Messenger.PlayerWarp(client, map.Right, 0, player.Y);
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
break;
}
#endregion
player.RefreshSeenCharacters(hitlist);
#region More Collision Checking
//if (map.Tile[player.X, player.Y].Players.Players == null) {
// map.Tile[player.X, player.Y].Players.Players = new List<string>();
//}
//if (map.Tile[player.X, player.Y].Players.Players.Contains(client.Player.CharID) == false) {
// map.Tile[player.X, player.Y].Players.PlayerCount += 1;
// map.Tile[player.X, player.Y].Players.Players.Add(client.Player.CharID);
//}
//if (map.Tile[player.X, player.Y].Players.PlayerCount > 1) {
// map.Tile[player.X, player.Y].Players.LastPlayer = map.Tile[player.X, player.Y].Players.Players[map.Tile[player.X, player.Y].Players.Players.Count - 2];
// map.Tile[player.X, player.Y].Players.HasPlayer = true;
// PlayerCollide(client, map.Tile[player.X, player.Y].Players);
//}
//if (map.Tile[player.X, player.Y].Players.Players.Count == 1) {
// map.Tile[player.X, player.Y].Players.LastPlayer = "";
//}
{
Client lastCollision = null;
int collisionCounter = 0;
foreach (Client i in map.GetClients()) {
if (i != client) {
if (i.Player.X == client.Player.X && i.Player.Y == client.Player.Y) {
lastCollision = i;
collisionCounter++;
}
}
}
if (lastCollision != null) {
PlayerCollide(client, lastCollision, collisionCounter);
}
}
#endregion
Scripting.ScriptManager.InvokeSub("OnStep", map, client.Player.GetActiveRecruit(), speed, hitlist);
// Trigger event checking
for (int i = 0; i < player.TriggerEvents.Count; i++) {
switch (player.TriggerEvents[i].Trigger) {
case Events.Player.TriggerEvents.TriggerEventTrigger.SteppedOnTile: {
if (player.TriggerEvents[i].CanInvokeTrigger()) {
player.TriggerEvents[i].InvokeTrigger();
}
}
break;
case Events.Player.TriggerEvents.TriggerEventTrigger.StepCounter: {
((Events.Player.TriggerEvents.StepCounterTriggerEvent)player.TriggerEvents[i]).StepsCounted++;
if (player.TriggerEvents[i].CanInvokeTrigger()) {
player.TriggerEvents[i].InvokeTrigger();
}
}
break;
}
}
#region Tile Checks
//healing tiles code
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Heal) {
//if (!player.PK) {
player.SetHP(player.GetMaxHP());
hitlist.AddPacket(client, PacketBuilder.CreateBattleMsg("The entire team was fully healed!", Text.BrightGreen));
//} else {
// hitlist.AddPacket(client, PacketBuilder.CreateBattleMsg("Outlaws can't use healing tiles!", Text.BrightRed));
//}
PacketHitList.MethodEnded(ref hitlist);
return;
}
//Check for kill tile, and if so kill them
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Kill) {
player.SetHP(0);
Messenger.PlayerMsg(client, "You have fainted!", Text.BrightRed);
Scripting.ScriptManager.InvokeSub("OnDeath", client, Enums.KillType.Tile);
player.SetHP(player.GetMaxHP());
PacketHitList.MethodEnded(ref hitlist);
return;
}
//check for doors
if (player.X + 1 <= map.MaxX) {
if (map.Tile[player.X + 1, player.Y].Type == Enums.TileType.Door) {
X += 1;
Y = player.Y;
if (map.Tile[X, Y].DoorOpen == false) {
map.Tile[X, Y].DoorOpen = true;
map.Tile[X, Y].DoorTimer = Core.GetTickCount();
hitlist.AddPacketToMap(map, TcpPacket.CreatePacket("mapkey", X.ToString(), Y.ToString(), "1"));
hitlist.AddPacketToMap(map, PacketBuilder.CreateSoundPacket("door.wav"));
}
}
}
if (player.X - 1 <= map.MaxX && player.X - 1 > -1) {
if (map.Tile[player.X - 1, player.Y].Type == Enums.TileType.Door) {
X -= 1;
Y = player.Y;
if (map.Tile[X, Y].DoorOpen == false) {
map.Tile[X, Y].DoorOpen = true;
map.Tile[X, Y].DoorTimer = Core.GetTickCount();
hitlist.AddPacketToMap(map, TcpPacket.CreatePacket("mapkey", X.ToString(), Y.ToString(), "1"));
hitlist.AddPacketToMap(map, PacketBuilder.CreateSoundPacket("door.wav"));
}
}
}
if (player.Y - 1 <= map.MaxY && player.Y - 1 > -1) {
if (map.Tile[player.X, player.Y - 1].Type == Enums.TileType.Door) {
X = player.X;
Y -= 1;
if (map.Tile[X, Y].DoorOpen == false) {
map.Tile[X, Y].DoorOpen = true;
map.Tile[X, Y].DoorTimer = Core.GetTickCount();
hitlist.AddPacketToMap(map, TcpPacket.CreatePacket("mapkey", X.ToString(), Y.ToString(), "1"));
hitlist.AddPacketToMap(map, PacketBuilder.CreateSoundPacket("door.wav"));
}
}
}
if (player.Y + 1 <= map.MaxY) {
if (map.Tile[player.X, player.Y + 1].Type == Enums.TileType.Door) {
X = player.X;
Y += 1;
if (map.Tile[X, Y].DoorOpen == false) {
map.Tile[X, Y].DoorOpen = true;
map.Tile[X, Y].DoorTimer = Core.GetTickCount();
hitlist.AddPacketToMap(map, TcpPacket.CreatePacket("mapkey", X.ToString(), Y.ToString(), "1"));
hitlist.AddPacketToMap(map, PacketBuilder.CreateSoundPacket("door.wav"));
}
}
}
// Check to see if the tile is a warp tile, and if so warp them
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Warp) {
int mapNum = map.Tile[player.X, player.Y].Data1;
X = map.Tile[player.X, player.Y].Data2;
Y = map.Tile[player.X, player.Y].Data3;
bool xyWarp = false;
if (player.Map.MapType == Enums.MapType.Standard) {
if (((Map)player.Map).MapNum == mapNum) {
xyWarp = true;
}
} else if (player.Map.MapType == Enums.MapType.Instanced) {
if (((InstancedMap)player.Map).MapBase == mapNum) {
xyWarp = true;
}
}
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
if (xyWarp) {
Messenger.PlayerXYWarp(client, X, Y);
} else {
Messenger.PlayerWarp(client, mapNum, X, Y);
}
return;
}
// Check for key trigger open
if (map.Tile[player.X, player.Y].Type == Enums.TileType.KeyOpen) {
X = map.Tile[player.X, player.Y].Data1;
Y = map.Tile[player.X, player.Y].Data2;
if (map.Tile[X, Y].Type == Enums.TileType.Key & map.Tile[X, Y].DoorOpen == false) {
map.Tile[X, Y].DoorOpen = true;
map.Tile[X, Y].DoorTimer = Core.GetTickCount();
hitlist.AddPacketToMap(map, TcpPacket.CreatePacket("mapkey", X.ToString(), Y.ToString(), "1"));
if (map.Tile[player.X, player.Y].String1.Trim() == "") {
hitlist.AddPacketToMap(map, PacketBuilder.CreateBattleMsg("A path was opened!", Text.White));
} else {
hitlist.AddPacketToMap(map, PacketBuilder.CreateBattleMsg(map.Tile[player.X, player.Y].String1.Trim(), Text.White));
}
hitlist.AddPacketToMap(map, PacketBuilder.CreateSoundPacket("key.wav"));
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
// Check for shop
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Shop) {
if (map.Tile[player.X, player.Y].Data1 > 0) {
Messenger.SendShopMenu(client, map.Tile[player.X, player.Y].Data1);
} else {
Messenger.PlayerMsg(client, "There is no shop here.", Text.BrightRed);
}
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
// Check for guild shop
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Guild) {
if (client.Player.GuildAccess > 0) {
//manage or view guild
Messenger.SendGuildMenu(client);
} else {
//register guild
if (client.Player.ExplorerRank >= Guilds.GuildManager.MIN_RANK) {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("Guilds can be created for " + Guilds.GuildManager.CREATE_PRICE + " " + Items.ItemManager.Items[1].Name + " per founder.", Text.Yellow));
Messenger.SendGuildCreation(client);
} else {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("Register a guild here. You can create a guild when your explorer rank is " + Guilds.GuildManager.MIN_RANK + " or higher.", Text.Green));
}
}
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
// Check for Link Shop
if (map.Tile[player.X, player.Y].Type == Enums.TileType.LinkShop) {
int priceItem = map.Tile[player.X, player.Y].Data1;
int priceAmount = map.Tile[player.X, player.Y].Data2;
bool earlierEvo = (map.Tile[player.X, player.Y].Data3 == 1);
Messenger.SendRecallMenu(client, earlierEvo);
if (priceItem > 0) {
if (Items.ItemManager.Items[priceItem].StackCap <= 0 && Items.ItemManager.Items[priceItem].Type != Enums.ItemType.Currency) {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("Moves will be taught in exchange for a " + Items.ItemManager.Items[priceItem].Name + ".", Text.Yellow));
} else if (priceAmount > 0) {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("Moves will be taught in exchange for " + priceAmount + " " + Items.ItemManager.Items[priceItem].Name + ".", Text.Yellow));
}
}
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
// Check if player stepped on sprite changing tile
if (map.Tile[player.X, player.Y].Type == Enums.TileType.SpriteChange) {
if (player.GetActiveRecruit().Sprite == map.Tile[player.X, player.Y].Data1) {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You already have this sprite!", Text.BrightRed));
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
} else {
if (map.Tile[player.X, player.Y].Data2 == 0) {
hitlist.AddPacket(client, TcpPacket.CreatePacket("spritechange", "0"));
} else {
if (ItemManager.Items[map.Tile[player.X, player.Y].Data2].Type == Enums.ItemType.Currency) {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("This sprite will cost you " + map.Tile[player.X, player.Y].Data3 + " " + ItemManager.Items[map.Tile[player.X, player.Y].Data2].Name.Trim() + "!", Text.Yellow));
} else {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("This sprite will cost you a " + ItemManager.Items[map.Tile[player.X, player.Y].Data2].Name.Trim() + "!", Text.Yellow));
}
hitlist.AddPacket(client, TcpPacket.CreatePacket("spritechange", "1"));
}
}
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
// Check if player stepped on notice tile
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Notice) {
if (map.Tile[player.X, player.Y].String1.Trim() != "") {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg(map.Tile[player.X, player.Y].String1.Trim(), Text.Black));
}
if (map.Tile[player.X, player.Y].String2.Trim() != "") {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg(map.Tile[player.X, player.Y].String2.Trim(), Text.Grey));
}
hitlist.AddPacketToMap(map, TcpPacket.CreatePacket("sound", map.Tile[player.X, player.Y].String3));
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
}
// Check if player stepped on sound tile
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Sound) {
hitlist.AddPacketToMap(map, TcpPacket.CreatePacket("sound", map.Tile[player.X, player.Y].String1));
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
}
PacketHitList.MethodEnded(ref hitlist);
return;
}
//Check if player stepped on a scripted tile
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Scripted) {
Scripting.ScriptManager.InvokeSub("ScriptedTile", map, client.Player.GetActiveRecruit(), map.Tile[player.X, player.Y].Data1, map.Tile[player.X, player.Y].String1, map.Tile[player.X, player.Y].String2, map.Tile[player.X, player.Y].String3, hitlist);
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
// Check if player stepped on Bank tile
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Bank) {
Messenger.OpenBank(client);
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Assembly) {
Messenger.SendAllRecruits(client);
Messenger.OpenAssembly(client);
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Evolution) {
EvolutionManager.StartEvolution(player);
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (map.Tile[player.X, player.Y].Type == Enums.TileType.Story) {
StoryManager.PlayStory(client, map.Tile[player.X, player.Y].Data1);
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (map.Tile[player.X, player.Y].Type == Enums.TileType.MissionBoard) {
Messenger.OpenMissionBoard(client);
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
if (map.Tile[player.X, player.Y].Type == Enums.TileType.RDungeonGoal) {
if (client.Player.PartyID == null) {
RDungeonMap rmap = map as RDungeonMap;
if (rmap != null) {
RDungeon dungeon = RDungeonManager.RDungeons[rmap.RDungeonIndex];
int floor = rmap.RDungeonFloor;
if (dungeon.Floors[floor].GoalType == Enums.RFloorGoalType.NextFloor) {
if (floor + 1 < dungeon.Floors.Count) {
player.WarpToRDungeon(rmap.RDungeonIndex, floor + 1);
} else {
//client.Player.dungeonIndex = -1;
//client.Player.dungeonFloor = -1;
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You have completed the dungeon!", Text.Yellow));
Messenger.PlayerWarp(client, Settings.Crossroads, Settings.StartX, Settings.StartY);
}
} else if (dungeon.Floors[floor].GoalType == Enums.RFloorGoalType.Map) {
//client.Player.dungeonIndex = -1;
//client.Player.dungeonFloor = -1;
Messenger.PlayerWarp(client, dungeon.Floors[floor].GoalMap, dungeon.Floors[floor].GoalX, dungeon.Floors[floor].GoalY);
} else {
Scripting.ScriptManager.InvokeSub("RDungeonScriptGoal", client, dungeon.Floors[floor].GoalMap, dungeon.Floors[floor].GoalX, dungeon.Floors[floor].GoalY);
}
}
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
} else {
bool warp = true;
Party party = PartyManager.FindPlayerParty(client);
IMap sourceMap = client.Player.Map;
foreach (Client member in party.GetOnlineMemberClients()) {
if (/*!member.Player.Dead && */member.Player.MapID == client.Player.MapID && (member.Player.X != client.Player.X || member.Player.Y != client.Player.Y)) {
warp = false;
}
}
if (warp) {
RDungeonMap rmap = map as RDungeonMap;
foreach (Client member in party.GetOnlineMemberClients()) {
if (member.Player.Map != sourceMap) continue;
if (rmap != null) {
RDungeon dungeon = RDungeonManager.RDungeons[rmap.RDungeonIndex];
int floor = rmap.RDungeonFloor;
if (dungeon.Floors[floor].GoalType == Enums.RFloorGoalType.NextFloor) {
if (floor + 1 < dungeon.Floors.Count) {
member.Player.WarpToRDungeon(rmap.RDungeonIndex, floor + 1);
} else {
//client.Player.dungeonIndex = -1;
//client.Player.dungeonFloor = -1;
hitlist.AddPacket(member, PacketBuilder.CreateChatMsg("You have completed the dungeon!", Text.Yellow));
Messenger.PlayerWarp(member, Settings.Crossroads, Settings.StartX, Settings.StartY);
}
} else if (dungeon.Floors[floor].GoalType == Enums.RFloorGoalType.Map) {
//client.Player.dungeonIndex = -1;
//client.Player.dungeonFloor = -1;
Messenger.PlayerWarp(member, dungeon.Floors[floor].GoalMap, dungeon.Floors[floor].GoalX, dungeon.Floors[floor].GoalY);
} else {
//client.Player.dungeonIndex = -1;
//client.Player.dungeonFloor = -1;
Scripting.ScriptManager.InvokeSub("RDungeonScriptGoal", member, dungeon.Floors[floor].GoalMap, dungeon.Floors[floor].GoalX, dungeon.Floors[floor].GoalY);
}
}
}
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
} else {
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("All surviving players on the floor must be on the goal in order to continue.", Text.WhiteSmoke));
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketHitList.MethodEnded(ref hitlist);
return;
}
}
}
for (int i = client.Player.ActiveGoalPoints.Count - 1; i >= 0; i--) {
bool missionComplete = false;
if (player.X == client.Player.ActiveGoalPoints[i].GoalX && player.Y == client.Player.ActiveGoalPoints[i].GoalY) {
switch (player.JobList.JobList[client.Player.ActiveGoalPoints[i].JobListIndex].Mission.MissionType) {
case Enums.MissionType.Rescue: {
missionComplete = true;
}
break;
case Enums.MissionType.ItemRetrieval: {
int itemVal = player.HasItem(player.JobList.JobList[client.Player.ActiveGoalPoints[i].JobListIndex].Mission.Data1);
if (itemVal > 0) {
player.TakeItem(player.JobList.JobList[client.Player.ActiveGoalPoints[i].JobListIndex].Mission.Data1, 1);
missionComplete = true;
} else {
missionComplete = false;
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You've reached the target Pokémon! But you don't have the requested item...", Text.Grey));
}
//else {
// missionComplete = false;
// hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You don't have enough " + ItemManager.Items[player.ActiveMission.WonderMail.Data1].Name + "!", Text.BrightRed));
//}
}
break;
case Enums.MissionType.Escort: {
if (player.IsInTeam(-2 - client.Player.ActiveGoalPoints[i].JobListIndex)) {
player.RemoveFromTeam(player.FindTeamSlot(-2 - client.Player.ActiveGoalPoints[i].JobListIndex));
missionComplete = true;
} else {
missionComplete = false;
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You've reached the target Pokémon! But you don't have the escort with you...", Text.Grey));
}
}
break;
}
}
if (missionComplete) {
client.Player.HandleMissionComplete(client.Player.ActiveGoalPoints[i].JobListIndex);
client.Player.ActiveGoalPoints.RemoveAt(i);
break;
}
}
//if (player.ActiveMission != null) {
// if (Generator.IsGoalMap(player.ActiveMission.WonderMail, map) && player.X == player.ActiveMission.GoalX && player.Y == player.ActiveMission.GoalY) {
// bool missionComplete = false;
// switch (player.ActiveMission.WonderMail.MissionType) {
// case Enums.MissionType.Rescue: {
// missionComplete = true;
// }
// break;
// case Enums.MissionType.ItemRetrieval: {
// int itemVal = player.HasItem(player.ActiveMission.WonderMail.Data1);
// if (itemVal > 0 && itemVal >= player.ActiveMission.WonderMail.Data2) {
// player.TakeItem(player.ActiveMission.WonderMail.Data2, player.ActiveMission.WonderMail.Data2);
// missionComplete = true;
// } else {
// missionComplete = false;
// hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You don't have enough " + ItemManager.Items[player.ActiveMission.WonderMail.Data1].Name + "!", Text.BrightRed));
// }
// }
// break;
// case Enums.MissionType.Escort: {
// if (player.IsInTeam(-2)) {
// player.RemoveFromTeam(player.FindTeamSlot(-2), false);
// missionComplete = true;
// } else {
// missionComplete = false;
// }
// }
// break;
// }
// if (missionComplete) {
// client.Player.HandleMissionComplete();
// }
// PacketHitList.MethodEnded(ref hitlist);
// return;
// }
//} else if (Program.ClassMan.mMissions.mMissions[player.mActiveMission].MissionType == Enums.MissionType.ItemRetrieval) {
// if (mapNum == Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data1 && player.mX == Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data2 && player.mY == Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data3) {
// int itemVal = player.HasItem(Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data4);
// if (itemVal > 0 && itemVal >= Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data5) {
// player.TakeItem(Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data4, Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data5);
// if (Program.ClassMan.mMissions.mMissions[player.mActiveMission].EndStory != 0) {
// Program.ClassMan.mStories.PlayStory(client, Program.ClassMan.mMissions.mMissions[player.mActiveMission].EndStory - 1);
// } else {
// Messenger.PlayerMsg(client, "You have completed the mission!", Text.Yellow);
// }
// if (player.mMissions.ContainsKey(player.mActiveMission)) {
// player.mMissions[player.mActiveMission] = true;
// } else {
// player.mMissions.Add(player.mActiveMission, true);
// }
// CXmlAttributes attrib = new CXmlAttributes();
// attrib.Add("completed", "True");
// player.mMissionsXML.SaveNode("mission" + player.mActiveMission, "MissionData", attrib);
// if (Program.ClassMan.mMissions.mMissions[player.mActiveMission].RewardItem != 0) {
// player.GiveItem(Program.ClassMan.mMissions.mMissions[player.mActiveMission].RewardItem, Program.ClassMan.mMissions.mMissions[player.mActiveMission].RewardCount);
// }
// if (Globals.Scripting == true) {
// Program.ClassMan.mScripts.InvokeSub("OnMissionComplete", client, player.mActiveMission);
// }
// player.mActiveMission = -1;
// Messenger.SendDataTo(client, "MISSIONCOMPLETE" + TcpManager.SEP_CHAR + TcpManager.END_CHAR);
// } else {
// Messenger.PlayerMsg(client, "You dont have enough " + ItemManager.Items[Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data4].Name.Trim() + "!", Text.BrightRed);
// }
// }
//}
// } else if (Program.ClassMan.mMissions.mMissions[player.mActiveMission].MissionType == Enums.MissionType.Escort) {
// if (mapNum == Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data1 && player.mX == Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data2 && player.mY == Program.ClassMan.mMissions.mMissions[player.mActiveMission].Data3) {
// if (player.IsInTeam(-2)) {
// if (Program.ClassMan.mMissions.mMissions[player.mActiveMission].EndStory != 0) {
// Program.ClassMan.mStories.PlayStory(client, Program.ClassMan.mMissions.mMissions[player.mActiveMission].EndStory - 1);
// } else {
// Messenger.PlayerMsg(client, "You have completed the mission!", Text.Yellow);
// }
// if (player.mMissions.ContainsKey(player.mActiveMission)) {
// player.mMissions[player.mActiveMission] = true;
// } else {
// player.mMissions.Add(player.mActiveMission, true);
// }
// CXmlAttributes attrib = new CXmlAttributes();
// attrib.Add("completed", "True");
// player.mMissionsXML.SaveNode("mission" + player.mActiveMission, "MissionData", attrib);
// if (Program.ClassMan.mMissions.mMissions[player.mActiveMission].RewardItem != 0) {
// player.GiveItem(Program.ClassMan.mMissions.mMissions[player.mActiveMission].RewardItem, Program.ClassMan.mMissions.mMissions[player.mActiveMission].RewardCount);
// }
// if (Globals.Scripting == true) {
// Program.ClassMan.mScripts.InvokeSub("OnMissionComplete", client, player.mActiveMission);
// }
// player.mActiveMission = -1;
// Messenger.SendDataTo(client, "MISSIONCOMPLETE" + TcpManager.SEP_CHAR + TcpManager.END_CHAR);
// player.RemoveFromTeam(player.FindTeamSlot(-2));
// }
// }
// }
//}
//}
#endregion
if (critical) {
PacketBuilder.AppendPlayerLock(client, hitlist, false);
PacketBuilder.AppendOwnXY(client, hitlist);
}
} catch (Exception ex) {
Exceptions.ErrorLogger.WriteToErrorLog(ex, "Player movement processing, Index: " + client.Player.CharID + " Direction: " + direction.ToString() + " Speed: " + speed.ToString() + " Map: " + client.Player.MapID + " X: " + client.Player.X.ToString() + " Y: " + client.Player.Y.ToString());
}
PacketHitList.MethodEnded(ref hitlist);
}
