private void HandleDisconnected(ITcpSocket socket)
{
NecClient client;
lock (_lock)
{
if (!_clients.ContainsKey(socket))
{
_logger.Error(socket, $"[{_identity}] Disconnected client does not exist in lookup");
return;
}
client = _clients[socket];
_clients.Remove(socket);
_logger.Debug($"[{_identity}] Clients Count: {_clients.Count}");
}
Action <NecClient> onClientDisconnected = ClientDisconnected;
if (onClientDisconnected != null)
{
try
{
onClientDisconnected.Invoke(client);
}
catch (Exception ex)
{
_logger.Exception(client, ex);
}
}
_logger.Info(client, $"[{_identity}] Client disconnected");
}
public override void Handle(NecClient client, NecPacket packet)
{
ItemZoneType fromZone = (ItemZoneType)packet.data.ReadByte();
byte fromBag = packet.data.ReadByte();
short fromSlot = packet.data.ReadInt16();
ItemZoneType toZone = (ItemZoneType)packet.data.ReadByte();
byte toBag = packet.data.ReadByte();
short toSlot = packet.data.ReadInt16();
byte quantity = packet.data.ReadByte();
_Logger.Debug($"fromStoreType byte [{fromZone}] toStoreType byte [{toZone}]");
_Logger.Debug($"fromBagId byte [{fromBag}] toBagId byte [{toBag}]");
_Logger.Debug($"fromSlot byte [{fromSlot}] toSlot[{toSlot}]");
_Logger.Debug($"itemCount [{quantity}]");
ItemLocation fromLoc = new ItemLocation(fromZone, fromBag, fromSlot);
ItemLocation toLoc = new ItemLocation(toZone, toBag, toSlot);
ItemService itemService = new ItemService(client.character);
int error = 0;
try
{
MoveResult moveResult = itemService.Move(fromLoc, toLoc, quantity);
List <PacketResponse> responses = itemService.GetMoveResponses(client, moveResult);
router.Send(client, responses);
}
catch (ItemException e)
{
error = (int)e.type;
}
RecvStorageDrawItem2 recvStorageDrawItem2 = new RecvStorageDrawItem2(client, error);
router.Send(recvStorageDrawItem2);
}
public override void Handle(NecClient client, NecPacket packet)
{
/*int32, unknown
* int32, target client(character) id[i think this is the sends structure]*/
int unknown = packet.Data.ReadInt32();
uint targetInstanceId = packet.Data.ReadUInt32();
NecClient targetClient = Server.Clients.GetByCharacterInstanceId(targetInstanceId);
targetClient.Character.partyRequest = client.Character.InstanceId;
if (targetInstanceId == 0)
{
targetInstanceId = client.Character.InstanceId;
} //band-aid for null reference errors while testing. to-do Delete this line.
Logger.Debug(
$"ID {client.Character.InstanceId} {client.Character.Name} sent a party invite to {targetClient.Character.Name} with instance ID {targetInstanceId}");
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(targetInstanceId);
Router.Send(client, (ushort)AreaPacketId.recv_party_invite_r, res, ServerType.Area);
SendPartyNotifyInvite(client, targetInstanceId);
}
protected override void HandleDisconnected(ITcpSocket socket)
{
NecConnection connection;
lock (_lock)
{
if (!_connections.ContainsKey(socket))
{
_Logger.Error(socket, $"[{_serverType}] Disconnected client does not exist in lookup");
return;
}
connection = _connections[socket];
_connections.Remove(socket);
_Logger.Debug($"[{_serverType}] Clients Count: {_connections.Count}");
}
Action <NecConnection> onClientDisconnected = clientDisconnected;
if (onClientDisconnected != null)
{
try
{
onClientDisconnected.Invoke(connection);
}
catch (Exception ex)
{
_Logger.Exception(connection, ex);
}
}
_Logger.Info(connection, $"[{_serverType}] Client disconnected");
}
public override void Handle(NecClient client, NecPacket packet)
{
byte isBuyout = packet.data.ReadByte();
int slot = packet.data.ReadInt32();
ulong bid = packet.data.ReadUInt64();
_Logger.Debug(isBuyout + " " + slot + " " + bid);
int auctionError = 0;
ItemService itemService = new ItemService(client.character);
try
{
itemService.Bid(isBuyout, slot, bid);
}
catch (AuctionException e)
{
auctionError = (int)e.type;
_Logger.Debug(e.ToString());
}
IBuffer res = BufferProvider.Provide();
res.WriteInt32(auctionError);
router.Send(client.map, (ushort)AreaPacketId.recv_auction_bid_r, res, ServerType.Area);
}
public override void Handle(NecClient client, NecPacket packet)
{
int unknown1 = packet.data.ReadInt32();
uint instanceId = packet.data.ReadUInt32();
int unknown2 = packet.data.ReadInt32();
client.character.eventSelectReadyCode = instanceId;
_Logger.Debug($"Just attacked Target {client.character.eventSelectReadyCode}");
int damage = client.character.battleParam.plusPhysicalAttack;
int seed = Util.GetRandomNumber(0, 20);
if (seed < 2)
{
damage += Util.GetRandomNumber(1, 4); // Light hit
}
else if (seed < 19)
{
damage += Util.GetRandomNumber(16, 24); // Normal hit
}
else
{
damage *= 2;
}
damage += Util.GetRandomNumber(32, 48); // Critical hit
if (client.account.state == AccountStateType.Admin)
{
damage *= 100; //testing death and revival is slow with low dmg.
}
AttackObjectsInRange(client, damage);
SendBattleAttackExecR(client);
}
public override void Handle(NecClient client, NecPacket packet)
{
int characterId = packet.data.ReadInt32();
Character character = database.SelectCharacterById(characterId);
if (character == null)
{
_Logger.Error(client, $"No character for CharacterId: {characterId}");
client.Close();
return;
}
server.instances.AssignInstance(character);
client.character = character;
client.character.criminalState = client.soul.criminalLevel;
client.UpdateIdentity();
client.character.CreateTask(server, client);
_Logger.Debug(client, $"Selected Character: {character.name}");
IBuffer res3 = BufferProvider.Provide();
res3.WriteInt32(0); //ERR-CHARSELECT error check
res3.WriteUInt32(client.character.instanceId);
//sub_4E4210_2341
res3.WriteInt32(client.character.mapId);
res3.WriteInt32(client.character.mapId);
res3.WriteInt32(client.character.mapId);
res3.WriteByte(0);
res3.WriteByte(0); //Bool
res3.WriteFixedString(settings.dataAreaIpAddress, 0x41); //IP
res3.WriteUInt16(settings.areaPort); //Port
res3.WriteFloat(client.character.x);
res3.WriteFloat(client.character.y);
res3.WriteFloat(client.character.z);
res3.WriteByte(client.character.heading);
router.Send(client, (ushort)MsgPacketId.recv_chara_select_r, res3, ServerType.Msg);
/*
* ERR_CHARSELECT GENERIC Failed to select a character (CODE:<errcode>)
* ERR_CHARSELECT -8 Maintenance
* ERR_CHARSELECT -13 You have selected an illegal character
*/
//Logic to support your dead body //Make this static. need a predictable deadbody instance ID to support disconnect/reconnet
DeadBody deadBody = new DeadBody();
deadBody.id = character.id;
server.instances.AssignInstance(deadBody);
character.deadBodyInstanceId = deadBody.instanceId;
deadBody.characterInstanceId = character.instanceId;
_Logger.Debug($"Dead Body Instance ID {deadBody.instanceId} | Character Instance ID {character.instanceId}");
}
public void Logout(DateTime logoutTime, byte logoutType)
{
lock (LogoutLock)
{
_logoutTime = logoutTime;
_logoutType = logoutType;
}
Logger.Debug($"logoutTime [{logoutTime}] _logoutType [{_logoutType}]");
}
public override void Handle(NecClient client, NecPacket packet)
{
ItemZoneType zoneType = (ItemZoneType)packet.data.ReadInt32();
byte container = packet.data.ReadByte();
int itemsToSort = packet.data.ReadInt32();
_Logger.Debug($"zoneType [{zoneType}] container [{container}] itemCount [{itemsToSort}]");
short[] fromSlots = new short[itemsToSort];
short[] toSlots = new short[itemsToSort];
short[] quantities = new short[itemsToSort];
for (int i = 0; i < itemsToSort; i++)
{
fromSlots[i] = packet.data.ReadInt16();
toSlots[i] = packet.data.ReadInt16();
quantities[i] = packet.data.ReadInt16();
_Logger.Debug($"fromSlot short [{fromSlots[i]}] toSlot short [{toSlots[i]}] amount [{quantities[i]}]");
}
ItemService itemService = new ItemService(client.character);
int error = 0;
try
{
for (int i = 0; i < itemsToSort; i++)
{
ItemLocation fromLoc = new ItemLocation(zoneType, container, fromSlots[i]);
ItemLocation toLoc = new ItemLocation(zoneType, container, toSlots[i]);
byte quantity = (byte)quantities[i];
MoveResult moveResult = itemService.Move(fromLoc, toLoc, quantity);
List <PacketResponse> responses = itemService.GetMoveResponses(client, moveResult);
router.Send(client, responses);
}
}
catch (ItemException e)
{
error = (int)e.type;
}
catch (Exception e1)
{
error = (int)ItemExceptionType.Generic;
_Logger.Exception(client, e1);
}
IBuffer res = BufferProvider.Provide();
res.WriteInt32(error);
router.Send(client, (ushort)AreaPacketId.recv_item_sort_r, res, ServerType.Area);
}
public DropItem GetLoot(int monsterId)
{
monsterId = 40101; // All monsters are beetles for now!!
int roll = LootRoll();
DropTable monsterDrop = dropTables.Find(x => x.MonsterId == monsterId);
DropItem dropItem = null;
if (monsterDrop != null)
{
List <DropTableItem> ItemDrop = monsterDrop.FindAll(roll);
if (ItemDrop.Count == 1)
{
Logger.Debug($"ItemId [ItemDrop ItemId {ItemDrop[0].ItemId}]");
if (!_server.SettingRepository.Items.TryGetValue(ItemDrop[0].ItemId, out ItemSetting itemSetting))
{
Logger.Error($"Could not retrieve ItemSettings for ItemId [{ItemDrop[0].ItemId}]");
return(null);
}
Logger.Debug($"ItemId [ItemDrop ItemId {ItemDrop[0].ItemId}]");
if (itemSetting.Id == 10200101)
{
itemSetting.IconType = 2;
}
else if (itemSetting.Id == 80000101)
{
itemSetting.IconType = 55;
}
Item item = _server.Instances64
.CreateInstance <Item>(); // Need to get fully populated Item repository
item.AddItemSetting(itemSetting);
int numItems = GetNumberItems(ItemDrop[0].MinItems, ItemDrop[0].Maxitems + 1);
dropItem = new DropItem(numItems, item);
}
}
else
{
if (!_server.SettingRepository.Items.TryGetValue(50100301, out ItemSetting itemSetting))
{
Logger.Error($"Could not retrieve ItemSettings for default Item Camp");
return(null);
}
Item item = new Item(); // Need to get fully populated Item repository
item.IconType = 45;
item.ItemType = 1;
dropItem = new DropItem(1, item);
}
return(dropItem);
}
public override void Handle(NecClient client, NecPacket packet)
{
ItemService itemService = new ItemService(client.character);
int result = 0;
int instanceId = packet.data.ReadInt32();
MonsterSpawn monster = client.map.GetMonsterByInstanceId((uint)instanceId);
_Logger.Debug($"{client.character.name} is trying to loot object {instanceId}. Inventory Space {client.character.itemLocationVerifier.GetTotalFreeSpace(ItemZoneType.AdventureBag)}");
ItemLocation nextOpenLocation = client.character.itemLocationVerifier.NextOpenSlot(ItemZoneType.AdventureBag);
if (monster == null)
{
result = -10;
}
else if (monster.loot.itemCountRng == 0)
{
result = -1;
}
else if (nextOpenLocation.zoneType == ItemZoneType.InvalidZone)
{
result = -207; //expand to all inventory. TODO
}
IBuffer res2 = BufferProvider.Provide();
res2.WriteInt32(result);
router.Send(client, (ushort)AreaPacketId.recv_loot_access_object_r, res2, ServerType.Area);
//LOOT, -1, I don't have anything. , SYSTEM_WARNING,
//LOOT, -10, no route target, SYSTEM_WARNING,
//LOOT, -207, There is no space in the inventory. , SYSTEM_WARNING,
//LOOT, -1500, no root authority. , SYSTEM_WARNING,
if (result == 0)
{
IBuffer res = BufferProvider.Provide();
res.WriteInt32(2);
router.Send(client, (ushort)AreaPacketId.recv_situation_start, res, ServerType.Area);
int itemId = monster.loot.dropTableItemSerialIds[monster.loot.itemCountRng];
ItemSpawnParams spawmParam = new ItemSpawnParams();
spawmParam.itemStatuses = ItemStatuses.Identified;
ItemInstance itemInstance = itemService.SpawnItemInstance(ItemZoneType.AdventureBag, itemId, spawmParam);
_Logger.Debug(itemInstance.type.ToString());
RecvItemInstance recvItemInstance = new RecvItemInstance(client, itemInstance);
router.Send(client, recvItemInstance.ToPacket());
monster.loot.itemCountRng--; //decrement available items
res = BufferProvider.Provide();
router.Send(client, (ushort)AreaPacketId.recv_situation_end, res, ServerType.Area);
}
}
public override void Handle(NecClient client, NecPacket packet)
{
uint partyInstanceId = packet.data.ReadUInt32();
_Logger.Debug($"character {client.character.name} accepted invite to party ID {partyInstanceId}");
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(0); //error check?
router.Send(client, (ushort)AreaPacketId.recv_party_accept_to_invite_r, res, ServerType.Area);
Party myParty = server.instances.GetInstance(partyInstanceId) as Party;
if (!myParty.partyMembers.Contains(client))
{
myParty.Join(client);
}
foreach (NecClient partyClient in myParty.partyMembers)
{
//Sanity check. Who is in the party List at the time of Accepting the invite?
_Logger.Debug(
$"my party with instance ID {myParty.instanceId} contains members {partyClient.character.name}");
List <NecClient> disposableList = new List <NecClient>();
foreach (NecClient disposablePartyClient in myParty.partyMembers)
{
disposableList.Add(disposablePartyClient);
_Logger.Debug($"Added {disposablePartyClient.character.name} to disposable list");
}
RecvPartyNotifyAddMember recvPartyNotifyAddMember = new RecvPartyNotifyAddMember(partyClient);
router.Send(recvPartyNotifyAddMember, disposableList);
_Logger.Debug($"Adding member {partyClient.character.name} to Roster ");
}
client.character.partyId = myParty.instanceId;
RecvPartyNotifyEstablish recvPartyNotifyEstablish = new RecvPartyNotifyEstablish(client, myParty);
router.Send(recvPartyNotifyEstablish, client); // Only establish the party for the acceptee. everyone else is already established.
RecvCharaBodyNotifyPartyJoin recvCharaBodyNotifyPartyJoin = new RecvCharaBodyNotifyPartyJoin(client.character.instanceId, myParty.instanceId, myParty.partyType);
router.Send(client.map, recvCharaBodyNotifyPartyJoin); //Only send the Join Notify of the Accepting Client to the Map. Existing members already did that when they joined.
RecvCharaNotifyPartyJoin recvCharaNotifyPartyJoin = new RecvCharaNotifyPartyJoin(client.character.instanceId, myParty.instanceId, myParty.partyType);
router.Send(recvCharaNotifyPartyJoin, client); //Only send the Join of the Accepting Client to the Accepting Client.
}
public override void Handle(NecClient client, NecPacket packet)
{
int PartyLeaderInstanceId = packet.Data.ReadInt32();
uint targetPartyInstanceId = packet.Data.ReadUInt32();
Logger.Debug($"{client.Character.Name}Applied to party {targetPartyInstanceId}");
Party myParty = Server.Instances.GetInstance(targetPartyInstanceId) as Party;
NecClient myPartyLeaderClient = Server.Clients.GetByCharacterInstanceId(myParty.PartyLeaderId);
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(myParty.PartyLeaderId);
Router.Send(client.Map, (ushort)AreaPacketId.recv_party_apply_r, res, ServerType.Area);
IBuffer res2 = BufferProvider.Provide();
res2.WriteUInt32(client.Character.partyId); //Party ID?
res2.WriteUInt32(client.Character.InstanceId);
res2.WriteFixedString($"{client.Soul.Name}", 0x31);
res2.WriteFixedString($"{client.Character.Name}", 0x5B);
res2.WriteUInt32(client.Character.ClassId);
res2.WriteByte(client.Character.Level);
res2.WriteByte(2); //Criminal Status
res2.WriteByte(1); //Beginner Protection (bool)
res2.WriteByte(1); //Membership Status
res2.WriteByte(1);
Router.Send(myPartyLeaderClient, (ushort)MsgPacketId.recv_party_notify_apply, res2, ServerType.Msg);
}
public override void Handle(NecClient client, NecPacket packet)
{
ItemEquipSlots equipSlot = (ItemEquipSlots)(1 << packet.data.ReadInt32());
ItemService itemService = new ItemService(client.character);
int error = 0;
_Logger.Debug(equipSlot.ToString());
try
{
ItemInstance unequippedItem = itemService.CheckAlreadyEquipped(equipSlot);
unequippedItem = itemService.Unequip(unequippedItem.currentEquipSlot);
RecvItemUpdateEqMask recvItemUpdateEqMask = new RecvItemUpdateEqMask(client, unequippedItem);
router.Send(recvItemUpdateEqMask);
//notify other players of your new look
RecvDataNotifyCharaData myCharacterData = new RecvDataNotifyCharaData(client.character, client.soul.name);
router.Send(client.map, myCharacterData, client);
}
catch (ItemException e)
{
error = (int)e.type;
}
RecvItemUnequip recvItemUnequip = new RecvItemUnequip(client, error);
router.Send(recvItemUnequip);
//Re-do all your stats
router.Send(client, itemService.CalculateBattleStats(client));
}
public override void Handle(NecClient client, NecPacket packet)
{
/*int32, unknown. probably party mode.
* int32, target client(character) id[i think this is the sends structure]*/
int unknown = packet.data.ReadInt32(); //party mode
uint targetInstanceId = packet.data.ReadUInt32();
NecClient targetClient = server.clients.GetByCharacterInstanceId(targetInstanceId);
Party party = server.instances.GetInstance(client.character.partyId) as Party;
targetClient.character.partyRequest = client.character.instanceId;
if (targetInstanceId == 0)
{
targetInstanceId = client.character.instanceId;
}
_Logger.Debug($"ID {client.character.instanceId} {client.character.name} sent a party: ${party.instanceId} invite to {targetClient.character.name} with instance ID {targetInstanceId}");
//acknowledge the send, tell it the recv logic is complete.
IBuffer res = BufferProvider.Provide();
res.WriteInt32(0); //error check
router.Send(client, (ushort)AreaPacketId.recv_party_invite_r, res, ServerType.Area);
RecvPartyNotifyInvite recvPartyNotifyInvite = new RecvPartyNotifyInvite(client, party);
router.Send(recvPartyNotifyInvite, targetClient);
}
public override void Handle(NecClient client, NecPacket packet)
{
int channelId = packet.Data.ReadInt32();
if (channelId == -1)
{
Logger.Debug(
"Escape button was selected to close channel select. channelId code == -0xFFFF => SendEventEnd");
SendEventEnd(client);
return;
}
if (!Server.Maps.TryGet(client.Character.MapId, out Map map))
{
Logger.Error($"MapId: {client.Character.MapId} does not exist");
return;
}
client.Character.Channel = channelId;
map.EnterForce(client);
SendEventEnd(client);
IBuffer res2 = BufferProvider.Provide();
res2.WriteUInt32(client.Character.InstanceId);
res2.WriteCString("IsThisMyChannel?????"); //Length to be Found
Router.Send(Server.Clients.GetAll(), (ushort)AreaPacketId.recv_channel_notify, res2, ServerType.Area);
}
private void SendItems(NecClient client, int[] itemIds)
{
ItemSpawnParams[] spawmParams = new ItemSpawnParams[itemIds.Length];
for (int i = 0; i < itemIds.Length; i++)
{
spawmParams[i] = new ItemSpawnParams();
spawmParams[i].itemStatuses = ItemStatuses.Identified;
}
ItemService itemService = new ItemService(client.character);
List <ItemInstance> items = itemService.SpawnItemInstances(ItemZoneType.AdventureBag, itemIds, spawmParams);
RecvSituationStart recvSituationStart = new RecvSituationStart(2);
router.Send(client, recvSituationStart.ToPacket());
foreach (ItemInstance itemInstance in items)
{
_Logger.Debug(itemInstance.type.ToString());
RecvItemInstance recvItemInstance = new RecvItemInstance(client, itemInstance);
router.Send(client, recvItemInstance.ToPacket());
}
RecvSituationEnd recvSituationEnd = new RecvSituationEnd();
router.Send(client, recvSituationEnd.ToPacket());
}
public override void Handle(NecClient client, NecPacket packet)
{
int targetInstanceId = packet.Data.ReadInt32();
int unknown = packet.Data.ReadInt32();
Logger.Debug($"accessing gimick with instance ID {targetInstanceId}");
IBuffer res = BufferProvider.Provide(); // this is the buffer we create
res.WriteInt32(0); //Error Check?
Router.Send(client, (ushort)AreaPacketId.recv_gimmick_access_object_r, res,
ServerType.Area); //this sends out our packet to the first operand
IBuffer res2 = BufferProvider.Provide();
res2.WriteUInt32(client.Character
.InstanceId); //this is probably for letting others know who accessed it (Instance Id)
res2.WriteInt32(targetInstanceId);
res2.WriteInt32(unknown);
Router.Send(client.Map, (ushort)AreaPacketId.recv_gimmick_access_object_notify, res2, ServerType.Area);
IBuffer res3 = BufferProvider.Provide();
res3.WriteInt32(targetInstanceId); //Gimmick Object ID.
res3.WriteInt32(unknown); //Gimmick State
Router.Send(client.Map, (ushort)AreaPacketId.recv_gimmick_state_update, res3, ServerType.Area);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
MonsterSpawn monsterSpawn = Server.Instances.CreateInstance <MonsterSpawn>();
if (!int.TryParse(command[0], out int monsterId))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
if (!Server.SettingRepository.Monster.TryGetValue(monsterId, out MonsterSetting monsterSetting))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid MonsterId: {monsterId}"));
return;
}
if (!int.TryParse(command[1], out int modelId))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[1]}"));
return;
}
if (!Server.SettingRepository.ModelCommon.TryGetValue(modelId, out ModelCommonSetting modelSetting))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid ModelId: {modelId}"));
return;
}
Logger.Debug($"modelSetting.Radius [{modelSetting.Radius}]");
monsterSpawn.MonsterId = monsterSetting.Id;
monsterSpawn.Name = monsterSetting.Name;
monsterSpawn.Title = monsterSetting.Title;
monsterSpawn.Level = (byte)monsterSetting.Level;
monsterSpawn.ModelId = modelSetting.Id;
monsterSpawn.Size = (short)(modelSetting.Height / 2);
monsterSpawn.Radius = (short)modelSetting.Radius;
monsterSpawn.MapId = client.Character.MapId;
monsterSpawn.X = client.Character.X;
monsterSpawn.Y = client.Character.Y;
monsterSpawn.Z = client.Character.Z;
monsterSpawn.Heading = client.Character.Heading;
monsterSpawn.Hp.setMax(100);
monsterSpawn.Hp.setCurrent(100);
if (!Server.Database.InsertMonsterSpawn(monsterSpawn))
{
responses.Add(ChatResponse.CommandError(client, "MonsterSpawn could not be saved to database"));
return;
}
RecvDataNotifyMonsterData monsterData = new RecvDataNotifyMonsterData(monsterSpawn);
Router.Send(client.Map, monsterData);
}
public override void Handle(NecClient client, NecPacket packet)
{
uint applicantInstanceId =
packet.Data.ReadUInt32(); //Could be a Party ID value hidden as character-who-made-it's value
Logger.Debug(
$"character {client.Character.Name} accepted Application to party from character Instance ID {applicantInstanceId}");
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(applicantInstanceId);
Router.Send(client, (ushort)AreaPacketId.recv_party_accept_to_apply_r, res, ServerType.Area);
Party myParty = Server.Instances.GetInstance(client.Character.partyId) as Party;
NecClient applicantClient = Server.Clients.GetByCharacterInstanceId(applicantInstanceId);
myParty.Join(applicantClient);
IBuffer res2 = BufferProvider.Provide();
Router.Send(applicantClient, (ushort)MsgPacketId.recv_party_notify_accept_to_apply, res2, ServerType.Msg);
foreach (NecClient partyClient in myParty.PartyMembers)
{
//if (partyClient != client)
{
SendPartyNotifyAddMember(partyClient, myParty);
}
}
SendCharaBodyNotifyPartyJoin(applicantClient, myParty.InstanceId);
}
public override void Handle(NecClient client, NecPacket packet)
{
/*int32, party type: 1 = open, 0 = closed
* int32, normal item distribution: 1 = random, 0 = do not distribute
* int32, rare item distribution: 1 = draw, 0 = do not distribute
* int32, target client(character) id*/
int partyType = packet.Data.ReadInt32();
int normItemDist = packet.Data.ReadInt32();
int rareItemDist = packet.Data.ReadInt32();
uint targetClientId = packet.Data.ReadUInt32();
Party myFirstParty = new Party();
Server.Instances.AssignInstance(myFirstParty);
myFirstParty.PartyType = partyType;
myFirstParty.NormalItemDist = normItemDist;
myFirstParty.RareItemDist = rareItemDist;
myFirstParty.TargetClientId = targetClientId;
myFirstParty.Join(client);
myFirstParty.PartyLeaderId = client.Character.InstanceId;
client.Character.partyId = myFirstParty.InstanceId;
//Sanity check. Did the player who made the party make it in to the List of Party Members stored on the Party Model?
foreach (NecClient necClient in myFirstParty.PartyMembers)
{
Logger.Debug(
$"my party with instance ID {myFirstParty.InstanceId} contains members {necClient.Character.Name}");
}
Logger.Debug($"Party Instance ID {myFirstParty.InstanceId}");
IBuffer res = BufferProvider.Provide();
res.WriteInt32(0);
Router.Send(client, (ushort)AreaPacketId.recv_party_establish_r, res, ServerType.Area);
SendPartyNotifyEstablish(client, partyType, normItemDist, rareItemDist, targetClientId,
myFirstParty.InstanceId);
SendCharaBodyNotifyPartyJoin(client);
SendCharaNotifyPartyJoin(client);
if (targetClientId != 0)
{
SendPartyNotifyInvite(client, targetClientId);
}
}
public void StartCast(SkillBaseSetting skillBase)
{
Logger.Debug(
$"Trap StartCast skillBase.Id [{skillBase.Id}] skillBase.CastingTime [{skillBase.CastingTime}]");
RecvSkillStartCastSelf startCast = new RecvSkillStartCastSelf(skillBase.Id, skillBase.CastingTime);
_server.Router.Send(startCast, _client);
List <PacketResponse> brList = new List <PacketResponse>();
RecvBattleReportStartNotify brStart = new RecvBattleReportStartNotify(_client.Character.InstanceId);
RecvBattleReportEndNotify brEnd = new RecvBattleReportEndNotify();
RecvBattleReportActionSkillStartCast brStartCast = new RecvBattleReportActionSkillStartCast(skillBase.Id);
brList.Add(brStart);
brList.Add(brStartCast);
brList.Add(brEnd);
_server.Router.Send(_client.Map, brList);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client,
$"Hi There! Type /players world or /players map to see who's here. You can also type a Character.Name"));
return;
}
switch (command[0])
{
case "map": //tells you all the people on the Map you're on
foreach (NecClient theirClient in client.Map.ClientLookup.GetAll())
{
//if(theirClient.Map.Id != -1 && theirClient.Character.InstanceId != 0)
responses.Add(ChatResponse.CommandError(client,
$"{theirClient.Character.Name} {theirClient.Soul.Name} is on Map {theirClient.Character.MapId} with InstanceID {theirClient.Character.InstanceId}"));
}
break;
case "world": //tells you all the people in the world
foreach (NecClient theirClient in Server.Clients.GetAll())
{
//if (theirClient.Map.Id != -1 && theirClient.Character.InstanceId != 0)
responses.Add(ChatResponse.CommandError(client,
$"{theirClient.Character.Name} {theirClient.Soul.Name} is on Map {theirClient.Character.MapId} with InstanceID {theirClient.Character.InstanceId}"));
}
break;
default: //you don't know what you're doing do you?
bool soulFound = false;
foreach (Character theirCharacter in Server.Characters.GetAll())
{
Logger.Debug($"Comparing {theirCharacter.Name} to {command[0]}");
if (theirCharacter.Name == command[0])
{
responses.Add(ChatResponse.CommandError(client,
$"{theirCharacter.Name} {theirCharacter.SoulName} is on Map {theirCharacter.MapId} with InstanceID {theirCharacter.InstanceId}"));
soulFound = true;
}
}
if (soulFound == false)
{
Logger.Error($"There is no command switch or player name matching : {command[0]} ");
responses.Add(
ChatResponse.CommandError(client, $"{command[0]} is not a valid players command."));
}
break;
}
}
public override void Handle(NecClient client, NecPacket packet)
{
uint applicantInstanceId = packet.data.ReadUInt32(); //Could be a Party ID value hidden as character-who-made-it's value
_Logger.Debug($"character {client.character.name} accepted Application to party from character Instance ID {applicantInstanceId}");
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(0);
router.Send(client, (ushort)AreaPacketId.recv_party_accept_to_apply_r, res, ServerType.Area);
Party myParty = server.instances.GetInstance(client.character.partyId) as Party;
NecClient applicantClient = server.clients.GetByCharacterInstanceId(applicantInstanceId);
myParty.Join(applicantClient);
applicantClient.character.partyId = myParty.instanceId;
RecvPartyNotifyEstablish recvPartyNotifyEstablish = new RecvPartyNotifyEstablish(applicantClient, myParty);
router.Send(recvPartyNotifyEstablish, applicantClient); // Only establish the party for the applicant. everyone else is already established.
foreach (NecClient partyClient in myParty.partyMembers)
{
//Sanity check. Who is in the party List at the time of Accepting the invite?
_Logger.Debug(
$"my party with instance ID {myParty.instanceId} contains members {partyClient.character.name}");
List <NecClient> disposableList = new List <NecClient>();
foreach (NecClient disposablePartyClient in myParty.partyMembers)
{
disposableList.Add(disposablePartyClient);
_Logger.Debug($"Added {disposablePartyClient.character.name} to disposable list");
}
RecvPartyNotifyAddMember recvPartyNotifyAddMember = new RecvPartyNotifyAddMember(partyClient);
router.Send(recvPartyNotifyAddMember, disposableList);
_Logger.Debug($"Adding member {partyClient.character.name} to Roster ");
}
RecvCharaBodyNotifyPartyJoin recvCharaBodyNotifyPartyJoin = new RecvCharaBodyNotifyPartyJoin(client.character.instanceId, myParty.instanceId, myParty.partyType);
router.Send(client.map, recvCharaBodyNotifyPartyJoin); //Only send the Join Notify of the Accepting Client to the Map. Existing members already did that when they joined.
}
public override void Handle(NecClient client, NecPacket packet)
{
int targetId = packet.Data.ReadInt32();
int skillId = client.Character.skillStartCast;
float X = packet.Data.ReadFloat();
float Y = packet.Data.ReadFloat();
float Z = packet.Data.ReadFloat();
int errcode = packet.Data.ReadInt32();
Logger.Debug($"myTargetID : {targetId}");
Logger.Debug($"Target location : X-{X}Y-{Y}Z-{Z}");
Logger.Debug($"ErrorCode : {errcode}");
IBuffer res = BufferProvider.Provide();
res.WriteInt32(errcode); //see sys_msg.csv
/*
* -1 Unable to use skill
* -1322 Incorrect target
* -1325 Insufficient usage count for Power Level
* 1 Not enough distance
* GENERIC Unable to use skill: < errcode >
*/
res.WriteFloat(2); //Cool time ./Skill_base.csv Column J
res.WriteFloat(1); //Rigidity time ./Skill_base.csv Column L
//Router.Send(client.Map, (ushort)AreaPacketId.recv_skill_exec_r, res, ServerType.Area);
int skillLookup = skillId / 1000;
Logger.Debug($"skillLookup : {skillLookup}");
var eventSwitchPerObjectID = new Dictionary <Func <int, bool>, Action>
{
{ x => (x > 114100 && x < 114199), () => ThiefSkill(client, skillId, targetId) },
{ x => (x > 114300 && x < 114399), () => ThiefSkill(client, skillId, targetId) },
{ x => x == 114607, () => ThiefSkill(client, skillId, targetId) },
{ x => (x > 113000 && x < 113999), () => MageSkill(client, skillId, targetId) },
{
x => (x > 1 && x < 999999), () => MageSkill(client, skillId, targetId)
} //this is a default catch statement for unmapped skills to prevent un-handled exceptions
};
eventSwitchPerObjectID.First(sw => sw.Key(skillLookup)).Value();
client.Character.castingSkill = false;
////////////////////Battle testing below this line.
//Delete all this. it was just for fun. and an example for how we impact targets with other more proper recvs.
//IBuffer res3 = BufferProvider.Provide();
//res3.WriteInt32(instance.InstanceId);
//Router.Send(client, (ushort)AreaPacketId.recv_object_disappear_notify, res3, ServerType.Area);
//IBuffer res4 = BufferProvider.Provide();
//res4.WriteInt32(instance.InstanceId);
//res4.WriteByte((byte)(Util.GetRandomNumber(0,70))); // % hp remaining of target. need to store current NPC HP and OD as variables to "attack" them
//Router.Send(client, (ushort)AreaPacketId.recv_object_hp_per_update_notify, res4, ServerType.Area);
}
private void LoadCharacterRepository()
{
foreach (Character character in Database.SelectCharacters())
{
Instances.AssignInstance(character);
Characters.Add(character);
Logger.Debug(
$"Character {character.Name} loaded from database added to memory. Assigned Intance ID {character.InstanceId} ");
}
}
public override void Handle(NecClient client, NecPacket packet)
{
uint objectId = packet.data.ReadUInt32();
_Logger.Debug($"Targeting : {objectId}");
IBuffer res = BufferProvider.Provide();
res.WriteInt32(0);
//Router.Send(client.Map, (ushort) AreaPacketId.recv_auction_bid_r, res, ServerType.Area);
}
public override void Handle(NecClient client, NecPacket packet)
{
IBuffer res = BufferProvider.Provide();
string targetSoulName = packet.data.ReadCString();
int targetSoulId;
int result;
try
{
Soul blockSoul = server.database.SelectSoulByName(targetSoulName);
targetSoulId = blockSoul.id;
result = 0;
_Logger.Debug($"target Soul Id is {targetSoulId}");
}
catch //(System.NullReferenceException NRE)
{
targetSoulId = 0;
result = -20;
_Logger.Debug($"Database Lookup for soul name {targetSoulName} returned null. Result {result}");
}
/*
* REFUSAL_LIST 0 %s is added to your Block List
* REFUSAL_LIST 1 %s is removed from your Block List
* REFUSAL_LIST 2 %s has been deleted from your Block List as its Soul has been deleted
* REFUSAL_LIST -1 Invalid action
* REFUSAL_LIST -20 The Soul Name does not exist
* REFUSAL_LIST -2201 The target is on your Block List
* REFUSAL_LIST -2202 You have been added to the target's Block List
* REFUSAL_LIST -2203 The Soul Name does not exist
* REFUSAL_LIST -2204 Block List is full
* REFUSAL_LIST -2205 Soul Name has already been added
* REFUSAL_LIST -2206 You may not add yourself to the Block List
* REFUSAL_LIST -2207 The Soul Name does not exist
* REFUSAL_LIST -2208 You may not add party members to the Block List
* REFUSAL_LIST GENERIC Unable to add to Block List
*/
res.WriteInt32(result); //error check
res.WriteInt32(targetSoulId); //ref_soulid
router.Send(client, (ushort)AreaPacketId.recv_refusallist_add_user_r, res, ServerType.Area);
}
public void StartCast()
{
IInstance target = _server.instances.GetInstance(_targetInstanceId);
switch (target) // ToDO Do a hositilty check to make sure this is allowed
{
case NpcSpawn npcSpawn:
_Logger.Debug(
$"Start casting Skill [{_skillId}] on NPCId: {npcSpawn.instanceId} SerialId: {npcSpawn.npcId}");
break;
case MonsterSpawn monsterSpawn:
_Logger.Debug($"Start casting Skill [{_skillId}] on MonsterId: {monsterSpawn.instanceId}");
break;
case Character character:
_Logger.Debug($"Start casting Skill [{_skillId}] on CharacterId: {character.instanceId}");
break;
default:
_Logger.Error(
$"Instance with InstanceId: {_targetInstanceId} does not exist. the ground is gettin blasted");
break;
}
if (!_server.settingRepository.skillBase.TryGetValue(_skillId, out SkillBaseSetting skillBaseSetting))
{
_Logger.Error($"Could not get SkillBaseSetting for skillId : {_skillId}");
return;
}
float castTime = skillBaseSetting.castingTime;
_Logger.Debug($"Start casting Skill [{_skillId}] cast time is [{castTime}]");
RecvSkillStartCastR thiefSkill = new RecvSkillStartCastR(0, castTime);
_server.router.Send(thiefSkill, _client);
List <PacketResponse> brList = new List <PacketResponse>();
RecvBattleReportStartNotify brStart = new RecvBattleReportStartNotify(_client.character.instanceId);
RecvBattleReportEndNotify brEnd = new RecvBattleReportEndNotify();
RecvBattleReportActionSkillStartCast brStartCast = new RecvBattleReportActionSkillStartCast(_skillId);
brList.Add(brStart);
brList.Add(brStartCast);
brList.Add(brEnd);
_server.router.Send(_client.map, brList);
}
public override void Handle(NecClient client, NecPacket packet)
{
uint partyInstanceId = packet.Data.ReadUInt32();
Logger.Debug($"character {client.Character.Name} accepted invite to party ID {partyInstanceId}");
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(partyInstanceId);
Router.Send(client, (ushort)AreaPacketId.recv_party_accept_to_invite_r, res, ServerType.Area);
Party myParty = Server.Instances.GetInstance(partyInstanceId) as Party;
if (!myParty.PartyMembers.Contains(client))
{
myParty.Join(client);
} //add Accepting client to party list if it doesn't exist
foreach (NecClient partyClient in myParty.PartyMembers)
{
//Sanity check. Who is in the party List at the time of Accepting the invite?
Logger.Debug(
$"my party with instance ID {myParty.InstanceId} contains members {partyClient.Character.Name}");
List <NecClient> DisposableList = new List <NecClient>();
foreach (NecClient DisposablePartyClient in myParty.PartyMembers)
{
DisposableList.Add(DisposablePartyClient);
Logger.Debug($"Added {DisposablePartyClient.Character.Name} to disposable list");
}
SendPartyNotifyAddMember(partyClient, DisposableList);
Logger.Debug($"Adding member {partyClient.Character.Name} to Roster ");
}
client.Character.partyId = myParty.InstanceId;
SendPartyNotifyEstablish(client, myParty);
SendCharaBodyNotifyPartyJoin(client,
myParty); //Only send the Join Notify of the Accepting Client to the Map. Existing members already did that when they joined.
SendCharaNotifyPartyJoin(client,
myParty); //Only send the Join of the Accepting Client to the Accepting Client.
}
