public bool UserDetected(int[] boxIds, byte jobId)
{
Job job = (Job)jobId;
List <Character> players = Field.State.Players.Values.ToList();
if (job != Job.None)
{
players = players.Where(x => x.Value.Job == job).ToList();
}
foreach (int boxId in boxIds)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box == null)
{
return(false);
}
if (players.Any(player => FieldManager.IsPlayerInBox(box, player)))
{
return(true);
}
}
return(false);
}
public void EndMiniGame(int winnerBoxId, MiniGame type, bool isOnlyWinner)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, winnerBoxId);
if (box is null)
{
return;
}
foreach (IFieldObject <Player> player in Field.State.Players.Values)
{
if (!FieldManager.IsPlayerInBox(box, player))
{
continue;
}
switch (type)
{
case MiniGame.LudibriumEscape:
PlayerTrigger trigger = player.Value.Triggers.FirstOrDefault(x => x.Key == "gameStart");
player.Value.Triggers.Remove(trigger);
player.Value.Session.Send(ResultsPacket.Rounds(1, 1));
break;
case MiniGame.OXQuiz:
player.Value.Session.Send(ResultsPacket.Rounds(10, 10));
break;
}
}
}
public bool MonsterDead(int[] spawnPointIds, bool arg2)
{
// TODO: Needs a better check for multiple mob spawns
foreach (int spawnPointId in spawnPointIds)
{
MapEventNpcSpawnPoint spawnPoint = MapEntityMetadataStorage.GetMapEventNpcSpawnPoint(Field.MapId, spawnPointId);
if (spawnPoint == null)
{
continue;
}
foreach (string npcId in spawnPoint.NpcIds)
{
if (!int.TryParse(npcId, out int id))
{
continue;
}
if (Field.State.Mobs.Values.Any(x => x.Value.Id == id && !x.IsDead))
{
return(false);
}
}
}
return(true);
}
public void MiniGameGiveReward(int winnerBoxId, string contentType, MiniGame type)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, winnerBoxId);
if (box is null)
{
return;
}
List <IFieldObject <Player> > players = new();
foreach (IFieldObject <Player> player in Field.State.Players.Values)
{
if (FieldManager.IsPlayerInBox(box, player))
{
players.Add(player);
}
}
foreach (IFieldObject <Player> player in players)
{
if (contentType == "miniGame")
{
List <Item> items = RewardContentMetadataStorage.GetRewardItems(3, player.Value.Levels.Level);
foreach (Item item in items)
{
player.Value.Inventory.AddItem(player.Value.Session, item, true);
}
}
else if (contentType == "UserOpenMiniGameExtraReward")
{
}
}
}
public void MiniGameCameraDirection(int boxId, int cameraId)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box is null)
{
return;
}
List <IFieldObject <Player> > boxPlayers = new();
foreach (IFieldObject <Player> player in Field.State.Players.Values)
{
if (FieldManager.IsPlayerInBox(box, player))
{
boxPlayers.Add(player);
}
}
Random random = Random.Shared;
int index = random.Next(boxPlayers.Count);
IFieldObject <Player> randomPlayer = boxPlayers[index];
Field.BroadcastPacket(LocalCameraPacket.Camera(cameraId, 1, randomPlayer.ObjectId));
}
public void PlaySystemSoundInBox(int[] boxIds, string sound)
{
if (boxIds != null)
{
foreach (int boxId in boxIds)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box is null)
{
return;
}
foreach (IFieldObject <Player> player in Field.State.Players.Values)
{
if (FieldManager.IsPlayerInBox(box, player))
{
player.Value.Session.Send(SystemSoundPacket.Play(sound));
}
}
}
return;
}
Field.BroadcastPacket(SystemSoundPacket.Play(sound));
}
public int GetUserCount(int boxId, int userTagId)
{
if (boxId == 0)
{
return(Field.State.Players.Values.Count);
}
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box is null)
{
return(0);
}
int userCount = 0;
foreach (IFieldActor <Player> player in Field.State.Players.Values)
{
if (FieldManager.IsPlayerInBox(box, player))
{
userCount++;
}
}
return(userCount);
}
public void MoveUser(int mapId, int triggerId, int boxId)
{
List <Character> players = Field.State.Players.Values.ToList();
if (boxId != 0)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box is null)
{
return;
}
players = players.Where(player => FieldManager.IsPlayerInBox(box, player)).ToList();
}
// move player back to return map
if (mapId == 0 && triggerId == 0)
{
foreach (IFieldObject <Player> player in players)
{
player.Value.Warp(player.Value.ReturnMapId, player.Value.ReturnCoord);
}
return;
}
if (mapId == Field.MapId)
{
IFieldObject <Portal> portal = Field.State.Portals.Values.First(p => p.Value.Id == triggerId);
foreach (IFieldObject <Player> player in players)
{
player.Value.Move(portal.Coord, portal.Rotation, isTrigger: true);
}
return;
}
CoordF moveCoord;
CoordF moveRotation;
MapPortal dstPortal = MapEntityMetadataStorage.GetPortals(mapId).FirstOrDefault(portal => portal.Id == triggerId);
if (dstPortal == null)
{
MapPlayerSpawn spawn = MapEntityMetadataStorage.GetRandomPlayerSpawn(mapId);
moveCoord = spawn.Coord.ToFloat();
moveRotation = spawn.Rotation.ToFloat();
}
else
{
moveCoord = dstPortal.Coord.ToFloat();
moveRotation = dstPortal.Rotation.ToFloat();
}
foreach (IFieldObject <Player> player in players)
{
player.Value.Warp(mapId, moveCoord, moveRotation, instanceId: 1);
}
}
public MushkingRoyaleSession(int mapId)
{
MapPlayerSpawn spawn = MapEntityMetadataStorage.GetRandomPlayerSpawn(mapId);
MapId = mapId;
SpawnPosition = spawn.Coord;
SpawnRotation = spawn.Rotation;
SessionId = GameServer.MushkingRoyaleSessionManager.GetSessionId();
InstanceId = SessionId;
GameServer.MushkingRoyaleSessionManager.AddSession(this);
}
public static void HandleCreateDungeon(GameSession session, PacketReader packet)
{
int dungeonId = packet.ReadInt();
bool groupEnter = packet.ReadBool();
Player player = session.Player;
if (player.DungeonSessionId != -1)
{
session.SendNotice("Leave your current dungeon before opening another.");
return;
}
int dungeonLobbyId = DungeonStorage.GetDungeonByDungeonId(dungeonId).LobbyFieldId;
MapPlayerSpawn spawn = MapEntityMetadataStorage.GetRandomPlayerSpawn(dungeonLobbyId);
DungeonSession dungeonSession = GameServer.DungeonManager.CreateDungeonSession(dungeonId, groupEnter ? DungeonType.Group : DungeonType.Solo);
//TODO: Send packet that greys out enter alone / enter as party when already in a dungeon session (sendRoomDungeon packet/s).
//the session belongs to the party leader
if (groupEnter)
{
Party party = player.Party;
if (party.DungeonSessionId != -1)
{
session.SendNotice("Need to reset dungeon before entering another instance");
return;
}
foreach (Player member in party.Members)
{
if (member.DungeonSessionId != -1)
{
session.SendNotice($"{member.Name} is still in a Dungeon Instance.");
return;
}
}
party.DungeonSessionId = dungeonSession.SessionId;
party.BroadcastPacketParty(PartyPacket.PartyHelp(dungeonId));
//TODO: Update Party with dungeon Info via party packets (0d,0e and others are involved).
}
else // solo join dungeon
{
player.DungeonSessionId = dungeonSession.SessionId;
}
session.Player.Warp(dungeonLobbyId, instanceId: dungeonSession.DungeonInstanceId);
//TODO: things after map is created here: spawn doctor npc.
//This packet sets the banner in the dungeon that displays the dungeonname and the playersize it was created for.
//party.BroadcastPacketParty(DungeonWaitPacket.Show(dungeonId, DungeonStorage.GetDungeonByDungeonId(dungeonId).MaxUserCount));
}
public bool QuestUserDetected(int[] boxes, int[] questIds, byte[] modes, byte arg4)
{
byte mode = modes[0];
foreach (int boxId in boxes)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box is null)
{
return(false);
}
List <Character> players = Field.State.Players.Values.ToList();
foreach (Character player in players)
{
if (!FieldManager.IsPlayerInBox(box, player))
{
continue;
}
foreach (int questId in questIds)
{
if (!player.Value.QuestData.TryGetValue(questId, out QuestStatus quest))
{
return(false);
}
switch (mode)
{
case 1: // started
return(quest.State is QuestState.Started);
case 2: // on going
return(quest.State is QuestState.Started && quest.Condition.All(x => x.Completed));
case 3: // completed
return(quest.State is QuestState.Completed);
}
}
}
}
return(false);
}
public void EndMiniGameRound(int winnerBoxId, float expRate, bool isOnlyWinner, bool isGainLoserBonus, bool meso, MiniGame type)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, winnerBoxId);
if (box is null)
{
return;
}
foreach (IFieldObject <Player> player in Field.State.Players.Values)
{
if (FieldManager.IsPlayerInBox(box, player))
{
// TODO: calculate correct amount of exp;
player.Value.Levels.GainExp(10000);
}
}
}
public void AddBuff(int[] boxIds, int skillId, byte skillLevel, bool arg4, bool arg5, string feature)
{
foreach (int boxId in boxIds)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box is null)
{
return;
}
foreach (Character player in Field.State.Players.Values.Where(player => FieldManager.IsPlayerInBox(box, player)))
{
// TODO: Rework when buff system is implemented
Status status = new(new(skillId, skillLevel), player.ObjectId, player.ObjectId, 1);
StatusHandler.Handle(player.Value.Session, status);
}
}
}
public override void Handle(GameSession session, PacketReader packet)
{
string entityId = packet.ReadString();
long skillSN = packet.ReadLong();
int skillId = packet.ReadInt();
short skillLevel = packet.ReadShort();
short unkShort = packet.ReadShort();
int unkInt = packet.ReadInt();
CoordF playerCoords = packet.Read <CoordF>();
Player player = session.Player;
if (!MapEntityMetadataStorage.IsVibrateObject(player.MapId, entityId))
{
return;
}
session.FieldManager.BroadcastPacket(VibratePacket.Vibrate(entityId, player.FieldPlayer.SkillCast));
}
public void CreateMonster(int[] spawnPointIds, bool spawnAnimation, int arg3)
{
foreach (int spawnPointId in spawnPointIds)
{
MapEventNpcSpawnPoint spawnPoint = MapEntityMetadataStorage.GetMapEventNpcSpawnPoint(Field.MapId, spawnPointId);
if (spawnPoint is null)
{
continue;
}
for (int i = 0; i < spawnPoint.Count; i++)
{
foreach (string npcId in spawnPoint.NpcIds)
{
if (!int.TryParse(npcId, out int id))
{
continue;
}
short animation = -1;
if (spawnAnimation)
{
NpcMetadata npcMetadata = NpcMetadataStorage.GetNpcMetadata(id);
if (npcMetadata is null || !npcMetadata.StateActions.TryGetValue(NpcState.Normal, out (string, NpcAction, short)[] stateAction))
{
continue;
}
if (stateAction.Length == 0)
{
continue;
}
animation = AnimationStorage.GetSequenceIdBySequenceName(npcMetadata.NpcMetadataModel.Model, stateAction[0].Item1);
}
Npc npc = Field.RequestNpc(id, spawnPoint.Position, spawnPoint.Rotation, animation);
npc.SpawnPointId = spawnPointId;
}
}
}
}
public void SpawnNpcRange(int[] rangeId, bool isAutoTargeting, byte randomPickCount, int score)
{
foreach (int spawnPointId in rangeId)
{
MapEventNpcSpawnPoint spawnPoint = MapEntityMetadataStorage.GetMapEventNpcSpawnPoint(Field.MapId, spawnPointId);
if (spawnPoint == null)
{
continue;
}
foreach (string npcId in spawnPoint.NpcIds)
{
if (!int.TryParse(npcId, out int id))
{
continue;
}
Npc npc = Field.RequestNpc(id, spawnPoint.Position, spawnPoint.Rotation);
npc.SpawnPointId = spawnPointId;
}
}
}
public void SetAchievement(int boxId, string type, string trophySet)
{
List <Character> players = Field.State.Players.Values.ToList();
if (boxId != 0)
{
MapTriggerBox box = MapEntityMetadataStorage.GetTriggerBox(Field.MapId, boxId);
if (box is null)
{
return;
}
players = players.Where(player => FieldManager.IsPlayerInBox(box, player)).ToList();
}
foreach (IFieldObject <Player> player in players)
{
if (type == "trigger")
{
TrophyManager.OnTrigger(player.Value, trophySet);
}
}
}
public void FaceEmotion(int spawnPointId, string emotionName)
{
if (spawnPointId == 0)
{
IFieldActor <Player> firstPlayer = Field.State.Players.FirstOrDefault().Value;
Field.BroadcastPacket(TriggerPacket.SetFaceEmotion(firstPlayer.ObjectId, emotionName));
return;
}
MapEventNpcSpawnPoint spawnPoint = MapEntityMetadataStorage.GetMapEventNpcSpawnPoint(Field.MapId, spawnPointId);
if (spawnPoint is null)
{
return;
}
foreach (string npcId in spawnPoint.NpcIds)
{
if (!int.TryParse(npcId, out int id))
{
continue;
}
if (Field.State.Npcs.TryGetValue(id, out Npc npc))
{
Field.BroadcastPacket(TriggerPacket.SetFaceEmotion(npc.ObjectId, emotionName));
return;
}
if (Field.State.Mobs.TryGetValue(id, out Npc mob))
{
Field.BroadcastPacket(TriggerPacket.SetFaceEmotion(mob.ObjectId, emotionName));
return;
}
}
}
private static void HandleEnter(GameSession session, PacketReader packet)
{
int globalEventId = packet.ReadInt();
int selectionIndex = packet.ReadInt();
GlobalEvent globalEvent = GameServer.GlobalEventManager.GetEventById(globalEventId);
if (globalEvent == null)
{
return;
}
Map map;
switch (globalEvent.Events[selectionIndex])
{
case GlobalEventType.oxquiz:
map = Map.MapleOXQuiz;
break;
case GlobalEventType.trap_master:
map = Map.TrapMaster;
break;
case GlobalEventType.spring_beach:
map = Map.SpringBeach;
break;
case GlobalEventType.crazy_runner:
map = Map.CrazyRunners;
break;
case GlobalEventType.final_surviver:
map = Map.SoleSurvivor;
break;
case GlobalEventType.great_escape:
map = Map.LudibriumEscape;
break;
case GlobalEventType.dancedance_stop:
map = Map.DanceDanceStop;
break;
case GlobalEventType.crazy_runner_shanghai:
map = Map.ShanghaiCrazyRunners;
break;
case GlobalEventType.hideandseek:
map = Map.HideAndSeek;
break;
case GlobalEventType.red_arena:
map = Map.RedArena;
break;
case GlobalEventType.blood_mine:
map = Map.CrimsonTearMine;
break;
case GlobalEventType.treasure_island:
map = Map.TreasureIsland;
break;
case GlobalEventType.christmas_dancedance_stop:
map = Map.HolidayDanceDanceStop;
break;
default:
Logger.Warning("Unknown Global Event: {event}", globalEvent.Events[selectionIndex]);
return;
}
session.Player.Mount = null;
MapPortal portal = MapEntityMetadataStorage.GetPortals((int)map).FirstOrDefault(portal => portal.Id == 1);
session.Player.Warp(map, portal.Coord.ToFloat(), portal.Rotation.ToFloat());
}
public void MoveNpc(int spawnTriggerId, string patrolDataName)
{
PatrolData patrolData = MapEntityMetadataStorage.GetPatrolData(Field.MapId, patrolDataName);
Field.State.Npcs.Values.FirstOrDefault(x => x.SpawnPointId == spawnTriggerId)?.SetPatrolData(patrolData);
}
public void TalkFunction(GameSession session, int functionId, string function)
{
if (functionId == 0)
{
return;
}
List <ActionType> actions = new();
Script npcScript = ScriptLoader.GetScript($"Npcs/{Npc.Id}");
DynValue actionResults = npcScript?.RunFunction(function);
if (actionResults == null)
{
return;
}
switch (actionResults.Type)
{
case DataType.Number:
actions.Add((ActionType)actionResults.Number);
break;
case DataType.Tuple:
foreach (DynValue value in actionResults.Tuple)
{
actions.Add((ActionType)value.Number);
}
break;
default:
return;
}
MapPortal portal = new();
foreach (ActionType action in actions)
{
switch (action)
{
case ActionType.OpenWindow:
DynValue windowResults = npcScript.RunFunction("actionWindow");
session.Send(NpcTalkPacket.Action(ActionType.OpenWindow, windowResults.Tuple[0].String, windowResults.Tuple[1].String));
break;
case ActionType.Portal:
DynValue portalResults = npcScript.RunFunction("actionPortal");
portal = MapEntityMetadataStorage.GetPortals(session.Player.MapId).FirstOrDefault(portal => portal.Id == portalResults.Number);
if (portal is null)
{
return;
}
session.Send(NpcTalkPacket.Action(ActionType.Portal, "", "", portal.Id));
break;
case ActionType.ItemReward:
DynValue itemResults = npcScript.RunFunction("actionItemReward"); // TODO: Support > 1 item
Item item = new(id : (int)itemResults.Tuple[0].Number,
amount : (int)itemResults.Tuple[2].Number,
rarity : (int)itemResults.Tuple[1].Number);
session.Player.Inventory.AddItem(session, item, true);
session.Send(NpcTalkPacket.Action(action, "", "", 0, item));
break;
case ActionType.MoveMap:
DynValue map = npcScript.RunFunction("actionMoveMap");
int mapId = (int)map.Tuple[0].Number;
int portalId = (int)map.Tuple[1].Number;
MapPortal portalDst = MapEntityMetadataStorage.GetPortals(mapId).FirstOrDefault(x => x.Id == portalId);
if (portalDst is null)
{
session.Player.Warp(mapId);
return;
}
session.Player.Warp(mapId, portalDst.Coord, portalDst.Rotation);
break;
}
}
// this needs to be sent after the UI window action
if (actions.Contains(ActionType.Portal))
{
session.Player.Move(portal.Coord.ToFloat(), portal.Rotation.ToFloat());
}
}
public void MoveUserPath(string movePath)
{
PatrolData patrolData = MapEntityMetadataStorage.GetPatrolData(Field.MapId, movePath);
Field.MovePlayerAlongPath(Field.State.Players.First().Value, patrolData);
}
private static void HandleMove(GameSession session, PacketReader packet)
{
int srcMapId = packet.ReadInt();
if (srcMapId != session.FieldManager.MapId)
{
return;
}
int portalId = packet.ReadInt();
IFieldObject <Portal> fieldPortal = session.FieldManager.State.Portals.Values.FirstOrDefault(x => x.Value.Id == portalId);
if (fieldPortal == default)
{
Logger.Warning("Unable to find portal: {portalId} in map: {srcMapId}", portalId, srcMapId);
return;
}
Portal srcPortal = fieldPortal.Value;
switch (srcPortal.PortalType)
{
case PortalTypes.Field:
break;
case PortalTypes.DungeonReturnToLobby:
DungeonSession dungeonSession = GameServer.DungeonManager.GetDungeonSessionBySessionId(session.Player.DungeonSessionId);
if (dungeonSession == null)
{
return;
}
session.Player.Warp(dungeonSession.DungeonLobbyId, instanceId: dungeonSession.DungeonInstanceId);
return;
case PortalTypes.LeaveDungeon:
HandleLeaveInstance(session);
return;
case PortalTypes.Home:
HandleHomePortal(session, fieldPortal);
return;
default:
Logger.Warning("unknown portal type id: {portalType}", srcPortal.PortalType);
break;
}
if (!MapEntityMetadataStorage.HasSafePortal(srcMapId) || srcPortal.TargetMapId == 0) // map is instance only
{
HandleLeaveInstance(session);
return;
}
MapPortal dstPortal = MapEntityMetadataStorage.GetPortals(srcPortal.TargetMapId)
.FirstOrDefault(portal => portal.Id == srcPortal.TargetPortalId); // target map's portal id == source portal's targetPortalId
if (dstPortal == default)
{
session.Player.Warp(srcPortal.TargetMapId);
return;
}
CoordF coord = dstPortal.Coord.ToFloat();
if (dstPortal.Name == "Portal_cube") // spawn on the next block if portal is a cube
{
if (dstPortal.Rotation.Z == Direction.SOUTH_EAST)
{
coord.Y -= Block.BLOCK_SIZE;
}
else if (dstPortal.Rotation.Z == Direction.NORTH_EAST)
{
coord.X += Block.BLOCK_SIZE;
}
else if (dstPortal.Rotation.Z == Direction.NORTH_WEST)
{
coord.Y += Block.BLOCK_SIZE;
}
else if (dstPortal.Rotation.Z == Direction.SOUTH_WEST)
{
coord.X -= Block.BLOCK_SIZE;
}
}
session.Player.Warp(srcPortal.TargetMapId, coord, dstPortal.Rotation.ToFloat());
}
