public bool LevelUp()
{
if (!ExpMetadataStorage.LevelExist((short)(Level + 1)))
{
return(false);
}
Level++;
Player.Stats.AddBaseStats(Player);
Player.FieldPlayer.RecoverHp(FieldPlayer.Stats[StatId.Hp].Bonus);
Session.FieldManager.BroadcastPacket(RevivalConfirmPacket.Send(FieldPlayer.ObjectId, 0));
Session.FieldManager.BroadcastPacket(LevelUpPacket.LevelUp(FieldPlayer.ObjectId, Level));
Session.FieldManager.BroadcastPacket(FieldObjectPacket.UpdateCharacterLevel(Player));
Session.FieldManager.BroadcastPacket(JobPacket.SendJob(FieldPlayer));
Session.Send(StatPacket.SetStats(FieldPlayer));
Session.FieldManager.BroadcastPacket(StatPacket.UpdateFieldStats(FieldPlayer), Session);
Session.Send(KeyTablePacket.SendFullOptions(Player.GameOptions));
TrophyManager.OnLevelUp(Player);
QuestHelper.GetNewQuests(Player);
return(true);
}
// Gets a list of packets to update the state of all field objects for client.
public IEnumerable <Packet> GetUpdates()
{
List <Packet> updates = new List <Packet>();
// Update players locations
// Update NPCs
foreach (IFieldObject <Npc> npc in State.Npcs.Values)
{
updates.Add(FieldObjectPacket.ControlNpc(npc));
}
foreach (IFieldObject <Player> player in State.Players.Values)
{
updates.Add(FieldObjectPacket.UpdatePlayer(player));
}
foreach (IFieldObject <Mob> mob in State.Mobs.Values)
{
updates.Add(FieldObjectPacket.ControlMob(mob));
if (mob.Value.IsDead)
{
RemoveMob(mob);
}
}
foreach (TriggerScript trigger in Triggers)
{
trigger.Next();
}
return(updates);
}
public void GainExp(long amount)
{
if (amount <= 0 || !ExpMetadataStorage.LevelExist((short)(Level + 1)))
{
return;
}
long newExp = Exp + amount + RestExp;
if (RestExp > 0)
{
RestExp -= amount;
}
else
{
RestExp = 0;
}
bool hasLeveledUp = false;
while (newExp >= ExpMetadataStorage.GetExpToLevel(Level))
{
newExp -= ExpMetadataStorage.GetExpToLevel(Level);
if (LevelUp())
{
hasLeveledUp = true;
continue;
}
newExp = 0;
break;
}
Exp = newExp;
Session.Send(ExperiencePacket.ExpUp(amount, newExp, RestExp));
if (!hasLeveledUp)
{
return;
}
Session.FieldManager.BroadcastPacket(RevivalConfirmPacket.Send(FieldPlayer.ObjectId, 0));
Session.FieldManager.BroadcastPacket(LevelUpPacket.LevelUp(FieldPlayer.ObjectId, Level));
Session.FieldManager.BroadcastPacket(FieldObjectPacket.UpdateCharacterLevel(Player));
// Find all new skills for current level
HashSet <int> newSkillIds = SkillMetadataStorage.GetJobSkills(Player.Job)
.Where(x => x.SkillLevels.First().SkillUpgrade.LevelRequired == Level)
.Select(x => x.SkillId).ToHashSet();
Session.FieldManager.BroadcastPacket(JobPacket.UpdateSkillTab(FieldPlayer, newSkillIds));
Session.Send(StatPacket.SetStats(FieldPlayer));
Session.FieldManager.BroadcastPacket(StatPacket.SetStats(FieldPlayer), Session);
Session.Send(KeyTablePacket.SendFullOptions(Player.GameOptions));
DatabaseManager.Characters.Update(Player);
}
public void AddTestNpc(IFieldObject <Npc> fieldNpc)
{
State.AddNpc(fieldNpc);
Broadcast(session => {
session.Send(FieldPacket.AddNpc(fieldNpc));
session.Send(FieldObjectPacket.LoadNpc(fieldNpc));
});
}
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.InteractActors.Values.Count > 0)
{
sender.Send(InteractActorPacket.AddInteractActors(State.InteractActors.Values));
}
if (MapEntityStorage.HasHealingSpot(MapId))
{
if (HealingSpotThread == null || HealingSpotThread.IsCompleted)
{
HealingSpotThread = StartHealingSpot(sender, player);
}
sender.Send(RegionSkillPacket.Send(player, MapEntityStorage.GetHealingSpot(MapId), new SkillCast(70000018, 1, 0, 1)));
}
State.AddPlayer(player);
// Broadcast new player to all players in map
Broadcast(session =>
{
session.Send(FieldPacket.AddPlayer(player));
session.Send(FieldObjectPacket.LoadPlayer(player));
});
}
public void AddMob(IFieldObject <Mob> fieldMob)
{
State.AddMob(fieldMob);
Broadcast(session =>
{
session.Send(FieldPacket.AddMob(fieldMob));
session.Send(FieldObjectPacket.LoadMob(fieldMob));
});
}
public void SetLevel(short level)
{
Level = level;
Exp = 0;
Session.Send(ExperiencePacket.ExpUp(0, Exp, 0));
Session.FieldManager.BroadcastPacket(LevelUpPacket.LevelUp(FieldPlayer.ObjectId, Level));
Session.FieldManager.BroadcastPacket(FieldObjectPacket.UpdateCharacterLevel(Player));
QuestHelper.GetNewQuests(Player);
}
// Spawned NPCs will not appear until controlled
public void AddNpc(GameSession sender, Npc npc)
{
FieldObject <Npc> fieldNpc = WrapObject(npc);
fieldNpc.Coord = sender.FieldPlayer.Coord; // Spawn NPC on player for now
State.AddNpc(fieldNpc);
Broadcast(session => {
session.Send(FieldPacket.AddNpc(fieldNpc));
session.Send(FieldObjectPacket.LoadNpc(fieldNpc));
});
}
public void AddMob(IFieldObject <Mob> fieldMob)
{
State.AddMob(fieldMob);
fieldMob.Value.OriginSpawn.Value.Mobs.Add(fieldMob);
Broadcast(session =>
{
session.Send(FieldPacket.AddMob(fieldMob));
session.Send(FieldObjectPacket.LoadMob(fieldMob));
// TODO: Add spawn buff (ID: 0x055D4DAE)
});
}
public bool RemoveNpc(IFieldObject <Npc> fieldNpc)
{
if (!State.RemoveNpc(fieldNpc.ObjectId))
{
return(false);
}
Broadcast(session =>
{
// TODO: Add field remove NPC packet
session.Send(FieldObjectPacket.RemoveNpc(fieldNpc));
});
return(true);
}
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.InteractActors.Values.Count > 0)
{
sender.Send(InteractActorPacket.AddInteractActors(State.InteractActors.Values));
}
State.AddPlayer(player);
// Broadcast new player to all players in map
Broadcast(session =>
{
session.Send(FieldPacket.AddPlayer(player));
session.Send(FieldObjectPacket.LoadPlayer(player));
});
}
public void RemovePlayer(GameSession sender, IFieldObject <Player> player)
{
lock (Sessions)
{
Sessions.Remove(sender);
}
State.RemovePlayer(player.ObjectId);
// Remove player
Broadcast(session =>
{
session.Send(FieldPacket.RemovePlayer(player));
session.Send(FieldObjectPacket.RemovePlayer(player));
});
((FieldObject <Player>)player).ObjectId = -1; // Reset object id
}
// Gets a list of packets to update the state of all field objects for client.
public IEnumerable <Packet> GetUpdates()
{
List <Packet> updates = new List <Packet>();
// Update players locations
// Update NPCs
foreach (IFieldObject <Npc> npc in State.Npcs.Values)
{
updates.Add(FieldObjectPacket.ControlNpc(npc));
}
foreach (IFieldObject <Player> player in State.Players.Values)
{
updates.Add(FieldObjectPacket.UpdatePlayer(player));
}
return(updates);
}
public bool RemoveMob(IFieldObject <Mob> mob)
{
if (!State.RemoveMob(mob.ObjectId))
{
return(false);
}
IFieldObject <MobSpawn> originSpawn = mob.Value.OriginSpawn;
if (originSpawn != null && originSpawn.Value.Mobs.Remove(mob) && originSpawn.Value.Mobs.Count == 0)
{
StartSpawnTimer(originSpawn);
}
Broadcast(session =>
{
session.Send(FieldPacket.RemoveMob(mob));
session.Send(FieldObjectPacket.RemoveMob(mob));
});
return(true);
}
private void HandleEquipItem(GameSession session, PacketReader packet)
{
long itemUid = packet.ReadLong();
string equipSlotStr = packet.ReadUnicodeString();
if (!Enum.TryParse(equipSlotStr, out ItemSlot equipSlot))
{
logger.Warning("Unknown equip slot: " + equipSlotStr);
return;
}
// Remove the item from the users inventory
session.Player.Inventory.Remove(itemUid, out Item item);
session.Send(ItemInventoryPacket.Remove(itemUid));
// TODO: Move unequipped item into the correct slot
// Move previously equipped item back to inventory
if (session.Player.Equips.Remove(equipSlot, out Item prevItem))
{
session.Player.Inventory.Add(prevItem);
session.Send(ItemInventoryPacket.Add(prevItem));
session.FieldManager.BroadcastPacket(EquipmentPacket.UnequipItem(session.FieldPlayer, prevItem));
}
// Equip new item
session.Player.Equips[equipSlot] = item;
session.FieldManager.BroadcastPacket(EquipmentPacket.EquipItem(session.FieldPlayer, item, equipSlot));
// TODO - Increase stats based on the item stats itself
session.Player.Stats.CritRate.Max += 12;
session.Player.Stats.CritRate.Total += 12;
session.Player.Stats.MinAtk.Max += 15;
session.Player.Stats.MinAtk.Total += 15;
session.Player.Stats.MaxAtk.Max += 17;
session.Player.Stats.MaxAtk.Total += 17;
session.Send(FieldObjectPacket.SetStats(session.FieldPlayer));
}
public override void Handle(GameSession session, PacketReader packet)
{
packet.ReadInt(); // ?
// Liftable: 00 00 00 00 00
// SendBreakable
// Self
session.EnterField(session.Player.MapId);
session.Send(FieldObjectPacket.SetStats(session.FieldPlayer));
session.Send(EmotePacket.LoadEmotes());
// Normally skill layout would be loaded from a database
QuickSlot arrowStream = QuickSlot.From(10500001);
QuickSlot arrowBarrage = QuickSlot.From(10500011);
QuickSlot eagleGlide = QuickSlot.From(10500151);
QuickSlot testSkill = QuickSlot.From(10500153);
if (session.Player.GameOptions.TryGetHotbar(0, out Hotbar mainHotbar))
{
/*
* mainHotbar.MoveQuickSlot(4, arrowStream);
* mainHotbar.MoveQuickSlot(5, arrowBarrage);
* mainHotbar.MoveQuickSlot(6, eagleGlide);
* mainHotbar.MoveQuickSlot(7, testSkill);
*/
session.Send(KeyTablePacket.SendHotbars(session.Player.GameOptions));
}
// Add catalysts for testing
/*
* int[] catalysts = { 40100001, 40100002, 40100003, 40100021, 40100023, 40100024, 40100026 };
* foreach (int catalyst in catalysts) {
* var item = new Item(catalyst) { Amount = 99999, Uid = catalyst };
* session.Inventory.Add(item);
* session.Send(ItemInventoryPacket.Add(item));
* }
*/
}
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));
});
}
public override void Handle(GameSession session, PacketReader packet)
{
packet.ReadInt(); // ?
// Liftable: 00 00 00 00 00
// SendBreakable
// Self
session.EnterField(session.Player.MapId);
session.Send(FieldObjectPacket.SetStats(session.FieldPlayer));
session.Send(EmotePacket.LoadEmotes());
// Normally skill layout would be loaded from a database
QuickSlot arrowStream = QuickSlot.From(10500001);
QuickSlot arrowBarrage = QuickSlot.From(10500011);
QuickSlot eagleGlide = QuickSlot.From(10500151);
QuickSlot testSkill = QuickSlot.From(10500153);
if (session.Player.GameOptions.TryGetHotbar(0, out Hotbar mainHotbar))
{
/*
* mainHotbar.MoveQuickSlot(4, arrowStream);
* mainHotbar.MoveQuickSlot(5, arrowBarrage);
* mainHotbar.MoveQuickSlot(6, eagleGlide);
* mainHotbar.MoveQuickSlot(7, testSkill);
*/
session.Send(KeyTablePacket.SendHotbars(session.Player.GameOptions));
}
// Add catalysts for testing
var item = new Item(40100001)
{
Amount = 99999
};
var item2 = new Item(40100001)
{
Amount = 90000
};
var item3 = new Item(40100001)
{
Amount = 10000
};
InventoryController.Add(session, item);
InventoryController.Add(session, item2);
InventoryController.Add(session, item3);
//Add mail for testing
//System mail without any item
Mail sysMail = new Mail
(
101,
session.Player.CharacterId,
"50000002",
"",
"",
0,
DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
null
);
// System mail with an item
List <Item> items = new List <Item>
{
new Item(20302228)
{
CreationTime = DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
Owner = session.Player,
Amount = 10
}
};
Mail sysItemMail = new Mail
(
101,
session.Player.CharacterId,
"53000042",
"",
"",
0,
DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
items
);
// Regular mail
Mail regMail = new Mail
(
1,
session.Player.CharacterId,
session.Player.Name,
"Test Title",
"Test Body",
0,
DateTimeOffset.UtcNow.ToUnixTimeSeconds(),
null
);
session.Player.Mailbox.AddOrUpdate(sysItemMail);
session.Player.Mailbox.AddOrUpdate(sysMail);
session.Player.Mailbox.AddOrUpdate(regMail);
}
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.Values.Count > 0)
{
sender.Send(CubePacket.LoadCubes(State.Cubes.Values));
}
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));
}
}
State.AddPlayer(player);
if (!State.HealingSpots.IsEmpty)
{
if (HealingSpotThread == null)
{
HealingSpotThread = StartHealingSpot();
}
}
// Broadcast new player to all players in map
Broadcast(session =>
{
session.Send(FieldPacket.AddPlayer(player));
session.Send(FieldObjectPacket.LoadPlayer(player));
});
}
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
}
}
