private static void HandleReplaceCube(GameSession session, PacketReader packet)
{
CoordB coord = packet.Read <CoordB>();
packet.Skip(1);
int replacementItemId = packet.ReadInt();
long replacementItemUid = packet.ReadLong();
byte unk = packet.ReadByte();
long unk2 = packet.ReadLong(); // maybe part of rotation?
float zRotation = packet.ReadFloat();
CoordF rotation = new CoordF();
rotation.Z = zRotation;
int plotNumber = MapMetadataStorage.GetPlotNumber(session.Player.MapId, coord);
if (plotNumber < 0)
{
return;
}
//TODO: Add and remove appropriate items to warehouse inventory and furnishing inventory
//TODO: If itemUid is not found, send player to purchase the item
Item item = new Item(replacementItemId);
Cube cube = new Cube(item, plotNumber);
IFieldObject <Cube> fieldCube = session.FieldManager.RequestFieldObject(cube);
fieldCube.Coord = coord.ToFloat();
fieldCube.Rotation = rotation;
session.FieldManager.BroadcastPacket(ResponseCubePacket.ReplaceCube(session.FieldPlayer, fieldCube));
session.FieldManager.AddCube(fieldCube, session.FieldPlayer);
}
private static bool IsCoordSafe(Player player, CoordS currentCoord, CoordF closestCoord)
{
// Check if current coord is safe to be used as a return point when the character falls off the map
return(MapMetadataStorage.BlockExists(player.MapId, closestCoord.ToShort()) &&
!player.OnAirMount && (player.SafeBlock - closestCoord).Length() > 350 &&
player.FieldPlayer.Coord.Z == currentCoord.Z);
}
private static bool IsCoordSafe(GameSession session, CoordS currentCoord, CoordF closestCoord)
{
// Save last coord if player is not falling and not in a air mount
return(MapMetadataStorage.BlockExists(session.Player.MapId, closestCoord.ToShort()) &&
!session.Player.OnAirMount &&
(session.Player.SafeBlock - closestCoord).Length() > 350 &&
session.FieldPlayer.Coord.Z == currentCoord.Z);
}
public override void Execute(GameCommandTrigger trigger)
{
int mapId = trigger.Get <int>("id");
int instanceId = trigger.Get <int>("instance");
if (MapMetadataStorage.GetMetadata(mapId) == null)
{
trigger.Session.SendNotice($"Current map id:{trigger.Session.Player.MapId} instance: {trigger.Session.Player.InstanceId}");
return;
}
if (trigger.Session.Player.MapId == mapId && trigger.Session.Player.InstanceId == instanceId)
{
trigger.Session.SendNotice("You are already on that map.");
return;
}
trigger.Session.Player.Warp(mapId: mapId, instanceId: instanceId);
}
private static void HandleAddFurnishing(GameSession session, PacketReader packet)
{
CoordB coord = packet.Read <CoordB>();
byte padding = packet.ReadByte();
int itemId = packet.ReadInt();
long itemUid = packet.ReadLong();
byte padding2 = packet.ReadByte();
CoordF rotation = packet.Read <CoordF>();
int plotNumber = MapMetadataStorage.GetPlotNumber(session.Player.MapId, coord);
if (plotNumber < 0)
{
return;
}
// TODO: Check if player has rights to this plot
FurnishingShopMetadata shopMetadata = FurnishingShopMetadataStorage.GetMetadata(itemId);
if (shopMetadata == null || !shopMetadata.Buyable)
{
return;
}
if (itemUid == 0) // player needs to purchase
{
if (!PurchaseFurnishingItem(session, shopMetadata))
{
return;
}
Item item = new Item(itemId);
//TODO: Add and remove appropriate item to warehouse inventory and furnishing inventory
Cube cube = new Cube(item, plotNumber);
IFieldObject <Cube> fieldCube = session.FieldManager.RequestFieldObject(cube);
fieldCube.Coord = coord.ToFloat();
fieldCube.Rotation = rotation;
session.FieldManager.AddCube(fieldCube, session.FieldPlayer);
}
}
private static void HandleCatch(GameSession session, PacketReader packet)
{
bool success = packet.ReadBool();
CoordF guideBlock = Block.ClosestBlock(session.Player.Guide.Coord);
guideBlock.Z -= Block.BLOCK_SIZE; // get liquid block coord
MapBlock block = MapMetadataStorage.GetMapBlock(session.Player.MapId, guideBlock.ToShort());
List <FishMetadata> fishes = FishMetadataStorage.GetValidFishes(session.Player.MapId, block.Attribute);
//determine fish rarity
List <FishMetadata> selectedFishRarities = FilterFishesByRarity(fishes);
Random rnd = RandomProvider.Get();
int randomFishIndex = rnd.Next(selectedFishRarities.Count);
FishMetadata fish = selectedFishRarities[randomFishIndex];
//determine fish size
int fishSize = rnd.NextDouble() switch
{
private static MapBlock ScanZAxisForLiquidBlock(CoordF checkBlock, int mapId)
{
for (int zAxis = 0; zAxis < 3; zAxis++)
{
if (MapMetadataStorage.BlockAboveExists(mapId, checkBlock.ToShort()))
{
return(null);
}
MapBlock block = MapMetadataStorage.GetMapBlock(mapId, checkBlock.ToShort());
if (block == null || !IsLiquidBlock(block))
{
checkBlock.Z -= Block.BLOCK_SIZE;
continue;
}
return(block);
}
return(null);
}
public FieldManager(Player player)
{
MapId = player.MapId;
InstanceId = player.InstanceId;
BoundingBox = MapEntityStorage.GetBoundingBox(MapId);
// Load default npcs for map from config
foreach (MapNpc npc in MapEntityStorage.GetNpcs(MapId))
{
IFieldObject <Npc> fieldNpc = RequestFieldObject(new Npc(npc.Id)
{
ZRotation = (short)(npc.Rotation.Z * 10)
});
if (fieldNpc.Value.Friendly == 2)
{
fieldNpc.Coord = npc.Coord.ToFloat();
AddNpc(fieldNpc);
}
else
{
// NPC is an enemy
IFieldObject <Mob> fieldMob = RequestFieldObject(new Mob(npc.Id)
{
ZRotation = (short)(npc.Rotation.Z * 10)
});
fieldMob.Coord = npc.Coord.ToFloat();
AddMob(fieldMob);
}
}
// Spawn map's mobs at the mob spawners
foreach (MapMobSpawn mobSpawn in MapEntityStorage.GetMobSpawns(MapId))
{
if (mobSpawn.SpawnData == null)
{
Debug.WriteLine($"Missing mob spawn data: {mobSpawn}");
continue;
}
IFieldObject <MobSpawn> fieldMobSpawn = RequestFieldObject(new MobSpawn(mobSpawn));
fieldMobSpawn.Coord = mobSpawn.Coord.ToFloat();
State.AddMobSpawn(fieldMobSpawn);
SpawnMobs(fieldMobSpawn);
}
// Load default portals for map from config
foreach (MapPortal portal in MapEntityStorage.GetPortals(MapId))
{
IFieldObject <Portal> fieldPortal = RequestFieldObject(new Portal(portal.Id)
{
IsVisible = portal.IsVisible,
IsEnabled = portal.Enable,
IsMinimapVisible = portal.MinimapVisible,
Rotation = portal.Rotation.ToFloat(),
TargetMapId = portal.Target,
TargetPortalId = portal.TargetPortalId,
PortalType = portal.PortalType
});
fieldPortal.Coord = portal.Coord.ToFloat();
AddPortal(fieldPortal);
}
MapMetadata mapMetadata = MapMetadataStorage.GetMetadata(MapId);
if (mapMetadata != null)
{
string xBlockName = mapMetadata.XBlockName;
Triggers = TriggerLoader.GetTriggers(xBlockName).Select(initializer =>
{
TriggerContext context = new TriggerContext(this, Logger);
TriggerState startState = initializer.Invoke(context);
return(new TriggerScript(context, startState));
}).ToArray();
}
foreach (MapTriggerMesh mapTriggerMesh in MapEntityStorage.GetTriggerMeshes(MapId))
{
if (mapTriggerMesh != null)
{
TriggerMesh triggerMesh = new TriggerMesh(mapTriggerMesh.Id, mapTriggerMesh.IsVisible);
State.AddTriggerObject(triggerMesh);
}
}
foreach (MapTriggerEffect mapTriggerEffect in MapEntityStorage.GetTriggerEffects(MapId))
{
if (mapTriggerEffect != null)
{
TriggerEffect triggerEffect = new TriggerEffect(mapTriggerEffect.Id, mapTriggerEffect.IsVisible);
State.AddTriggerObject(triggerEffect);
}
}
foreach (MapTriggerActor mapTriggerActor in MapEntityStorage.GetTriggerActors(MapId))
{
if (mapTriggerActor != null)
{
TriggerActor triggerActor = new TriggerActor(mapTriggerActor.Id, mapTriggerActor.IsVisible, mapTriggerActor.InitialSequence);
State.AddTriggerObject(triggerActor);
}
}
foreach (MapTriggerCamera mapTriggerCamera in MapEntityStorage.GetTriggerCameras(MapId))
{
if (mapTriggerCamera != null)
{
TriggerCamera triggerCamera = new TriggerCamera(mapTriggerCamera.Id, mapTriggerCamera.IsEnabled);
State.AddTriggerObject(triggerCamera);
}
}
foreach (MapTriggerCube mapTriggerCube in MapEntityStorage.GetTriggerCubes(MapId))
{
if (mapTriggerCube != null)
{
TriggerCube triggerCube = new TriggerCube(mapTriggerCube.Id, mapTriggerCube.IsVisible);
State.AddTriggerObject(triggerCube);
}
}
foreach (MapTriggerLadder mapTriggerLadder in MapEntityStorage.GetTriggerLadders(MapId))
{
if (mapTriggerLadder != null)
{
TriggerLadder triggerLadder = new TriggerLadder(mapTriggerLadder.Id, mapTriggerLadder.IsVisible);
State.AddTriggerObject(triggerLadder);
}
}
foreach (MapTriggerRope mapTriggerRope in MapEntityStorage.GetTriggerRopes(MapId))
{
if (mapTriggerRope != null)
{
TriggerRope triggerRope = new TriggerRope(mapTriggerRope.Id, mapTriggerRope.IsVisible);
State.AddTriggerObject(triggerRope);
}
}
foreach (MapTriggerSound mapTriggerSound in MapEntityStorage.GetTriggerSounds(MapId))
{
if (mapTriggerSound != null)
{
TriggerSound triggerSound = new TriggerSound(mapTriggerSound.Id, mapTriggerSound.IsEnabled);
State.AddTriggerObject(triggerSound);
}
}
foreach (MapTriggerSkill mapTriggerSkill in MapEntityStorage.GetTriggerSkills(MapId))
{
if (mapTriggerSkill != null)
{
TriggerSkill triggerSkill = new TriggerSkill(mapTriggerSkill.Id, mapTriggerSkill.SkillId, mapTriggerSkill.SkillLevel, mapTriggerSkill.Count, mapTriggerSkill.Position);
IFieldObject <TriggerSkill> fieldTriggerSkill = RequestFieldObject(triggerSkill);
fieldTriggerSkill.Coord = fieldTriggerSkill.Value.Position;
State.AddTriggerSkills(fieldTriggerSkill);
}
}
// Load breakables
foreach (MapBreakableActorObject mapActor in MapEntityStorage.GetBreakableActors(MapId))
{
if (mapActor != null)
{
BreakableActorObject actor = new BreakableActorObject(mapActor.EntityId, mapActor.IsEnabled, mapActor.HideDuration, mapActor.ResetDuration);
State.AddBreakable(actor);
}
}
foreach (MapBreakableNifObject mapNif in MapEntityStorage.GetBreakableNifs(MapId))
{
if (mapNif != null)
{
BreakableNifObject nif = new BreakableNifObject(mapNif.EntityId, mapNif.IsEnabled, mapNif.TriggerId, mapNif.HideDuration, mapNif.ResetDuration);
State.AddBreakable(nif);
}
}
// Load interact objects
foreach (MapInteractObject mapInteract in MapEntityStorage.GetInteractObjects(MapId))
{
if (mapInteract != null)
{
InteractObject interactObject = new InteractObject(mapInteract.EntityId, mapInteract.InteractId, mapInteract.Type, InteractObjectState.Default);
State.AddInteractObject(interactObject);
}
}
// Load cubes
if (MapId == (int)Map.PrivateResidence)
{
Home home = GameServer.HomeManager.GetHomeById(player.VisitingHomeId);
if (home != null)
{
// Add cubes to state
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);
}
// Add portals to state
IEnumerable <Cube> cubePortals = cubes.Values.Where(x => x.Item.Id == 50400158);
foreach (Cube cubePortal in cubePortals)
{
Portal portal = new Portal(GuidGenerator.Int())
{
IsVisible = true,
IsEnabled = true,
IsMinimapVisible = false,
Rotation = cubePortal.Rotation,
PortalType = PortalTypes.Home
};
IFieldObject <Portal> fieldPortal = RequestFieldObject(portal);
fieldPortal.Coord = cubePortal.CoordF;
fieldPortal.Value.UGCPortalMethod = cubePortal.PortalSettings.Method;
if (!string.IsNullOrEmpty(cubePortal.PortalSettings.DestinationTarget))
{
switch (cubePortal.PortalSettings.Destination)
{
case UGCPortalDestination.PortalInHome:
fieldPortal.Value.TargetMapId = (int)Map.PrivateResidence;
break;
case UGCPortalDestination.SelectedMap:
fieldPortal.Value.TargetMapId = int.Parse(cubePortal.PortalSettings.DestinationTarget);
break;
case UGCPortalDestination.FriendHome:
fieldPortal.Value.TargetHomeAccountId = long.Parse(cubePortal.PortalSettings.DestinationTarget);
break;
}
}
cubePortal.PortalSettings.PortalObjectId = fieldPortal.ObjectId;
AddPortal(fieldPortal);
}
}
}
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);
}
}
}
if (MapEntityStorage.HasHealingSpot(MapId))
{
List <CoordS> healingSpots = MapEntityStorage.GetHealingSpot(MapId);
if (State.HealingSpots.IsEmpty)
{
foreach (CoordS coord in healingSpots)
{
int objectId = GuidGenerator.Int();
State.AddHealingSpot(RequestFieldObject(new HealingSpot(objectId, coord)));
}
}
}
}
public FieldManager(int mapId, long instanceId)
{
MapId = mapId;
InstanceId = instanceId;
BoundingBox = MapEntityStorage.GetBoundingBox(mapId);
// Load default npcs for map from config
foreach (MapNpc npc in MapEntityStorage.GetNpcs(mapId))
{
IFieldObject <Npc> fieldNpc = RequestFieldObject(new Npc(npc.Id)
{
ZRotation = (short)(npc.Rotation.Z * 10)
});
if (fieldNpc.Value.Friendly == 2)
{
fieldNpc.Coord = npc.Coord.ToFloat();
AddNpc(fieldNpc);
}
else
{
// NPC is an enemy
IFieldObject <Mob> fieldMob = RequestFieldObject(new Mob(npc.Id)
{
ZRotation = (short)(npc.Rotation.Z * 10)
});
fieldMob.Coord = npc.Coord.ToFloat();
AddMob(fieldMob);
}
}
// Spawn map's mobs at the mob spawners
foreach (MapMobSpawn mobSpawn in MapEntityStorage.GetMobSpawns(mapId))
{
if (mobSpawn.SpawnData == null)
{
Debug.WriteLine($"Missing mob spawn data: {mobSpawn}");
continue;
}
IFieldObject <MobSpawn> fieldMobSpawn = RequestFieldObject(new MobSpawn(mobSpawn));
fieldMobSpawn.Coord = mobSpawn.Coord.ToFloat();
State.AddMobSpawn(fieldMobSpawn);
SpawnMobs(fieldMobSpawn);
}
// Load default portals for map from config
foreach (MapPortal portal in MapEntityStorage.GetPortals(mapId))
{
IFieldObject <Portal> fieldPortal = RequestFieldObject(new Portal(portal.Id)
{
IsVisible = portal.IsVisible,
IsEnabled = portal.Enable,
IsMinimapVisible = portal.MinimapVisible,
Rotation = portal.Rotation.ToFloat(),
TargetMapId = portal.Target,
PortalType = portal.PortalType
});
fieldPortal.Coord = portal.Coord.ToFloat();
AddPortal(fieldPortal);
}
// Load default InteractObjects
List <IFieldObject <InteractObject> > actors = new List <IFieldObject <InteractObject> > {
};
foreach (MapInteractObject interactObject in MapEntityStorage.GetInteractObject(mapId))
{
// TODO: Group these fieldActors by their correct packet type.
actors.Add(RequestFieldObject(new InteractObject(interactObject.Uuid, interactObject.Name, interactObject.Type)
{
}));
}
AddInteractObject(actors);
MapMetadata mapMetadata = MapMetadataStorage.GetMetadata(mapId);
if (mapMetadata != null)
{
string xBlockName = mapMetadata.XBlockName;
Triggers = TriggerLoader.GetTriggers(xBlockName).Select(initializer =>
{
TriggerContext context = new TriggerContext(this, Logger);
TriggerState startState = initializer.Invoke(context);
return(new TriggerScript(context, startState));
}).ToArray();
}
foreach (MapTriggerMesh mapTriggerMesh in MapEntityStorage.GetTriggerMeshes(mapId))
{
if (mapTriggerMesh != null)
{
TriggerMesh triggerMesh = new TriggerMesh(mapTriggerMesh.Id, mapTriggerMesh.IsVisible);
State.AddTriggerObject(triggerMesh);
}
}
foreach (MapTriggerEffect mapTriggerEffect in MapEntityStorage.GetTriggerEffects(mapId))
{
if (mapTriggerEffect != null)
{
TriggerEffect triggerEffect = new TriggerEffect(mapTriggerEffect.Id, mapTriggerEffect.IsVisible);
State.AddTriggerObject(triggerEffect);
}
}
foreach (MapTriggerActor mapTriggerActor in MapEntityStorage.GetTriggerActors(mapId))
{
if (mapTriggerActor != null)
{
TriggerActor triggerActor = new TriggerActor(mapTriggerActor.Id, mapTriggerActor.IsVisible, mapTriggerActor.InitialSequence);
State.AddTriggerObject(triggerActor);
}
}
foreach (MapTriggerCamera mapTriggerCamera in MapEntityStorage.GetTriggerCameras(mapId))
{
if (mapTriggerCamera != null)
{
TriggerCamera triggerCamera = new TriggerCamera(mapTriggerCamera.Id, mapTriggerCamera.IsEnabled);
State.AddTriggerObject(triggerCamera);
}
}
foreach (MapTriggerCube mapTriggerCube in MapEntityStorage.GetTriggerCubes(mapId))
{
if (mapTriggerCube != null)
{
TriggerCube triggerCube = new TriggerCube(mapTriggerCube.Id, mapTriggerCube.IsVisible);
State.AddTriggerObject(triggerCube);
}
}
foreach (MapTriggerLadder mapTriggerLadder in MapEntityStorage.GetTriggerLadders(mapId))
{
if (mapTriggerLadder != null)
{
TriggerLadder triggerLadder = new TriggerLadder(mapTriggerLadder.Id, mapTriggerLadder.IsVisible);
State.AddTriggerObject(triggerLadder);
}
}
foreach (MapTriggerRope mapTriggerRope in MapEntityStorage.GetTriggerRopes(mapId))
{
if (mapTriggerRope != null)
{
TriggerRope triggerRope = new TriggerRope(mapTriggerRope.Id, mapTriggerRope.IsVisible);
State.AddTriggerObject(triggerRope);
}
}
foreach (MapTriggerSound mapTriggerSound in MapEntityStorage.GetTriggerSounds(mapId))
{
if (mapTriggerSound != null)
{
TriggerSound triggerSound = new TriggerSound(mapTriggerSound.Id, mapTriggerSound.IsEnabled);
State.AddTriggerObject(triggerSound);
}
}
// Load breakables
foreach (MapBreakableActorObject mapActor in MapEntityStorage.GetBreakableActors(mapId))
{
if (mapActor != null)
{
BreakableActorObject actor = new BreakableActorObject(mapActor.EntityId, mapActor.IsEnabled, mapActor.HideDuration, mapActor.ResetDuration);
State.AddBreakable(actor);
}
}
foreach (MapBreakableNifObject mapNif in MapEntityStorage.GetBreakableNifs(mapId))
{
if (mapNif != null)
{
BreakableNifObject nif = new BreakableNifObject(mapNif.EntityId, mapNif.IsEnabled, mapNif.TriggerId, mapNif.HideDuration, mapNif.ResetDuration);
State.AddBreakable(nif);
}
}
if (MapEntityStorage.HasHealingSpot(MapId))
{
List <CoordS> healingSpots = MapEntityStorage.GetHealingSpot(MapId);
if (State.HealingSpots.IsEmpty)
{
foreach (CoordS coord in healingSpots)
{
int objectId = GuidGenerator.Int();
State.AddHealingSpot(RequestFieldObject(new HealingSpot(objectId, coord)));
}
}
}
}
public FieldManager(int mapId)
{
MapId = mapId;
BoundingBox = MapEntityStorage.GetBoundingBox(mapId);
// Load default npcs for map from config
foreach (MapNpc npc in MapEntityStorage.GetNpcs(mapId))
{
IFieldObject <Npc> fieldNpc = RequestFieldObject(new Npc(npc.Id)
{
ZRotation = (short)(npc.Rotation.Z * 10)
});
if (fieldNpc.Value.Friendly == 2)
{
fieldNpc.Coord = npc.Coord.ToFloat();
AddNpc(fieldNpc);
}
else
{
// NPC is an enemy
IFieldObject <Mob> fieldMob = RequestFieldObject(new Mob(npc.Id)
{
ZRotation = (short)(npc.Rotation.Z * 10)
});
fieldMob.Coord = npc.Coord.ToFloat();
AddMob(fieldMob);
}
}
// Spawn map's mobs at the mob spawners
foreach (MapMobSpawn mobSpawn in MapEntityStorage.GetMobSpawns(mapId))
{
if (mobSpawn.SpawnData == null)
{
Debug.WriteLine($"Missing mob spawn data: {mobSpawn}");
continue;
}
IFieldObject <MobSpawn> fieldMobSpawn = RequestFieldObject(new MobSpawn(mobSpawn));
fieldMobSpawn.Coord = mobSpawn.Coord.ToFloat();
State.AddMobSpawn(fieldMobSpawn);
SpawnMobs(fieldMobSpawn);
}
// Load default portals for map from config
foreach (MapPortal portal in MapEntityStorage.GetPortals(mapId))
{
IFieldObject <Portal> fieldPortal = RequestFieldObject(new Portal(portal.Id)
{
IsVisible = portal.Flags.HasFlag(MapPortalFlag.Visible),
IsEnabled = portal.Flags.HasFlag(MapPortalFlag.Enabled),
IsMinimapVisible = portal.Flags.HasFlag(MapPortalFlag.MinimapVisible),
Rotation = portal.Rotation.ToFloat(),
TargetMapId = portal.Target,
});
fieldPortal.Coord = portal.Coord.ToFloat();
AddPortal(fieldPortal);
}
// Load default InteractActors
List <IFieldObject <InteractActor> > actors = new List <IFieldObject <InteractActor> > {
};
foreach (MapInteractActor actor in MapEntityStorage.GetInteractActors(mapId))
{
// TODO: Group these fieldActors by their correct packet type.
actors.Add(RequestFieldObject(new InteractActor(actor.Uuid, actor.Name, actor.Type)
{
}));
}
AddInteractActor(actors);
string mapName = MapMetadataStorage.GetMetadata(mapId).Name;
Triggers = TriggerLoader.GetTriggers(mapName).Select(initializer =>
{
TriggerContext context = new TriggerContext(this, Logger);
TriggerState startState = initializer.Invoke(context);
return(new TriggerScript(context, startState));
}).ToArray();
}
/// <summary>
/// Get the coordinates of the skill's effect, if needed change the offset to match the direction of the player.
/// For skills that paint the ground, match the correct height.
/// </summary>
private static List <CoordF> GetEffectCoords(SkillCast skillCast, int mapId, int attackIndex)
{
SkillAttack skillAttack = skillCast.SkillAttack;
List <MagicPathMove> cubeMagicPathMoves = new();
List <MagicPathMove> magicPathMoves = new();
if (skillAttack.CubeMagicPathId != 0)
{
cubeMagicPathMoves.AddRange(MagicPathMetadataStorage.GetMagicPath(skillAttack.CubeMagicPathId)?.MagicPathMoves ?? new());
}
if (skillAttack.MagicPathId != 0)
{
magicPathMoves.AddRange(MagicPathMetadataStorage.GetMagicPath(skillAttack.MagicPathId)?.MagicPathMoves ?? new());
}
int skillMovesCount = cubeMagicPathMoves.Count + magicPathMoves.Count;
List <CoordF> effectCoords = new();
if (skillMovesCount <= 0)
{
effectCoords.Add(skillCast.Position);
return(effectCoords);
}
// TODO: Handle case where magicPathMoves and cubeMagicPathMoves counts are > 0
// Basically do the next if, with the later for loop
if (magicPathMoves.Count > 0)
{
MagicPathMove magicPathMove = magicPathMoves[attackIndex];
IFieldActor <NpcMetadata> parentSkillTarget = skillCast.ParentSkill.Target;
if (parentSkillTarget is not null)
{
effectCoords.Add(parentSkillTarget.Coord);
return(effectCoords);
}
// Rotate the offset coord and distance based on the look direction
CoordF rotatedOffset = CoordF.From(magicPathMove.FireOffsetPosition.Length(), skillCast.LookDirection);
CoordF distance = CoordF.From(magicPathMove.Distance, skillCast.LookDirection);
// Create new effect coord based on offset rotation and distance
effectCoords.Add(rotatedOffset + distance + skillCast.Position);
return(effectCoords);
}
// Adjust the effect on the destination/cube
foreach (MagicPathMove cubeMagicPathMove in cubeMagicPathMoves)
{
CoordF offSetCoord = cubeMagicPathMove.FireOffsetPosition;
// If false, rotate the offset based on the look direction. Example: Wizard's Tornado
if (!cubeMagicPathMove.IgnoreAdjust)
{
// Rotate the offset coord based on the look direction
CoordF rotatedOffset = CoordF.From(offSetCoord.Length(), skillCast.LookDirection);
// Create new effect coord based on offset rotation and source coord
effectCoords.Add(rotatedOffset + skillCast.Position);
continue;
}
offSetCoord += Block.ClosestBlock(skillCast.Position);
CoordS tempBlockCoord = offSetCoord.ToShort();
// Set the height to the max allowed, which is one block above the cast coord.
tempBlockCoord.Z += Block.BLOCK_SIZE * 2;
// Find the first block below the effect coord
int distanceToNextBlockBelow = MapMetadataStorage.GetDistanceToNextBlockBelow(mapId, offSetCoord.ToShort(), out MapBlock blockBelow);
// If the block is null or the distance from the cast effect Z height is greater than two blocks, continue
if (blockBelow is null || distanceToNextBlockBelow > Block.BLOCK_SIZE * 2)
{
continue;
}
// If there is a block above, continue
if (MapMetadataStorage.BlockAboveExists(mapId, blockBelow.Coord))
{
continue;
}
// If block is liquid, continue
if (MapMetadataStorage.IsLiquidBlock(blockBelow))
{
continue;
}
// Since this is the block below, add 150 units to the Z coord so the effect is above the block
offSetCoord = blockBelow.Coord.ToFloat();
offSetCoord.Z += Block.BLOCK_SIZE;
effectCoords.Add(offSetCoord);
}
return(effectCoords);
}
public override void Handle(GameSession session, PacketReader packet)
{
packet.ReadInt(); // ?
// Liftable: 00 00 00 00 00
// SendBreakable
// Self
Player player = session.Player;
Account account = player.Account;
session.EnterField(player);
session.Send(StatPacket.SetStats(player.FieldPlayer));
session.Send(StatPointPacket.WriteTotalStatPoints(player));
session.Send(StatPointPacket.WriteTotalStatPoints(player)); // This packet is sent twice on GMS, not sure why
session.Send(StatPointPacket.WriteStatPointDistribution(player));
session.Send(SkillPointPacket.ExtraSkillPoints(player));
if (player.ActivePet is not null)
{
player.ActivePet.SetMetadataValues();
Pet pet = session.FieldManager.RequestPet(player.ActivePet, player.FieldPlayer);
if (pet is not null)
{
player.FieldPlayer.ActivePet = pet;
session.Send(ResponsePetPacket.LoadPetSettings(pet));
session.Send(NoticePacket.Notice(SystemNotice.PetSummonOn, NoticeType.Chat | NoticeType.FastText));
}
}
if (account.IsVip())
{
session.Send(BuffPacket.SendBuff(0,
new(100000014, player.FieldPlayer.ObjectId, player.FieldPlayer.ObjectId, 1, (int)account.VIPExpiration, 1)));
session.Send(PremiumClubPacket.ActivatePremium(player.FieldPlayer, account.VIPExpiration));
}
session.Send(EmotePacket.LoadEmotes(player));
session.Send(MacroPacket.LoadControls(player.Macros));
session.Send(ChatStickerPacket.LoadChatSticker(player));
session.Send(ResponseCubePacket.DecorationScore(account.Home));
session.Send(ResponseCubePacket.LoadHome(player.FieldPlayer.ObjectId, player.Account.Home));
session.Send(ResponseCubePacket.ReturnMap(player.ReturnMapId));
session.Send(LapenshardPacket.Load(player.Inventory.LapenshardStorage));
IEnumerable <Cube> cubes = session.FieldManager.State.Cubes.Values
.Where(x => x.Value.PlotNumber == 1 && x.Value.Item.HousingCategory is ItemHousingCategory.Farming or ItemHousingCategory.Ranching)
.Select(x => x.Value);
foreach (Cube cube in cubes)
{
session.Send(FunctionCubePacket.UpdateFunctionCube(cube.CoordF.ToByte(), 2, 1));
}
if (player.Party is not null)
{
session.Send(PartyPacket.UpdatePlayer(player));
}
GlobalEvent globalEvent = GameServer.GlobalEventManager.GetCurrentEvent();
if (globalEvent is not null && !MapMetadataStorage.MapIsInstancedOnly(player.MapId))
{
session.Send(GlobalPortalPacket.Notice(globalEvent));
}
FieldWar fieldWar = GameServer.FieldWarManager.CurrentFieldWar;
if (fieldWar is not null && !MapMetadataStorage.MapIsInstancedOnly(player.MapId) && fieldWar.MapId != player.MapId)
{
session.Send(FieldWarPacket.LegionPopup(fieldWar.Id, fieldWar.EntryClosureTime.ToUnixTimeSeconds()));
}
session.Send(KeyTablePacket.SendHotbars(player.GameOptions));
TrophyManager.OnMapEntered(player, player.MapId);
QuestManager.OnMapEnter(player, player.MapId);
player.InitializeEffects();
}
public FieldWar(int id)
{
Id = id;
MapId = FieldWarMetadataStorage.MapId(id);
List <Player> onlinePlayers = GameServer.PlayerManager.GetAllPlayers().Where(x => !MapMetadataStorage.MapIsInstancedOnly(x.MapId)).ToList();
DateTimeOffset now = DateTimeOffset.UtcNow;
EntryClosureTime = now.AddSeconds(-now.Second).AddMinutes(5);
foreach (Player player in onlinePlayers)
{
player.Session.Send(FieldWarPacket.LegionPopup(id, EntryClosureTime.ToUnixTimeSeconds()));
}
}
protected override void EndSession(bool logoutNotice)
{
if (Player is null || FieldManager is null)
{
return;
}
FieldManager.RemovePlayer(Player);
GameServer.PlayerManager.RemovePlayer(Player);
Player.OnlineCTS.Cancel();
Player.OnlineTimeThread = null;
CoordF safeCoord = Player.SafeBlock;
safeCoord.Z += Block.BLOCK_SIZE;
Player.SavedCoord = safeCoord;
// if session is not changing channels or servers, send the logout message
if (logoutNotice)
{
Player.Session = null;
GameServer.BuddyManager.SetFriendSessions(Player);
Player.Party?.CheckOfflineParty(Player);
Player.Guild?.BroadcastPacketGuild(GuildPacket.MemberLoggedOff(Player));
Player.UpdateBuddies();
foreach (Club club in Player.Clubs)
{
club?.BroadcastPacketClub(ClubPacket.LogoutNotice(Player, club));
}
foreach (GroupChat groupChat in Player.GroupChats)
{
groupChat?.BroadcastPacketGroupChat(GroupChatPacket.LogoutNotice(groupChat, Player));
groupChat?.CheckOfflineGroupChat();
}
Player.IsMigrating = false;
if (MapMetadataStorage.MapIsInstancedOnly(Player.MapId) && !MapMetadataStorage.MapIsTutorial(Player.MapId))
{
Player.SavedCoord = Player.ReturnCoord;
Player.MapId = Player.ReturnMapId;
}
AuthData authData = Player.Account.AuthData;
authData.OnlineCharacterId = 0;
DatabaseManager.AuthData.UpdateOnlineCharacterId(authData);
}
List <GameEventUserValue> userTimeValues = Player.EventUserValues.Where(x => x.EventType == GameEventUserValueType.AttendanceAccumulatedTime).ToList();
foreach (GameEventUserValue userValue in userTimeValues)
{
if (!long.TryParse(userValue.EventValue, out long timeAccumulated))
{
timeAccumulated = 0;
}
timeAccumulated += TimeInfo.Now() - Player.LastLogTime;
userValue.EventValue = timeAccumulated.ToString();
DatabaseManager.GameEventUserValue.Update(userValue);
}
Player.LastLogTime = TimeInfo.Now();
Player.Account.LastLogTime = TimeInfo.Now();
if (Player.GuildMember is not null)
{
Player.GuildMember.LastLogTimestamp = TimeInfo.Now();
}
DatabaseManager.Characters.Update(Player);
}