public static bool VerifyKeyTile(Client client, IMap map, int x, int y, PacketHitList packetList)
{
PacketHitList.MethodStart(ref packetList);
bool unlocked = false;
Tile mapTile = map.Tile[x, y];
if (mapTile.Type == Server.Enums.TileType.Scripted)
{
if (mapTile.Data1 == 58)
{
int chargeLevel = mapTile.String1.ToInt();
exPlayer exPlayer = exPlayer.Get(client);
if ((exPlayer.ElectrolockLevel == chargeLevel && exPlayer.ElectrolockCharge >= ChargesNeededForLevel(chargeLevel) && exPlayer.ElectrolockSublevel.Count >= SublevelsNeededForLevel(chargeLevel)) ||
exPlayer.ElectrolockLevel > chargeLevel)
{
unlocked = true;
DisplayInvisibleKeyTile(client, map, x, y, packetList);
}
else
{
DisplayVisibleKeyTile(client, map, x, y, packetList);
}
}
}
PacketHitList.MethodEnded(ref packetList);
return(unlocked);
}
public static void OnStep(Client client, PacketHitList hitlist)
{
// NOTE: Remove the mapper+ check for release
if (exPlayer.Get(client).AnniversaryEnabled&& client.Player.CurrentChapter == null && Ranks.IsAllowed(client, Enums.Rank.Mapper))
{
int currentAnniversarySection = client.Player.StoryHelper.ReadSetting("[Anniversary12]-CurrentSection").ToInt();
//Messenger.PlayerMsg(client, "Section: " + currentAnniversarySection, Text.BrightRed);
// NOTE: Do /not/ remove the mapper+ check here, this resets the story when you reach the end
if (currentAnniversarySection == annivRiddles.Length && Ranks.IsAllowed(client, Enums.Rank.Mapper))
{
currentAnniversarySection = 0;
client.Player.StoryHelper.SaveSetting("[Anniversary12]-CurrentSection", currentAnniversarySection.ToString());
Messenger.PlayerMsg(client, "Section reset!", Text.BrightRed);
}
if (currentAnniversarySection >= 0 && currentAnniversarySection < annivRiddles.Length)
{
AnniversaryRiddle currentRiddle = annivRiddles[currentAnniversarySection];
if (client.Player.MapID == currentRiddle.MapId &&
client.Player.X == currentRiddle.X && client.Player.Y == currentRiddle.Y)
{
client.Player.SetStoryState(currentRiddle.Story - 1, false);
StoryManager.PlayStory(client, currentRiddle.Story - 1);
currentAnniversarySection++;
client.Player.StoryHelper.SaveSetting("[Anniversary12]-CurrentSection", currentAnniversarySection.ToString());
}
}
}
if (exPlayer.Get(client).StoryEnabled&& client.Player.CurrentChapter == null)
{
int currentStorySection = client.Player.StoryHelper.ReadSetting("[MainStory]-CurrentSection").ToInt();
switch (client.Player.MapID)
{
case "s737": {
if (currentStorySection == 3) // Tiny Grotto complete, first time [Bulbasaur mission]
{
if (client.Player.X > 20 && client.Player.X < 35 && client.Player.Y > 43)
{
if (client.Player.GetDungeonCompletionCount(1 - 1) >= 1)
{
StoryManager.PlayStory(client, 614 - 1);
}
}
}
}
break;
case "s1934": {
if (currentStorySection == 6)
{
if (client.Player.X == 10 && client.Player.Y == 9)
{
StoryManager.PlayStory(client, 616 - 1);
}
}
}
break;
}
}
}
public static void RunTest(Client client)
{
Messenger.PlayerMsg(client, client.IP.ToString(), Text.BrightRed);
return;
int playerCount = 0;
PacketHitList hitlist = null;
PacketHitList.MethodStart(ref hitlist);
IMap map = client.Player.Map;
Stopwatch watch = new Stopwatch();
watch.Start();
using (DatabaseConnection db = new DatabaseConnection(DatabaseID.Players)) {
PlayerManager.RetrieveCharacterID(db, "luigiDUDE");
}
//Messenger.PlayerWarp(client, map.MapID, 0, 25);
watch.Stop();
PacketHitList.MethodEnded(ref hitlist);
Messenger.PlayerMsg(client, "Time: " + watch.ElapsedMilliseconds + "\nPlayer Count: " + playerCount, Text.BrightGreen);
Messenger.PlayerMsg(client, "RNG: " + Server.Math.Rand(0, 1000), Text.BrightGreen);
Messenger.PlayerMsg(client, "Tick Count: " + Server.Core.GetTickCount().Tick, Text.BrightGreen);
//exPlayer.Get(client).EvolutionActive = !exPlayer.Get(client).EvolutionActive;
//Messenger.PlayerMsg(client, "Evolution active: " + exPlayer.Get(client).EvolutionActive, Text.Yellow);
//BossBattles.StartBossBattle(client, "CliffsideRelic");
//map.SetTile(9, 3, 3, 0, 4, 3);
//map.SetAttribute(9, 3, Server.Enums.TileType.Scripted, 46, 0, 0, "2", "1015", "25:25");
//Messenger.SendTile(9, 3, map);
}
public override void OnNpcDeath(PacketHitList hitlist, ICharacter attacker, MapNpc npc)
{
var map = MapManager.RetrieveActiveMap(npc.MapID);
if (!map.ActiveNpc.Enumerate().Where(x => x.Num > 0).Where(x => x != npc).Any())
{
SetCompletionTile(MapManager.RetrieveActiveMap(npc.MapID));
}
}
public static bool MoveNpcRight(IMap map, Client target, PacketHitList packetList, int mapNpcSlot)
{
// Right
if (map.ActiveNpc[mapNpcSlot].X < target.Player.X)
{
if (MovementProcessor.CanNpcMove(map, mapNpcSlot, Enums.Direction.Right))
{
MovementProcessor.NpcMove(packetList, map, mapNpcSlot, map.ActiveNpc[mapNpcSlot].Direction, Enums.Speed.Walking);
return(true);
}
}
return(false);
}
public static void VerifyMapSublevelTriggerTiles(Client client, IMap map, PacketHitList packetList)
{
PacketHitList.MethodStart(ref packetList);
bool unlocked = false;
for (int x = 0; x <= map.MaxX; x++)
{
for (int y = 0; y <= map.MaxY; y++)
{
VerifySublevelTriggerTile(client, map, x, y, packetList);
}
}
PacketHitList.MethodEnded(ref packetList);
}
public static void OnMapLoaded(Client client, IMap map, PacketHitList packetList)
{
if (exPlayer.Get(client).StoryEnabled)
{
int currentStorySection = client.Player.StoryHelper.ReadSetting("[MainStory]-CurrentSection").ToInt();
switch (map.MapID)
{
case "s50": {
if (currentStorySection == 4) // Retreive 500 Poke for Team Jaw
{
if (client.Player.HasItem(1) >= 500)
{
// We have the 500 Poke
client.Player.TakeItem(1, 500);
// Move forward one section so we don't have to take the money again
currentStorySection++;
client.Player.StoryHelper.SaveSetting("[MainStory]-CurrentSection", currentStorySection.ToString());
}
else
{
// We don't have the 500 Poke
StoryManager.PlayStory(client, 619 - 1);
}
}
if (currentStorySection == 5) // We already delivered the 500 Poke to Team Jaw
{
StoryManager.PlayStory(client, 615 - 1);
}
}
break;
case "s737": {
if (currentStorySection == 1)
{
StoryManager.PlayStory(client, 612 - 1);
}
}
break;
case "s1286": {
if (client.Player.Y > 8 && client.Player.Y < 40 &&
currentStorySection == 2)
{
StoryManager.PlayStory(client, 613 - 1);
}
}
break;
}
}
}
public override void DeconfigurePlayer(Client client)
{
base.DeconfigurePlayer(client);
client.Player.KillableAnywhere = false;
client.Player.EndTempStatMode();
PacketHitList packetHitList = null;
PacketHitList.MethodStart(ref packetHitList);
Main.RefreshCharacterSpeedLimit(client.Player.GetActiveRecruit(), client.Player.Map, packetHitList);
PacketHitList.MethodEnded(ref packetHitList);
}
public static void CheckForSublevelGoal(Client client, PacketHitList packetList)
{
for (int i = 0; i < client.Player.TriggerEvents.Count; i++)
{
if (client.Player.TriggerEvents[i].Trigger == TriggerEventTrigger.SteppedOnTile &&
client.Player.TriggerEvents[i].ID.StartsWith("ESTSublevelGoal"))
{
SteppedOnTileTriggerEvent tEvent = client.Player.TriggerEvents[i] as SteppedOnTileTriggerEvent;
if (client.Player.MapID == tEvent.MapID)
{
DisplayVisibleSublevelGoalTile(client, client.Player.Map, tEvent.X, tEvent.Y, packetList);
}
}
}
}
public static void CreateNewParty(Client leader)
{
PacketHitList hitlist = null;
PacketHitList.MethodStart(ref hitlist);
List <string> partyIDs = new List <string>();
using (DatabaseConnection dbConnection = new DatabaseConnection(DatabaseID.Players))
{
partyIDs = LoadPartyIDList(dbConnection.Database);
}
if (leader.Player.PartyID == null)
{
string partyID = null;
rwLock.EnterWriteLock();
try
{
while (true)
{
string tempID = Security.PasswordGen.Generate(10, 15);
if (partyIDs.Contains(tempID) == false)
{
partyID = tempID;
break;
}
}
Party party = new Party(partyID, leader);
leader.Player.PartyID = partyID;
parties.Add(partyID, party);
}
finally
{
rwLock.ExitWriteLock();
}
leader.Player.AddExpKitModule(new AvailableExpKitModule(Enums.ExpKitModules.Party, true));
PacketBuilder.AppendPartyMemberDataFor(leader, hitlist, 0);
hitlist.AddPacket(leader, PacketBuilder.CreateChatMsg("You have created a new party!", Text.BrightGreen));
}
else
{
hitlist.AddPacket(leader, PacketBuilder.CreateChatMsg("You are already in a party!", Text.BrightRed));
}
PacketHitList.MethodEnded(ref hitlist);
}
public static void JoinParty(Party party, Client client)
{
PacketHitList hitlist = null;
PacketHitList.MethodStart(ref hitlist);
if (party != null)
{
Client leader = party.GetLeader();
if (Combat.MoveProcessor.IsInAreaRange(1, client.Player.X, client.Player.Y, leader.Player.X, leader.Player.Y))
{
if (party.AddToParty(client))
{
client.Player.PartyID = party.PartyID;
client.Player.AddExpKitModule(new AvailableExpKitModule(Enums.ExpKitModules.Party, true));
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You have joined the party!", Text.BrightGreen));
//PartyMember member = party.FindMember(client.Player.CharID);
int slot = party.GetMemberSlot(client.Player.CharID);
//Messenger.SendPartyMemberData(client, member, slot);
foreach (Client i in party.GetOnlineMemberClients())
{
if (i.IsPlaying() && i != client)
{
//PartyMember teamMember = party.Members.FindMember(i.Player.CharID);
//int teamMemberSlot = party.Members.GetMemberSlot(i.Player.CharID);
//Messenger.SendPartyMemberData(client, teamMember, teamMemberSlot);
//Messenger.SendPartyMemberData(i, member, slot);
hitlist.AddPacket(i, PacketBuilder.CreateChatMsg(client.Player.Name + " has joined the party!", Text.BrightGreen));
}
PacketBuilder.AppendPartyMemberData(i, hitlist, slot);
}
}
else
{
hitlist.AddPacket(client, PacketBuilder.CreateChatMsg("You couldn't join the party!", Text.BrightRed));
}
}
else
{
Messenger.PlayerMsg(client, "You need to stand next to the leader to join the party!", Text.BrightRed);
}
}
PacketHitList.MethodEnded(ref hitlist);
}
public void CompleteRoom(Client client)
{
var playerData = Data.ExtendPlayer(client);
if (playerData.CurrentRoom % CheckpointInterval == 0)
{
PacketHitList hitlist = null;
PacketHitList.MethodStart(ref hitlist);
Main.HealParty(hitlist, client);
PacketHitList.MethodEnded(ref hitlist);
}
playerData.CurrentRoom++;
playerData.RoomsCleared++;
WarpToCurrentRoom(client);
}
public static void DisplayInvisibleSublevelGoalTile(Client client, IMap map, int x, int y, PacketHitList packetList)
{
PacketHitList.MethodStart(ref packetList);
Tile tile = new Tile(new DataManager.Maps.Tile());
MapCloner.CloneTile(map, x, y, tile);
tile.Mask = 0;
tile.MaskSet = 7;
tile.Type = Enums.TileType.Walkable;
Messenger.SendTemporaryTileTo(packetList, client, x, y, tile);
MapCloner.CloneTile(map, x, y - 1, tile);
tile.Fringe = 0;
tile.FringeSet = 7;
tile.Type = Enums.TileType.Walkable;
Messenger.SendTemporaryTileTo(packetList, client, x, y - 1, tile);
PacketHitList.MethodEnded(ref packetList);
}
public static bool VerifyMapKeyTiles(Client client, IMap map, PacketHitList packetList)
{
PacketHitList.MethodStart(ref packetList);
bool unlocked = false;
for (int x = 0; x <= map.MaxX; x++)
{
for (int y = 0; y <= map.MaxY; y++)
{
bool state = VerifyKeyTile(client, map, x, y, packetList);
if (state)
{
unlocked = true;
}
}
}
PacketHitList.MethodEnded(ref packetList);
return(unlocked);
}
public override void OnNpcDeath(PacketHitList hitlist, ICharacter attacker, MapNpc npc)
{
base.OnNpcDeath(hitlist, attacker, npc);
if (Data.Started)
{
var map = MapManager.RetrieveMap(attacker.MapID);
if (!map.IsZoneOrObjectSandboxed())
{
if (attacker.CharacterType == Enums.CharacterType.Recruit)
{
var npcDefinition = NpcManager.Npcs[npc.Species];
var owner = ((Recruit)attacker).Owner;
if (npc.Shiny == Enums.Coloration.Shiny &&
(npcDefinition.Behavior == Enums.NpcBehavior.AttackOnSight || npcDefinition.Behavior == Enums.NpcBehavior.AttackWhenAttacked || npcDefinition.Behavior == Enums.NpcBehavior.FleeOnsight))
{
if (Data.Scores.TryGetValue(owner.Player.CharID, out var userScore))
{
userScore.Score += 1;
}
else
{
userScore = new UserScore()
{
Score = 1
};
Data.Scores.Add(owner.Player.CharID, userScore);
}
if (!userScore.FoundSpecies.Contains(npc.Species))
{
userScore.FoundSpecies.Add(npc.Species);
}
Messenger.PlayerMsg(owner, "You got a point!", Text.BrightGreen);
}
}
}
}
}
public static void HandleOutlawGameOver(Client client, ref PacketHitList hitList)
{
PacketHitList.MethodStart(ref hitList);
if (client.Player.OutlawRole == Enums.OutlawRole.Outlaw)
{
var lostPoints = client.Player.PlayerData.PendingOutlawPoints % OutlawPointInterval;
var gainedPoints = client.Player.PlayerData.PendingOutlawPoints - lostPoints;
client.Player.PlayerData.LockedOutlawPoints += gainedPoints;
Messenger.PlayerMsg(client, $"You have been defeated! You gained {gainedPoints} points from this round!", Text.BrightGreen);
Messaging.SendGlobalMessage($"{client.Player.DisplayName} has been captured!", Settings.DiscordOutlawChannel, Text.BrightGreen);
}
client.Player.OutlawRole = Enums.OutlawRole.None;
client.Player.PlayerData.PendingOutlawPoints = 0;
PacketBuilder.AppendPlayerData(client, hitList);
PacketHitList.MethodEnded(ref hitList);
}
public static void OnMapLoaded(Client client, IMap map, PacketHitList packetList)
{
PacketHitList.MethodStart(ref packetList);
if (IsInTower(map))
{
// Prevent others from entering until finished. Spoiler prevention!
if (Ranks.IsDisallowed(client, Enums.Rank.Scripter))
{
packetList.HitList.Clear(); // Remove the warp packets to cancel the map load
Messenger.PlayerWarp(client, 1015, 25, 25);
if (Ranks.IsAllowed(client, Enums.Rank.Moniter))
{
Messenger.PlayerMsg(client, "Sorry, you can't go here! ~Pikachu", Text.BrightRed);
}
else
{
Messenger.PlayerMsg(client, "Sorry, you can't go here!", Text.BrightRed);
}
}
else
{
if (VerifyMapKeyTiles(client, map, packetList))
{
packetList.AddPacket(client, PacketBuilder.CreateBattleMsg("An electrolock has been opened nearby!", Text.BrightGreen));
}
CheckForSublevelGoal(client, packetList);
VerifyMapSublevelTriggerTiles(client, map, packetList);
}
}
else
{
ResetPlayer(client);
}
PacketHitList.MethodEnded(ref packetList);
}
public static void VerifySublevelTriggerTile(Client client, IMap map, int x, int y, PacketHitList packetList)
{
PacketHitList.MethodStart(ref packetList);
Tile mapTile = map.Tile[x, y];
if (mapTile.Type == Server.Enums.TileType.Scripted)
{
if (mapTile.Data1 == 59)
{
string triggerID = mapTile.String1;
exPlayer exPlayer = exPlayer.Get(client);
if (exPlayer.ElectrolockSublevelTriggersActive.Contains(triggerID) == false)
{
DisplayVisibleSublevelTriggerTile(client, map, x, y, packetList);
}
else
{
DisplayInvisibleSublevelTriggerTile(client, map, x, y, packetList);
}
}
}
PacketHitList.MethodEnded(ref packetList);
}
public static void DisplayInvisibleSublevelTriggerTile(Client client, IMap map, int x, int y, PacketHitList packetList)
{
Tile tile = new Tile(new DataManager.Maps.Tile());
MapCloner.CloneTile(map, x, y, tile);
tile.Mask = 0;
tile.MaskSet = 10;
tile.Anim = 0;
tile.AnimSet = 10;
tile.Type = Enums.TileType.Walkable;
Messenger.SendTemporaryTileTo(packetList, client, x, y, tile);
}
public override void OnNpcSpawn(IMap map, MapNpcPreset npc, MapNpc spawnedNpc, PacketHitList hitlist)
{
spawnedNpc.MaxHPBonus = 300;
spawnedNpc.SpAtkBuff = 1;
spawnedNpc.SpDefBuff = 1;
spawnedNpc.HP = spawnedNpc.MaxHP;
Main.RefreshCharacterTraits(spawnedNpc, map, hitlist);
}
public void SpawnNpc(MapNpcPreset npc, bool checkSight)
{
int NPCNum = 0;
int X = 0;
int Y = 0;
bool Spawned = false;
// Check for empty NPC slot
int npcSlot = FindOpenNpcSlot();
if (npcSlot < 0 || npcSlot >= Constants.MAX_MAP_NPCS)
{
return;
}
NPCNum = npc.NpcNum;
if (NPCNum > 0)
{
ActiveNpc[npcSlot].Num = NPCNum;
ActiveNpc[npcSlot].Target = null;
ActiveNpc[npcSlot].Name = NpcManager.Npcs[NPCNum].Name;
ActiveNpc[npcSlot].Form = NpcManager.Npcs[NPCNum].Form;
//if (NpcManager.Npcs[NPCNum].ShinyChance != 0 && Server.Math.Rand(0, NpcManager.Npcs[NPCNum].ShinyChance) == 0) ActiveNpc[npcSlot].Shiny = true;
ActiveNpc[npcSlot].Sex = Pokedex.Pokedex.GetPokemonForm(NpcManager.Npcs[NPCNum].Species, ActiveNpc[npcSlot].Form).GenerateLegalSex();
ActiveNpc[npcSlot].AttackTimer = new TickCount(Core.GetTickCount().Tick);
ActiveNpc[npcSlot].PauseTimer = new TickCount(Core.GetTickCount().Tick);
//if (Npc[npcSlot].MinLevel == -1) {
//Npc[npcSlot].MinLevel = NpcManager.Npcs[Npc[npcSlot].NpcNum].RecruitLevel;
if (npc.MinLevel <= 0)
{
npc.MinLevel = 1;
npc.MaxLevel = 1;
}// else {
// Console.WriteLine("Npc found!");
// }
//}
ActiveNpc[npcSlot].Level = Server.Math.Rand(npc.MinLevel, npc.MaxLevel + 1);
//set initial stats
ActiveNpc[npcSlot].CalculateOriginalSprite();
ActiveNpc[npcSlot].CalculateOriginalStats();
ActiveNpc[npcSlot].CalculateOriginalType();
ActiveNpc[npcSlot].CalculateOriginalAbility();
//ActiveNpc[npcSlot].CalculateOriginalMobility();
ActiveNpc[npcSlot].HP = ActiveNpc[npcSlot].MaxHP;
ActiveNpc[npcSlot].Direction = (Enums.Direction)Server.Math.Rand(0, 4);
ActiveNpc[npcSlot].GenerateMoveset();
if (Moral == Enums.MapMoral.None)
{
ActiveNpc[npcSlot].GenerateHeldItem();
}
if (Server.Math.Rand(0, 100) < npc.StartStatusChance)
{
ActiveNpc[npcSlot].StatusAilment = npc.StartStatus;
ActiveNpc[npcSlot].StatusAilmentCounter = npc.StartStatusCounter;
}
if (npc.SpawnX < 0 | npc.SpawnY < 0)
{
// We'll try 100 times to randomly place the sprite
for (int i = 1; i <= 50; i++)
{
if (Tile[X, Y].Type == Enums.TileType.Walkable || Tile[X, Y].Type == Enums.TileType.Slow)
{
if (checkSight)
{
bool seen = false;
foreach (Client client in GetClients())
{
if (CanCharacterSeeDestination(client.Player.GetActiveRecruit(), X, Y))
{
seen = true;
break;
}
}
if (!seen)
{
ActiveNpc[npcSlot].X = X;
ActiveNpc[npcSlot].Y = Y;
Spawned = true;
break;
}
}
else
{
ActiveNpc[npcSlot].X = X;
ActiveNpc[npcSlot].Y = Y;
Spawned = true;
break;
}
}
}
for (int i = 1; i <= 50; i++)
{
X = Server.Math.Rand(0, MaxX + 1);
Y = Server.Math.Rand(0, MaxY + 1);
// Check if the tile is walkable
if (Tile[X, Y].Type == Enums.TileType.Walkable)
{
ActiveNpc[npcSlot].X = X;
ActiveNpc[npcSlot].Y = Y;
Spawned = true;
break;
}
}
}
else
{
// We no longer subtract one because Rand is ListIndex -1.
ActiveNpc[npcSlot].X = npc.SpawnX;
ActiveNpc[npcSlot].Y = npc.SpawnY;
Spawned = true;
}
// Didn't spawn, so now we'll just try to find a free tile
if (!Spawned)
{
for (Y = 0; Y <= MaxY; Y++)
{
for (X = 0; X <= MaxX; X++)
{
if (Tile[X, Y].Type == Enums.TileType.Walkable)
{
ActiveNpc[npcSlot].X = X;
ActiveNpc[npcSlot].Y = Y;
Spawned = true;
}
}
}
}
// If we suceeded in spawning then send it to everyone
if (Spawned)
{
PacketHitList hitlist = null;
PacketHitList.MethodStart(ref hitlist);
PacketBuilder.AppendNpcSpawn(MapManager.RetrieveActiveMap(MapID), hitlist, npcSlot);
Scripting.ScriptManager.InvokeFunction("OnNpcSpawn", MapManager.RetrieveActiveMap(MapID), npc, ActiveNpc[npcSlot], hitlist);
PacketHitList.MethodEnded(ref hitlist);
}
}
}
public static bool MoveNpcInDirection(Enums.Direction direction, IMap map, Client target, PacketHitList packetList, int mapNpcSlot)
{
switch (direction)
{
case Enums.Direction.Up: {
return(MoveNpcUp(map, target, packetList, mapNpcSlot));
}
case Enums.Direction.Down: {
return(MoveNpcDown(map, target, packetList, mapNpcSlot));
}
case Enums.Direction.Left: {
return(MoveNpcLeft(map, target, packetList, mapNpcSlot));
}
case Enums.Direction.Right: {
return(MoveNpcRight(map, target, packetList, mapNpcSlot));
}
}
return(false);
}
public void SendHPToMap(PacketHitList packetList, IMap map, int mapNpcNum)
{
PacketBuilder.AppendNpcHP(map, packetList, mapNpcNum);
hpChanged = false;
}
public void HandoutExp(Client giver, ulong exp, PacketHitList hitlist)
{
PacketHitList.MethodStart(ref hitlist);
bool totalForAll = true;
ulong newExp;
if (totalForAll)
{
newExp = exp;
}
else
{
newExp = exp * (ulong)(Members.Count + 3) / 4 / (ulong)Members.Count;
}
if (!(giver.Player.GetActiveRecruit().Level == Exp.ExpManager.Exp.MaxLevels) && giver.Player.Hunted && !giver.Player.Dead)
{
Scripting.ScriptManager.InvokeSub("PlayerEXP", hitlist, giver, newExp);
Combat.BattleProcessor.CheckPlayerLevelUp(hitlist, giver);
}
foreach (Client i in GetOnlineMemberClients())
{
if (i.IsPlaying() && i != giver)
{
//PartyMember member = members.FindMember(i.Player.CharID);
//if (member != null) {
if (giver.Player.Map == i.Player.Map)
{
if (!(i.Player.GetActiveRecruit().Level == Exp.ExpManager.Exp.MaxLevels) && i.Player.Hunted && !i.Player.Dead)
{
int lowestBound = 8000;
int chosenMiddle = 8000;
if (i.Player.GetActiveRecruit().Level < giver.Player.GetActiveRecruit().Level)
{
int diff = giver.Player.GetActiveRecruit().Level - i.Player.GetActiveRecruit().Level;
lowestBound -= diff * diff * 100 / 5;
int distance = Math.Max(Math.Abs(giver.Player.X - i.Player.X), Math.Abs(giver.Player.Y - i.Player.Y));
if (distance > 40)
{
distance = 40;
}
if (distance < 8)
{
distance = 8;
}
chosenMiddle = lowestBound * (distance - 8) / 40 + chosenMiddle * (40 - (distance - 8)) / 40;
if (chosenMiddle < 0)
{
chosenMiddle = 0;
}
}
ulong moddedExp = newExp * (ulong)chosenMiddle / 8000;
if (moddedExp < 1)
{
moddedExp = 1;
}
Scripting.ScriptManager.InvokeSub("PlayerEXP", hitlist, i, moddedExp);
Combat.BattleProcessor.CheckPlayerLevelUp(hitlist, i);
}
else
{
// The party member is at the max level, so do nothing
}
}
//}
}
}
PacketHitList.MethodEnded(ref hitlist);
}
public static void DisplayVisibleKeyTile(Client client, IMap map, int x, int y, PacketHitList packetList)
{
Tile tile = new Tile(new DataManager.Maps.Tile());
MapCloner.CloneTile(map, x, y, tile);
tile.Mask = 6;
tile.MaskSet = 4;
tile.Type = Enums.TileType.Blocked;
Messenger.SendTemporaryTileTo(packetList, client, x, y, tile);
}
public override void OnNpcSpawn(IMap map, MapNpcPreset npc, MapNpc spawnedNpc, PacketHitList hitlist)
{
base.OnNpcSpawn(map, npc, spawnedNpc, hitlist);
if (Data.Started)
{
if (!map.IsZoneOrObjectSandboxed())
{
spawnedNpc.Unrecruitable = true;
spawnedNpc.Shiny = Server.Enums.Coloration.Shiny;
PacketBuilder.AppendNpcSprite(map, hitlist, spawnedNpc.MapSlot);
}
}
}
public void ProcessAI()
{
try {
TickCount tickCount = Core.GetTickCount();
PacketHitList packetList = null;
PacketHitList.MethodStart(ref packetList);
if (map.IsSaving == false)
{
// Keys/Other timed tile stuff
for (int x = 0; x <= map.MaxX; x++)
{
for (int y = 0; y <= map.MaxY; y++)
{
if (map.Tile[x, y] != null)
{
if (tickCount.Elapsed(map.Tile[x, y].DoorTimer, 5000))
{
if ((map.Tile[x, y].Type == Enums.TileType.Key || map.Tile[x, y].Type == Enums.TileType.Door) && map.Tile[x, y].DoorOpen == true)
{
map.Tile[x, y].DoorOpen = false;
packetList.AddPacketToMap(map, TcpPacket.CreatePacket("mapkey", x.ToString(), y.ToString(), "0"));
}
}
}
}
}
Scripting.ScriptManager.InvokeSub("OnMapTick", map);
if (map.ProcessingPaused == false)
{
int livingNpcs = 0;
for (int mapNpcSlot = 0; mapNpcSlot < Constants.MAX_MAP_NPCS; mapNpcSlot++)
{
int npcNum = map.ActiveNpc[mapNpcSlot].Num;
MapNpc mapNpc = map.ActiveNpc[mapNpcSlot];
if (npcNum > 0)
{
livingNpcs++;
Npc npc = NpcManager.Npcs[npcNum];
if (npc.Behavior != Enums.NpcBehavior.FullyScriptedAI || npc.AIScript == "" || npc.AIScript.ToLower() == "none")
{
#region Used for attacking on sight
if (npc.Behavior == Enums.NpcBehavior.AttackOnSight || npc.Behavior == Enums.NpcBehavior.Guard)
{
foreach (Client i in map.GetClients())
{
if (i.Player.MapID == map.MapID && map.ActiveNpc[mapNpcSlot].Target == null && !i.Player.Dead &&
i.Player.Hunted && map.Tile[i.Player.X, i.Player.Y].Type != Enums.TileType.NPCAvoid && i.Player.Hunted)
{
if (MovementProcessor.CanCharacterSeeCharacter(map, map.ActiveNpc[mapNpcSlot], i.Player.GetActiveRecruit()))
{
if (npc.Behavior == Enums.NpcBehavior.AttackOnSight /* || i.Player.PK == true*/)
{
//if (!string.IsNullOrEmpty(npc.AttackSay)) {
// packetList.AddPacket(i, PacketBuilder.CreateChatMsg("A " + npc.Name + " : " + npc.AttackSay, Text.Grey));
//}
map.ActiveNpc[mapNpcSlot].Target = i;
}
}
}
}
}
#endregion
#region Used for walking/targetting/picking up items
if (npcNum > 0)
{
bool hasNpcWalked;
if (map.ActiveNpc[mapNpcSlot].Target != null && map.ActiveNpc[mapNpcSlot].Target.IsPlaying() &&
map.ActiveNpc[mapNpcSlot].Target.Player.MapID == map.MapID &&
(map.Tile[map.ActiveNpc[mapNpcSlot].Target.Player.X, map.ActiveNpc[mapNpcSlot].Target.Player.Y].Type == Enums.TileType.NPCAvoid ||
!map.ActiveNpc[mapNpcSlot].Target.Player.Hunted || map.ActiveNpc[mapNpcSlot].Target.Player.Dead ||
!MovementProcessor.CanCharacterSeeCharacter(map, map.ActiveNpc[mapNpcSlot], map.ActiveNpc[mapNpcSlot].Target.Player.GetActiveRecruit())))
{
map.ActiveNpc[mapNpcSlot].Target = null;
}
Client target = map.ActiveNpc[mapNpcSlot].Target;
if (npc.Behavior != Enums.NpcBehavior.Shopkeeper)
{
if (target != null)
{
if (target.IsPlaying() && target.Player.MapID == map.MapID)
{
hasNpcWalked = false;
int dir = Math.Rand(0, 5);
hasNpcWalked = AIProcessor.MoveNpcInDirection((Enums.Direction)dir, map, target, packetList, mapNpcSlot);
if (!hasNpcWalked)
{
foreach (Enums.Direction direction in Enum.GetValues(typeof(Enums.Direction)))
{
if (direction != (Enums.Direction)dir)
{
if (AIProcessor.MoveNpcInDirection(direction, map, target, packetList, mapNpcSlot))
{
break;
}
}
}
}
if (hasNpcWalked == false)
{
if (map.ActiveNpc[mapNpcSlot].X - 1 == target.Player.X && map.ActiveNpc[mapNpcSlot].Y == target.Player.Y)
{
if (map.ActiveNpc[mapNpcSlot].Direction != Enums.Direction.Left)
{
MovementProcessor.ChangeNpcDir(packetList, map, mapNpcSlot, Enums.Direction.Left);
}
hasNpcWalked = true;
}
if (map.ActiveNpc[mapNpcSlot].X + 1 == target.Player.X && map.ActiveNpc[mapNpcSlot].Y == target.Player.Y)
{
if (map.ActiveNpc[mapNpcSlot].Direction != Enums.Direction.Right)
{
MovementProcessor.ChangeNpcDir(packetList, map, mapNpcSlot, Enums.Direction.Right);
}
hasNpcWalked = true;
}
if (map.ActiveNpc[mapNpcSlot].X == target.Player.X && map.ActiveNpc[mapNpcSlot].Y - 1 == target.Player.Y)
{
if (map.ActiveNpc[mapNpcSlot].Direction != Enums.Direction.Up)
{
MovementProcessor.ChangeNpcDir(packetList, map, mapNpcSlot, Enums.Direction.Up);
}
hasNpcWalked = true;
}
if (map.ActiveNpc[mapNpcSlot].X == target.Player.X && map.ActiveNpc[mapNpcSlot].Y + 1 == target.Player.Y)
{
if (map.ActiveNpc[mapNpcSlot].Direction != Enums.Direction.Down)
{
MovementProcessor.ChangeNpcDir(packetList, map, mapNpcSlot, Enums.Direction.Down);
}
hasNpcWalked = true;
}
}
if (hasNpcWalked == false)
{
int val = Math.Rand(0, 2);
if (val == 1)
{
val = Math.Rand(0, 4);
if (MovementProcessor.CanNpcMove(map, mapNpcSlot, (Enums.Direction)val))
{
MovementProcessor.NpcMove(packetList, map, mapNpcSlot, map.ActiveNpc[mapNpcSlot].Direction, Enums.Speed.Walking);
}
}
}
}
else
{
map.ActiveNpc[mapNpcSlot].Target = null;
}
}
else
{
int shouldWalk = Math.Rand(0, 2);
if (npc.Behavior != Enums.NpcBehavior.Friendly)
{
for (int i = 0; i < Constants.MAX_MAP_ITEMS; i++)
{
if (map.ActiveItem[i].X == map.ActiveNpc[mapNpcSlot].X && map.ActiveItem[i].Y == map.ActiveNpc[mapNpcSlot].Y &&
map.ActiveItem[i].Num > -1 && map.ActiveNpc[mapNpcSlot].HeldItem == null)
{
map.ActiveNpc[mapNpcSlot].MapGetItem();
shouldWalk = 1;
}
}
}
else if (npc.Behavior == Enums.NpcBehavior.Friendly)
{
foreach (Client i in map.GetClients())
{
if (i.Player.X >= map.ActiveNpc[mapNpcSlot].X - 1 && i.Player.X <= map.ActiveNpc[mapNpcSlot].X + 1 &&
i.Player.Y >= map.ActiveNpc[mapNpcSlot].Y - 1 && i.Player.Y <= map.ActiveNpc[mapNpcSlot].Y + 1)
{
shouldWalk = Math.Rand(0, 10);
break;
}
}
}
if (shouldWalk == 0)
{
shouldWalk = Math.Rand(0, 5);
if (MovementProcessor.CanNpcMove(map, mapNpcSlot, (Enums.Direction)shouldWalk))
{
MovementProcessor.NpcMove(packetList, map, mapNpcSlot, map.ActiveNpc[mapNpcSlot].Direction, Enums.Speed.Walking);
}
}
}
}
}
#endregion
#region Used for attacking players
if (npcNum > 0)
{
Client target = map.ActiveNpc[mapNpcSlot].Target;
if (target != null)
{
if (target.IsPlaying() && target.Player.MapID == map.MapID)
{
// Make sure npcs dont attack more then once a second
if (Core.GetTickCount().Elapsed(map.ActiveNpc[mapNpcSlot].AttackTimer, 1000))
{
int usableMoveCount = 0;
for (int i = 0; i < mapNpc.Moves.Length; i++)
{
if (mapNpc.Moves[i].MoveNum > -1 && mapNpc.Moves[i].CurrentPP > 0)
{
usableMoveCount++;
}
}
if (usableMoveCount == 0)
{
if (BattleProcessor.ShouldUseMove(map, mapNpc, -1))
{
mapNpc.UseMove(-1);
}
}
else
{
// Try to use a move, up to 50 times
for (int i = 0; i < 50; i++)
{
int moveSlotToUse = Server.Math.Rand(0, 5) - 1;
if (moveSlotToUse == -1)
{
// A standard attack
if (BattleProcessor.ShouldUseMove(map, mapNpc, moveSlotToUse))
{
mapNpc.UseMove(moveSlotToUse);
break;
}
}
else
{
if (mapNpc.Moves[moveSlotToUse].MoveNum > -1 && mapNpc.Moves[moveSlotToUse].CurrentPP > 0)
{
// Use a move
if (BattleProcessor.ShouldUseMove(map, mapNpc, moveSlotToUse))
{
mapNpc.UseMove(moveSlotToUse);
break;
}
}
}
}
}
}
}
else
{
map.ActiveNpc[mapNpcSlot].Target = null;
}
}
}
#endregion
if (npcNum > 0 && map.ActiveNpc[mapNpcSlot].HPChanged)
{
map.ActiveNpc[mapNpcSlot].SendHPToMap(packetList, map, mapNpcSlot);
}
}
else
{
// Scripted AI: Reimplement?
//Globals.AIScriptManager.CallAIProcessSub(NpcManager.Npcs[map.Npc[x].NpcNum].AIScript, tickCount, map.MapNum, x);
}
}
}
//try and spawn something
if (map.NpcSpawnWait == null)
{
map.NpcSpawnWait = Core.GetTickCount();
}
if (Core.GetTickCount().Tick > map.NpcSpawnWait.Tick)
{
if (livingNpcs < map.MaxNpcs)
{
map.SpawnNpc(true);
}
map.NpcSpawnWait = new TickCount(map.NpcSpawnWait.Tick + map.NpcSpawnTime * 1000);
}
}
}
//lock (MapManager.ActiveMapLockObject) {
bool shouldRemove = false;
if (map.PlayersOnMap.Count == 0 && tickCount.Elapsed(map.ActivationTime, AIProcessor.MapTTL))
{
if (map.IsProcessingComplete())
{
shouldRemove = true;
for (int i = 1; i < 9; i++)
{
IMap borderingMap = MapManager.RetrieveActiveBorderingMap(map, (Enums.MapID)i);
if (borderingMap != null)
{
if (borderingMap.PlayersOnMap.Count > 0)
{
shouldRemove = false;
}
}
}
if (shouldRemove)
{
MapManager.rwLock.EnterWriteLock();
try {
if (map.MapType == Enums.MapType.House)
{
// Only save the map here when logging out - otherwise, the map is saved when the player is saved
map.Save();
}
if ((map.MapType == Enums.MapType.RDungeonMap || map.MapType == Enums.MapType.Instanced))
{
using (Database.DatabaseConnection dbConnection = new Database.DatabaseConnection(Database.DatabaseID.Data)) {
if (MapManager.GetTotalPlayersOnMap(dbConnection, map.MapID) == 0)
{
DataManager.Maps.MapDataManager.DeleteMap(dbConnection.Database, map.MapID);
}
else
{
map.Save();
}
}
}
MapManager.UnsafeRemoveActiveMap(map.MapID);
} finally {
MapManager.rwLock.ExitWriteLock();
}
}
}
}
//}
PacketHitList.MethodEnded(ref packetList);
} catch (Exception ex) {
Server.Exceptions.ErrorLogger.WriteToErrorLog(ex, "MapAIProcessor");
}
}
