public void SetLadder(int ladderId, bool isVisible, bool animationEffect, byte animationDelay)
{
Field.State.TriggerLadders[ladderId].IsVisible = isVisible;
Field.State.TriggerLadders[ladderId].AnimationEffect = animationEffect;
Field.State.TriggerLadders[ladderId].AnimationDelay = animationDelay;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerLadders[ladderId]));
}
private static void HandleUpdateWidget(GameSession session, PacketReader packet)
{
TriggerUIMode submode = (TriggerUIMode)packet.ReadByte();
int arg = packet.ReadInt();
Widget widget;
switch (submode)
{
case TriggerUIMode.StopCutscene:
widget = session.FieldManager.GetWidget(WidgetType.SceneMovie);
if (widget == null)
{
return;
}
widget.State = "IsStop";
widget.Arg = arg.ToString();
session.Send(TriggerPacket.StopCutscene(arg));
break;
case TriggerUIMode.Guide:
widget = session.FieldManager.GetWidget(WidgetType.Guide);
if (widget == null)
{
return;
}
widget.State = "IsTriggerEvent";
widget.Arg = arg.ToString();
break;
}
}
public void SetCube(int[] triggerIds, bool isVisible, byte randomCount)
{
foreach (int triggerId in triggerIds)
{
Field.State.TriggerCubes[triggerId].IsVisible = isVisible;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerCubes[triggerId]));
}
}
public void SetMesh(int[] meshIds, bool isVisible, int arg3, int arg4, float arg5)
{
foreach (int triggerMeshId in meshIds)
{
Field.State.TriggerMeshes[triggerMeshId].IsVisible = isVisible;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerMeshes[triggerMeshId]));
}
}
public void SetEffect(int[] triggerIds, bool isVisible, int arg3, byte arg4)
{
foreach (int triggerId in triggerIds)
{
Field.State.TriggerEffects[triggerId].IsVisible = isVisible;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerEffects[triggerId]));
}
}
public void SetEffect(int[] triggerIds, bool isVisible, int arg3, byte arg4)
{
foreach (int triggerId in triggerIds)
{
if (Field.State.TriggerEffects.TryGetValue(triggerId, out TriggerEffect triggerEffect))
{
triggerEffect.IsVisible = isVisible;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(triggerEffect));
}
}
}
public void SetMesh(int[] meshIds, bool isVisible, int arg3, int arg4, float arg5)
{
foreach (int triggerMeshId in meshIds)
{
if (Field.State.TriggerMeshes.TryGetValue(triggerMeshId, out TriggerMesh triggerMesh))
{
triggerMesh.IsVisible = isVisible;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(triggerMesh));
}
}
}
public void SetLadder(int ladderId, bool isVisible, bool animationEffect, byte animationDelay)
{
if (!Field.State.TriggerLadders.TryGetValue(ladderId, out TriggerLadder ladder))
{
return;
}
ladder.IsVisible = isVisible;
ladder.AnimationEffect = animationEffect;
ladder.AnimationDelay = animationDelay;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(ladder));
}
public void SetActor(int actorId, bool isVisible, string stateName, bool arg4, bool arg5)
{
if (!Field.State.TriggerActors.TryGetValue(actorId, out TriggerActor stateTriggerActor))
{
Logger.Warning("SetActor: Actor not found: {0}", actorId);
return;
}
stateTriggerActor.IsVisible = isVisible;
stateTriggerActor.StateName = stateName;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(stateTriggerActor));
}
public void SetRandomMesh(int[] meshIds, bool isVisible, byte meshCount, int arg4, int delayTime)
{
Random random = RandomProvider.Get();
int[] pickedMeshIds = meshIds.OrderBy(x => random.Next()).Take(meshCount).ToArray();
Task.Run(async() =>
{
foreach (int triggerMeshId in pickedMeshIds)
{
Field.State.TriggerMeshes[triggerMeshId].IsVisible = isVisible;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerMeshes[triggerMeshId]));
await Task.Delay(delayTime);
}
});
}
public void SetTimer(string id, int time, bool clearAtZero, bool display, int arg5, string arg6)
{
int msTime = time * 1000;
int endTick = Environment.TickCount + msTime;
MapTimer timer = Field.GetMapTimer(id);
if (timer == null)
{
MapTimer newTimer = new MapTimer(id, endTick);
Field.AddMapTimer(newTimer);
Field.BroadcastPacket(TriggerPacket.Timer(msTime, clearAtZero, display));
return;
}
timer.EndTick = endTick;
Field.BroadcastPacket(TriggerPacket.Timer(msTime, clearAtZero, display));
}
public void SetMesh(int[] meshIds, bool isVisible, int arg3, int delay, float arg5)
{
Task.Run(async() =>
{
foreach (int triggerMeshId in meshIds)
{
if (!Field.State.TriggerMeshes.TryGetValue(triggerMeshId, out TriggerMesh triggerMesh))
{
continue;
}
triggerMesh.IsVisible = isVisible;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(triggerMesh));
await Task.Delay(delay);
}
});
}
public void SetEffect(int[] triggerIds, bool isVisible, int arg3, byte arg4)
{
foreach (int triggerId in triggerIds)
{
if (!Field.State.TriggerEffects.TryGetValue(triggerId, out TriggerEffect triggerEffect))
{
continue;
}
bool oldValue = triggerEffect.IsVisible;
triggerEffect.IsVisible = isVisible;
if (oldValue != isVisible) // If the value changed, broadcast the packet.
{
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(triggerEffect));
}
}
}
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;
}
}
}
public void SetActor(int actorId, bool isVisible, string stateName, bool arg4, bool arg5)
{
Field.State.TriggerActors[actorId].IsVisible = isVisible;
Field.State.TriggerActors[actorId].StateName = stateName;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerActors[actorId]));
}
public void SetPcEmotionLoop(string animationState, float duration, bool isLoop)
{
Field.BroadcastPacket(TriggerPacket.SetAnimationLoop(animationState, (int)duration, isLoop));
}
public void SetPcEmotionSequence(string animation)
{
Field.BroadcastPacket(TriggerPacket.SetAnimationSequence(animation));
}
public void SetSound(int soundId, bool isEnabled)
{
Field.State.TriggerSounds[soundId].IsEnabled = isEnabled;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerSounds[soundId]));
}
public void GuideEvent(int eventId)
{
Field.BroadcastPacket(TriggerPacket.Guide(eventId));
}
public void HideGuideSummary(int entityId, int textId)
{
Field.BroadcastPacket(TriggerPacket.Banner(03, entityId, textId));
}
public void AddPlayer(GameSession sender, IFieldObject <Player> player)
{
Debug.Assert(player.ObjectId > 0, "Player was added to field without initialized objectId.");
player.Coord = player.Value.Coord;
player.Value.MapId = MapId;
// TODO: Determine new coordinates for player as well
lock (Sessions)
{
Sessions.Add(sender);
}
// TODO: Send the initialization state of the field
foreach (IFieldObject <Player> existingPlayer in State.Players.Values)
{
sender.Send(FieldPacket.AddPlayer(existingPlayer));
sender.Send(FieldObjectPacket.LoadPlayer(existingPlayer));
}
State.AddPlayer(player);
// Broadcast new player to all players in map
Broadcast(session =>
{
session.Send(FieldPacket.AddPlayer(player));
session.Send(FieldObjectPacket.LoadPlayer(player));
});
foreach (IFieldObject <Item> existingItem in State.Items.Values)
{
sender.Send(FieldPacket.AddItem(existingItem, 123456));
}
foreach (IFieldObject <Npc> existingNpc in State.Npcs.Values)
{
sender.Send(FieldPacket.AddNpc(existingNpc));
sender.Send(FieldObjectPacket.LoadNpc(existingNpc));
}
foreach (IFieldObject <Portal> existingPortal in State.Portals.Values)
{
sender.Send(FieldPacket.AddPortal(existingPortal));
}
foreach (IFieldObject <Mob> existingMob in State.Mobs.Values)
{
sender.Send(FieldPacket.AddMob(existingMob));
sender.Send(FieldObjectPacket.LoadMob(existingMob));
}
if (player.Value.MapId == (int)Map.PrivateResidence && !player.Value.IsInDecorPlanner)
{
// Send function cubes
List <Cube> functionCubes = State.Cubes.Values.Where(x => x.Value.PlotNumber == 1 &&
(x.Value.Item.HousingCategory is ItemHousingCategory.Farming or ItemHousingCategory.Ranching))
.Select(x => x.Value).ToList();
if (functionCubes.Count > 0)
{
sender.Send(FunctionCubePacket.SendCubes(functionCubes));
}
}
foreach (IFieldObject <GuideObject> guide in State.Guide.Values)
{
sender.Send(GuideObjectPacket.Add(guide));
}
foreach (IFieldObject <HealingSpot> healingSpot in State.HealingSpots.Values)
{
sender.Send(RegionSkillPacket.Send(healingSpot.ObjectId, healingSpot.Value.Coord, new SkillCast(70000018, 1, 0, 1)));
}
foreach (IFieldObject <Instrument> instrument in State.Instruments.Values)
{
if (instrument.Value.Improvise)
{
sender.Send(InstrumentPacket.StartImprovise(instrument));
}
else
{
sender.Send(InstrumentPacket.PlayScore(instrument));
}
}
List <BreakableObject> breakables = new List <BreakableObject>();
breakables.AddRange(State.BreakableActors.Values.ToList());
breakables.AddRange(State.BreakableNifs.Values.ToList());
sender.Send(BreakablePacket.LoadBreakables(breakables));
List <InteractObject> interactObjects = new List <InteractObject>();
interactObjects.AddRange(State.InteractObjects.Values.Where(t => t is not AdBalloon).ToList());
sender.Send(InteractObjectPacket.LoadInteractObject(interactObjects));
List <AdBalloon> adBalloons = new List <AdBalloon>();
adBalloons.AddRange(State.InteractObjects.Values.OfType <AdBalloon>().ToList());
foreach (AdBalloon balloon in adBalloons)
{
sender.Send(InteractObjectPacket.LoadAdBallon(balloon));
}
List <TriggerObject> triggerObjects = new List <TriggerObject>();
triggerObjects.AddRange(State.TriggerMeshes.Values.ToList());
triggerObjects.AddRange(State.TriggerEffects.Values.ToList());
triggerObjects.AddRange(State.TriggerCameras.Values.ToList());
triggerObjects.AddRange(State.TriggerActors.Values.ToList());
triggerObjects.AddRange(State.TriggerCubes.Values.ToList());
triggerObjects.AddRange(State.TriggerLadders.Values.ToList());
triggerObjects.AddRange(State.TriggerRopes.Values.ToList());
triggerObjects.AddRange(State.TriggerSounds.Values.ToList());
sender.Send(TriggerPacket.LoadTriggers(triggerObjects));
if (MapLoopTask == null)
{
MapLoopTask = StartMapLoop(); //TODO: find a better place to initialise MapLoopTask
}
}
public void CameraSelect(int cameraId, bool enable)
{
Field.State.TriggerCameras[cameraId].IsEnabled = enable;
Field.BroadcastPacket(TriggerPacket.UpdateTrigger(Field.State.TriggerCameras[cameraId]));
}
public void CameraSelectPath(int[] pathIds, bool returnView)
{
Field.BroadcastPacket(TriggerPacket.Camera(pathIds, returnView));
}
public void AddPlayer(GameSession sender, IFieldObject <Player> player)
{
Debug.Assert(player.ObjectId > 0, "Player was added to field without initialized objectId.");
player.Coord = player.Value.Coord;
player.Value.MapId = MapId;
// TODO: Determine new coordinates for player as well
lock (Sessions)
{
Sessions.Add(sender);
}
// TODO: Send the initialization state of the field
foreach (IFieldObject <Player> existingPlayer in State.Players.Values)
{
sender.Send(FieldPacket.AddPlayer(existingPlayer));
sender.Send(FieldObjectPacket.LoadPlayer(existingPlayer));
}
foreach (IFieldObject <Item> existingItem in State.Items.Values)
{
sender.Send(FieldPacket.AddItem(existingItem, 123456));
}
foreach (IFieldObject <Npc> existingNpc in State.Npcs.Values)
{
sender.Send(FieldPacket.AddNpc(existingNpc));
sender.Send(FieldObjectPacket.LoadNpc(existingNpc));
}
foreach (IFieldObject <Portal> existingPortal in State.Portals.Values)
{
sender.Send(FieldPacket.AddPortal(existingPortal));
}
foreach (IFieldObject <Mob> existingMob in State.Mobs.Values)
{
sender.Send(FieldPacket.AddMob(existingMob));
sender.Send(FieldObjectPacket.LoadMob(existingMob));
}
if (State.InteractObjects.Values.Count > 0)
{
ICollection <IFieldObject <InteractObject> > balloons = State.InteractObjects.Values.Where(x => x.Value.Type == InteractObjectType.AdBalloon).ToList();
if (balloons.Count > 0)
{
foreach (IFieldObject <InteractObject> balloon in balloons)
{
sender.Send(InteractObjectPacket.AddAdBallons(balloon));
}
}
ICollection <IFieldObject <InteractObject> > objects = State.InteractObjects.Values.Where(x => x.Value.Type != InteractObjectType.AdBalloon).ToList();
if (objects.Count > 0)
{
sender.Send(InteractObjectPacket.AddInteractObjects(objects));
}
}
if (State.Cubes.IsEmpty && !player.Value.IsInDecorPlanner)
{
if (MapId == (int)Map.PrivateResidence)
{
Home home = GameServer.HomeManager.GetHome(player.Value.VisitingHomeId);
if (home != null)
{
Dictionary <long, Cube> cubes = home.FurnishingInventory;
foreach (Cube cube in cubes.Values.Where(x => x.PlotNumber == 1))
{
IFieldObject <Cube> ugcCube = RequestFieldObject(cube);
ugcCube.Coord = cube.CoordF;
ugcCube.Rotation = cube.Rotation;
State.AddCube(ugcCube);
}
}
}
else
{
List <Home> homes = GameServer.HomeManager.GetPlots(MapId);
foreach (Home home in homes)
{
Dictionary <long, Cube> cubes = home.FurnishingInventory;
foreach (Cube cube in cubes.Values.Where(x => x.PlotNumber != 1))
{
IFieldObject <Cube> ugcCube = RequestFieldObject(cube);
ugcCube.Coord = cube.CoordF;
ugcCube.Rotation = cube.Rotation;
State.AddCube(ugcCube);
}
}
}
}
foreach (IFieldObject <GuideObject> guide in State.Guide.Values)
{
sender.Send(GuideObjectPacket.Add(guide));
}
foreach (IFieldObject <HealingSpot> healingSpot in State.HealingSpots.Values)
{
sender.Send(RegionSkillPacket.Send(healingSpot.ObjectId, healingSpot.Value.Coord, new SkillCast(70000018, 1, 0, 1)));
}
foreach (IFieldObject <Instrument> instrument in State.Instruments.Values)
{
if (instrument.Value.Improvise)
{
sender.Send(InstrumentPacket.StartImprovise(instrument));
}
else
{
sender.Send(InstrumentPacket.PlayScore(instrument));
}
}
List <BreakableObject> breakables = new List <BreakableObject>();
breakables.AddRange(State.BreakableActors.Values.ToList());
breakables.AddRange(State.BreakableNifs.Values.ToList());
sender.Send(BreakablePacket.LoadBreakables(breakables));
List <TriggerObject> triggerObjects = new List <TriggerObject>();
triggerObjects.AddRange(State.TriggerMeshes.Values.ToList());
triggerObjects.AddRange(State.TriggerEffects.Values.ToList());
triggerObjects.AddRange(State.TriggerCameras.Values.ToList());
triggerObjects.AddRange(State.TriggerActors.Values.ToList());
triggerObjects.AddRange(State.TriggerCubes.Values.ToList());
triggerObjects.AddRange(State.TriggerLadders.Values.ToList());
triggerObjects.AddRange(State.TriggerRopes.Values.ToList());
triggerObjects.AddRange(State.TriggerSounds.Values.ToList());
sender.Send(TriggerPacket.LoadTriggers(triggerObjects));
State.AddPlayer(player);
if (MapLoopTask == null)
{
MapLoopTask = StartMapLoop(); //TODO: find a better place to initialise MapLoopTask
}
// Broadcast new player to all players in map
Broadcast(session =>
{
session.Send(FieldPacket.AddPlayer(player));
session.Send(FieldObjectPacket.LoadPlayer(player));
});
}
