public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
IBuffer res36 = BufferProvider.Provide();
switch (command[0])
{
case "start":
IBuffer res21 = BufferProvider.Provide();
res21.WriteInt32(1); // 0 = normal 1 = cinematic
res21.WriteByte(0);
router.Send(client, (ushort)AreaPacketId.recv_event_start, res21, ServerType.Area);
IBuffer res22 = BufferProvider.Provide();
res22.WriteCString(command[1]); // lable
res22.WriteUInt32(client.character.instanceId); //newjp ObjectId
router.Send(client, (ushort)AreaPacketId.recv_event_script_play, res22, ServerType.Area);
break;
default:
_Logger.Error($"There is no script of type : {command[1]} ");
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (!float.TryParse(command[0], out float x))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
if (!float.TryParse(command[1], out float y))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[1]}"));
return;
}
if (!float.TryParse(command[2], out float z))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[2]}"));
return;
}
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(client.character.instanceId);
res.WriteFloat(x);
res.WriteFloat(y);
res.WriteFloat(z);
res.WriteByte(client.character.heading);
res.WriteByte(client.character.movementAnim);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
}
public override void Handle(NecClient client, ChatMessage message, ChatResponse response,
List <ChatResponse> responses)
{
if (client == null)
{
return;
}
if (message.message == null || message.message.Length <= 1)
{
return;
}
if (!message.message.StartsWith(CHAT_COMMAND_START))
{
return;
}
string commandMessage = message.message.Substring(1);
string[] command = commandMessage.Split(CHAT_COMMAND_SEPARATOR);
if (command.Length <= 0)
{
_Logger.Error(client, $"Command '{message.message}' is invalid");
return;
}
string commandKey = command[0].ToLowerInvariant();
if (!_commands.ContainsKey(commandKey))
{
_Logger.Error(client, $"Command '{commandKey}' does not exist");
responses.Add(ChatResponse.CommandError(client, $"Command does not exist: {commandKey}"));
return;
}
ChatCommand chatCommand = _commands[commandKey];
if (client.account.state < chatCommand.accountState)
{
_Logger.Error(client,
$"Not entitled to execute command '{chatCommand.key}' (State < Required: {client.account.state} < {chatCommand.accountState})");
return;
}
int cmdLength = command.Length - 1;
string[] subCommand;
if (cmdLength > 0)
{
subCommand = new string[cmdLength];
Array.Copy(command, 1, subCommand, 0, cmdLength);
}
else
{
subCommand = new string[0];
}
chatCommand.Execute(subCommand, client, message, responses);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command.Length < 1)
{
responses.Add(ChatResponse.CommandError(client, "To few arguments"));
return;
}
switch (command[0])
{
case "bags":
SpawnBags(client);
break;
case "a_darkmerchant":
SpawnAvatarDarkMerchant(client);
break;
case "charmed":
SpawnCharmedGear(client);
break;
default:
responses.Add(ChatResponse.CommandError(client, $"Invalid Package: {command[0]}"));
return;
}
}
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 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 Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
responses.Add(ChatResponse.CommandError(client, "-----Status-----"));
responses.Add(ChatResponse.CommandError(client,
$"AccountId: {client.Account.Id} SoulId: {client.Soul.Id} CharacterId:{client.Character.Id} InstanceId: {client.Character.InstanceId}"));
responses.Add(ChatResponse.CommandError(client,
$"MapId: {client.Character.MapId} X: {client.Character.X} Y:{client.Character.Y} Z:{client.Character.Z}"));
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
responses.Add(ChatResponse.CommandError(client, "-----Status-----"));
responses.Add(ChatResponse.CommandError(client,
$"AccountId: {client.account.id} SoulId: {client.soul.id} CharacterId:{client.character.id} InstanceId: {client.character.instanceId} State: {client.character.state}"));
responses.Add(ChatResponse.CommandError(client,
$"MapId: {client.character.mapId} X: {client.character.x} Y:{client.character.y} Z:{client.character.z} H:{client.character.heading}"));
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (!int.TryParse(command[0], out int npcId))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
if (!server.settingRepository.npc.TryGetValue(npcId, out NpcSetting npcSetting))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid NpcId: {npcId}"));
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;
}
NpcSpawn npcSpawn = new NpcSpawn();
server.instances.AssignInstance(npcSpawn);
npcSpawn.npcId = npcSetting.id;
npcSpawn.name = npcSetting.name;
npcSpawn.title = npcSetting.title;
npcSpawn.level = (byte)npcSetting.level;
npcSpawn.modelId = modelSetting.id;
npcSpawn.size = (byte)modelSetting.height;
npcSpawn.mapId = client.character.mapId;
npcSpawn.x = client.character.x;
npcSpawn.y = client.character.y;
npcSpawn.z = client.character.z;
npcSpawn.heading = client.character.heading;
if (!server.database.InsertNpcSpawn(npcSpawn))
{
responses.Add(ChatResponse.CommandError(client, "NpcSpawn could not be saved to database"));
return;
}
RecvDataNotifyNpcData npcData = new RecvDataNotifyNpcData(npcSpawn);
router.Send(client.map, npcData);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (!int.TryParse(command[0], out int npcId))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
if (!Server.SettingRepository.Npc.TryGetValue(npcId, out NpcSetting npcSetting))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid NpcId: {npcId}"));
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;
}
NpcSpawn npcSpawn = Server.Instances.CreateInstance <NpcSpawn>();
npcSpawn.NpcId = npcSetting.Id;
npcSpawn.Name = npcSetting.Name;
npcSpawn.Title = npcSetting.Title;
npcSpawn.Level = (byte)npcSetting.Level;
npcSpawn.ModelId = modelSetting.Id;
npcSpawn.Size = (byte)modelSetting.Height;
npcSpawn.MapId = client.Character.MapId;
npcSpawn.X = client.Character.X;
npcSpawn.Y = client.Character.Y;
npcSpawn.Z = client.Character.Z;
npcSpawn.Heading = client.Character.Heading;
if (!Server.Database.InsertNpcSpawn(npcSpawn))
{
responses.Add(ChatResponse.CommandError(client, $"NpcSpawn could not be saved to database"));
return;
}
RecvDataNotifyNpcData npcData = new RecvDataNotifyNpcData(npcSpawn);
Router.Send(client.Map, npcData);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == "")
{
responses.Add(ChatResponse.CommandError(client, $"pick a command: {command[0]}"));
return;
}
IBuffer res = BufferProvider.Provide();
switch (command[0])
{
case "open":
RecvCharaArrangeNotifyOpen openArrange = new RecvCharaArrangeNotifyOpen();
RecvCharaArrangeNotifyUpdateUnlock unlockArrange1 = new RecvCharaArrangeNotifyUpdateUnlock();
router.Send(unlockArrange1, client);
router.Send(openArrange, client);
break;
case "update":
RecvCharaArrangeUpdateFormR updateArrange = new RecvCharaArrangeUpdateFormR();
router.Send(updateArrange, client);
break;
case "parts":
RecvCharaArrangeNotifyParts partsArrange = new RecvCharaArrangeNotifyParts();
router.Send(partsArrange, client);
break;
case "unlock":
RecvCharaArrangeNotifyUpdateUnlock unlockArrange = new RecvCharaArrangeNotifyUpdateUnlock();
router.Send(unlockArrange, client);
break;
case "form":
RecvCharaArrangeUpdateFormR formArrange = new RecvCharaArrangeUpdateFormR();
router.Send(formArrange, client);
break;
default:
Task.Delay(TimeSpan.FromMilliseconds(10 * 1000)).ContinueWith
(t1 =>
{
IBuffer res = BufferProvider.Provide();
res.WriteByte(0);
router.Send(client, (ushort)AreaPacketId.recv_event_end, res, ServerType.Area);
}
);
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (!int.TryParse(command[0], out int x))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(client.Character.InstanceId);
res.WriteInt32(x);
Router.Send(client.Map, 0x1489, res, ServerType.Area);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
int x = 10010101;
if (command[0] == "all")
{
//foreach (HonorSetting honorSetting in Server.SettingRepository.Honor.Values)
int[] honorSettings = server.settingRepository.honor.Keys.ToArray();
int numEntries = server.settingRepository.honor.Count; //its over 1000!
IBuffer res = BufferProvider.Provide();
res.WriteInt32(1000); // must be under 0x3E8 // wtf?
for (int i = 0; i < 1000; i++)
{
res.WriteInt32(honorSettings[i]);
res.WriteUInt32(client.character.instanceId);
res.WriteByte(1); // bool New Title 0:Yes 1:No
}
router.Send(client, (ushort)AreaPacketId.recv_get_honor_notify, res, ServerType.Area);
res = BufferProvider.Provide();
res.WriteInt32(numEntries - 1000); // must be under 0x3E8 // wtf?
for (int i = 1000; i < numEntries; i++)
{
res.WriteInt32(honorSettings[i]);
res.WriteUInt32(client.character.instanceId);
res.WriteByte(0); // bool New Title 0:Yes 1:No
}
router.Send(client, (ushort)AreaPacketId.recv_get_honor_notify, res, ServerType.Area);
}
else if (!int.TryParse(command[0], out x))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}. try 10010101"));
return;
}
IBuffer res2 = BufferProvider.Provide();
res2 = BufferProvider.Provide();
res2.WriteInt32(x);
res2.WriteUInt32(client.character.instanceId);
res2.WriteByte(1); // bool New Title 0:Yes 1:No
router.Send(client, (ushort)AreaPacketId.recv_get_honor, res2, ServerType.Area);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
responses.Add(ChatResponse.CommandError(client, "Available Commands:"));
Dictionary <string, ChatCommand> commands = server.chat.commandHandler.GetCommands();
foreach (string key in commands.Keys)
{
ChatCommand chatCommand = commands[key];
if (chatCommand.helpText == null)
{
continue;
}
responses.Add(ChatResponse.CommandError(client, "----------"));
responses.Add(ChatResponse.CommandError(client, $"{key}"));
responses.Add(ChatResponse.CommandError(client, chatCommand.helpText));
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0].Length == 0)
{
Logger.Debug("Re-entering current map");
command[0] = $"{client.Character.MapId}";
}
if (!int.TryParse(command[0], out int mapId))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
if (!Server.Maps.TryGet(mapId, out Map map))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid MapId: {mapId}"));
return;
}
map.EnterForce(client);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
if (!int.TryParse(command[1], out int x))
{
responses.Add(ChatResponse.CommandError(client, "Please provide a value to test"));
return;
}
IInstance instance = server.instances.GetInstance(client.character.eventSelectReadyCode);
MonsterSpawn monsterSpawn = null;
if (instance is MonsterSpawn monsterSpawn2)
{
client.map.monsterSpawns.TryGetValue(monsterSpawn2.instanceId, out monsterSpawn2);
monsterSpawn = monsterSpawn2;
}
switch (command[0])
{
case "state":
_Logger.Debug($"MonsterInstanceId: {monsterSpawn.instanceId} state is being set to {x}");
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(monsterSpawn.instanceId);
//Toggles state between Alive(attackable), Dead(lootable), or Inactive(nothing).
res.WriteInt32(x);
router.Send(client, (ushort)AreaPacketId.recv_monster_state_update_notify, res, ServerType.Area);
break;
case "dead":
//recv_battle_report_noact_notify_dead = 0xCDC9,
IBuffer res2 = BufferProvider.Provide();
res2.WriteUInt32(monsterSpawn.instanceId);
res2.WriteInt32(x);
res2.WriteInt32(x);
res2.WriteInt32(x);
router.Send(client.map, (ushort)AreaPacketId.recv_battle_report_noact_notify_dead, res2,
ServerType.Area);
break;
case "pose":
IBuffer res3 = BufferProvider.Provide();
//recv_battle_attack_pose_start_notify = 0x7CB2,
res3.WriteInt32(x);
router.Send(client.map, (ushort)AreaPacketId.recv_battle_attack_pose_start_notify, res3,
ServerType.Area);
break;
case "pose2":
IBuffer resT = BufferProvider.Provide();
resT.WriteUInt32(client.character.instanceId); //Character ID
resT.WriteInt32(x); //Character pose
router.Send(client.map, (ushort)AreaPacketId.recv_chara_pose_notify, resT, ServerType.Area,
client);
break;
case "hate":
_Logger.Debug(
$"Setting Monster Hate for Monster ID {monsterSpawn.instanceId} to act on character ID {client.character.instanceId}");
IBuffer res4 = BufferProvider.Provide();
res4.WriteUInt32(monsterSpawn
.instanceId); //Unique instance of this monsters "Hate" attribute. not to be confused with the Monsters InstanceID
res4.WriteInt32(x);
router.Send(client, (ushort)AreaPacketId.recv_monster_hate_on, res4, ServerType.Area);
break;
case "jump":
monsterSpawn.z += x;
IBuffer res5 = BufferProvider.Provide();
res5.WriteUInt32(monsterSpawn.instanceId);
res5.WriteFloat(monsterSpawn.x);
res5.WriteFloat(monsterSpawn.y);
res5.WriteFloat(monsterSpawn.z);
res5.WriteByte(monsterSpawn.heading);
res5.WriteByte(0xA);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res5, ServerType.Area);
break;
case "emotion":
//recv_emotion_notify_type = 0xF95B,
IBuffer res6 = BufferProvider.Provide();
res6.WriteUInt32(monsterSpawn.instanceId);
res6.WriteInt32(x);
router.Send(client.map, (ushort)AreaPacketId.recv_emotion_notify_type, res6, ServerType.Area);
break;
case "deadstate":
//recv_charabody_notify_deadstate = 0xCC36, // Parent = 0xCB94 // Range ID = 03
IBuffer res7 = BufferProvider.Provide();
res7.WriteUInt32(monsterSpawn.instanceId);
res7.WriteInt32(
x); //4 here causes a cloud and the model to disappear, 5 causes a mist to happen and disappear
res7.WriteInt32(x);
router.Send(client.map, (ushort)AreaPacketId.recv_charabody_notify_deadstate, res7,
ServerType.Area);
break;
case "target":
//recv_object_sub_target_update_notify = 0x23E5,
IBuffer resA = BufferProvider.Provide();
resA.WriteUInt32(monsterSpawn.instanceId);
//resA.WriteInt64(x);
resA.WriteUInt32(client.character.instanceId);
resA.WriteUInt32(client.character.instanceId);
router.Send(client.map, (ushort)AreaPacketId.recv_object_sub_target_update_notify, resA,
ServerType.Area);
break;
case "hp":
//recv_object_hp_per_update_notify = 0xFF00,
IBuffer resB = BufferProvider.Provide();
resB.WriteUInt32(monsterSpawn.instanceId);
resB.WriteByte((byte)x);
router.Send(client.map, (ushort)AreaPacketId.recv_object_hp_per_update_notify, resB,
ServerType.Area);
break;
case "cast":
IBuffer resC = BufferProvider.Provide();
//recv_battle_report_action_monster_skill_start_cast = 0x1959,
resC.WriteUInt32(client.character.instanceId);
resC.WriteInt32(13010101);
resC.WriteFloat(3);
router.Send(client, (ushort)AreaPacketId.recv_battle_report_action_monster_skill_start_cast, resC,
ServerType.Area);
break;
case "exec":
IBuffer resE = BufferProvider.Provide();
//recv_battle_report_action_monster_skill_exec = 0x2A82,
resE.WriteInt32(x);
router.Send(client, (ushort)AreaPacketId.recv_battle_report_action_monster_skill_exec, resE,
ServerType.Area);
break;
case "start":
IBuffer resO = BufferProvider.Provide();
resO.WriteUInt32(instance.instanceId);
router.Send(client.map, (ushort)AreaPacketId.recv_battle_report_start_notify, resO,
ServerType.Area);
break;
case "end":
IBuffer resG = BufferProvider.Provide();
resG.WriteUInt32(monsterSpawn.instanceId);
//Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_start_notify, resG, ServerType.Area);
//insert battle_report command to test here
IBuffer resF = BufferProvider.Provide();
//recv_battle_report_notify_hit_effect_name = 0xB037,
resF.WriteUInt32(monsterSpawn.instanceId);
resF.WriteCString("ToBeFound");
resF.WriteCString("ToBeFound_2");
//Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_notify_hit_effect_name, resF, ServerType.Area);
IBuffer resK = BufferProvider.Provide();
//recv_battle_report_notify_hit_effect = 0x179D,
resK.WriteInt32(x);
//Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_notify_hit_effect, resK, ServerType.Area);
IBuffer resL = BufferProvider.Provide();
//recv_battle_report_action_effect_onhit = 0x5899,
resL.WriteInt32(x);
//Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_action_effect_onhit, resL, ServerType.Area);
//recv_battle_report_noact_notify_buff_effect = 0xDB5E,
IBuffer resM = BufferProvider.Provide();
resM.WriteInt32(696969);
resM.WriteInt32(x);
//Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_noact_notify_buff_effect, resM, ServerType.Area);
IBuffer resH = BufferProvider.Provide();
router.Send(client.map, (ushort)AreaPacketId.recv_battle_report_end_notify, resH, ServerType.Area);
break;
case "gimmick":
//recv_data_notify_gimmick_data = 0xBFE9,
IBuffer resI = BufferProvider.Provide();
resI.WriteInt32(69696);
resI.WriteFloat(client.character.x);
resI.WriteFloat(client.character.y);
resI.WriteFloat(client.character.z);
resI.WriteByte(client.character.heading);
resI.WriteInt32(x); //Gimmick number (from gimmick.csv)
resI.WriteInt32(0);
router.Send(client.map, (ushort)AreaPacketId.recv_data_notify_gimmick_data, resI, ServerType.Area);
break;
default:
_Logger.Error($"There is no recv of type : {command[0]} ");
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
IBuffer res36 = BufferProvider.Provide();
switch (command[0])
{
case "union":
res36.WriteUInt32(client.Character.InstanceId);
res36.WriteInt32(client.Character.unionId);
res36.WriteCString("Trade_Union");
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_notify_union_data, res36, ServerType.Area);
break;
case "xunion":
res36.WriteUInt32(client.Character.InstanceId);
res36.WriteInt32(0 /*client.Character.UnionId*/);
res36.WriteCString("");
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_notify_union_data, res36, ServerType.Area);
break;
case "disband":
Router.Send(client, (ushort)MsgPacketId.recv_union_notify_disband, res36, ServerType.Msg);
res36.WriteInt32(0); //error check
Router.Send(client, (ushort)AreaPacketId.recv_union_request_disband_result, res36,
ServerType.Area);
IBuffer res37 = BufferProvider.Provide();
res37.WriteInt32(client.Character.unionId);
Router.Send(client, (ushort)MsgPacketId.recv_union_request_disband_r, res37, ServerType.Msg);
IBuffer res40 = BufferProvider.Provide();
res40.WriteUInt32(client.Character.InstanceId);
res40.WriteInt32(0 /*client.Character.UnionId*/);
res40.WriteCString("");
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_notify_union_data, res40, ServerType.Area);
client.Character.unionId = 0;
break;
case "open":
Router.Send(client.Map, (ushort)AreaPacketId.recv_union_open_window, res36, ServerType.Area);
break;
case "storage":
res36.WriteInt64(1);
res36.WriteInt64(1);
Router.Send(client.Map, (ushort)AreaPacketId.recv_event_union_storage_open, res36,
ServerType.Area);
break;
case "establish":
res36.WriteInt32(0); //error check
Router.Send(client.Map, (ushort)AreaPacketId.recv_union_request_establish_r, res36,
ServerType.Area);
break;
case "rename":
res36.WriteCString("YouDidIt");
Router.Send(client.Map, (ushort)AreaPacketId.recv_union_rename_open, res36, ServerType.Area);
IBuffer res38 = BufferProvider.Provide();
res38.WriteInt32(0); //error check
Router.Send(client.Map, (ushort)AreaPacketId.recv_union_request_rename_r, res38, ServerType.Area);
break;
case "resetid":
client.Character.unionId = 0;
break;
case "growth":
res36.WriteInt32(0); //error check
Router.Send(client.Map, (ushort)AreaPacketId.recv_union_request_growth_result, res36,
ServerType.Area);
IBuffer res39 = BufferProvider.Provide();
res39.WriteInt16(3); //sets union current exp
Router.Send(client.Map, (ushort)MsgPacketId.recv_union_notify_growth, res39, ServerType.Msg);
break;
case "display":
res36.WriteInt32(333); //error check
Router.Send(client.Map, (ushort)AreaPacketId.recv_quest_display_r, res36, ServerType.Area);
break;
case "order":
IBuffer res2 = BufferProvider.Provide();
res2.WriteInt32(0); // 0 = normal 1 = cinematic
res2.WriteByte(0);
Router.Send(client, (ushort)AreaPacketId.recv_event_start, res2, ServerType.Area);
IBuffer res = BufferProvider.Provide();
res.WriteInt32(1999);
res.WriteByte(1);
res.WriteFixedString("aaaaaaa", 0x61);
res.WriteInt32(1);
res.WriteInt32(1);
res.WriteFixedString("ffffffffff", 0x61);
res.WriteByte(1);
res.WriteByte(1);
res.WriteInt32(1);
res.WriteInt32(1);
res.WriteInt32(1);
int numEntries4 = 0xA;
res.WriteInt32(numEntries4);
for (int i = 0; i < numEntries4; i++)
{
res.WriteInt32(0x10); //size of string
res.WriteFixedString("asfsaf", 0x10);
res.WriteInt16(1);
res.WriteInt32(1);
}
res.WriteByte(1);
int numEntries5 = 0xC;
for (int k = 0; k < numEntries5; k++)
{
res.WriteInt32(0x10); //size of string
res.WriteFixedString("boooooo", 0x10);
res.WriteInt16(1);
res.WriteInt32(1);
}
res.WriteByte(1);
//??res.WriteByte(1);
res.WriteFixedString("Eat the monster", 0x181);
res.WriteFixedString("no wait, that'd be a really weird quest", 0x181);
for (int m = 0; m < 0x5; m++)
{
res.WriteByte(1);
res.WriteInt32(10101);
res.WriteInt32(100101);
res.WriteInt32(0);
res.WriteInt32(0);
}
res.WriteByte(2);
Router.Send(client, (ushort)AreaPacketId.recv_event_quest_order, res, ServerType.Area);
break;
case "mission":
IBuffer res3 = BufferProvider.Provide();
res3.WriteInt32(0); // 0 = normal 1 = cinematic
res3.WriteByte(0);
// Router.Send(client, (ushort)AreaPacketId.recv_event_start, res3, ServerType.Area);
IBuffer res4 = BufferProvider.Provide();
res4.WriteInt32(1); // 0 = normal 1 = cinematic
res4.WriteInt32(1); // 0 = normal 1 = cinematic
Router.Send(client, (ushort)AreaPacketId.recv_quest_get_mission_quest_works_r, res4,
ServerType.Area);
break;
case "begin":
IBuffer res5 = BufferProvider.Provide();
res5.WriteInt32(0); // 0 = normal 1 = cinematic
res5.WriteByte(0);
Router.Send(client, (ushort)AreaPacketId.recv_event_start, res5, ServerType.Area);
Router.Send(client, (ushort)AreaPacketId.recv_event_quest_report_list_begin, res36,
ServerType.Area);
break;
case "start":
uint.TryParse(command[1], out uint x);
IBuffer res21 = BufferProvider.Provide();
res21.WriteInt32(1); // 0 = normal 1 = cinematic
res21.WriteByte(255);
Router.Send(client, (ushort)AreaPacketId.recv_event_start, res21, ServerType.Area);
IBuffer res22 = BufferProvider.Provide();
res22.WriteCString(
"tutorial/tutorial_soul"); //ReadScript query to ...\Data\script\event\. Will play if found
Router.Send(client, (ushort)AreaPacketId.recv_event_script_play, res22, ServerType.Area);
break;
default:
Logger.Error($"There is no recv of type : {command[0]} ");
Task.Delay(TimeSpan.FromMilliseconds((int)(10 * 1000))).ContinueWith
(t1 =>
{
IBuffer res = BufferProvider.Provide();
res.WriteByte(0);
Router.Send(client, (ushort)AreaPacketId.recv_event_end, res, ServerType.Area);
}
);
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
if (!int.TryParse(command[1], out int x))
{
try
{
string binaryString = command[1];
binaryString = binaryString.Replace("0b", "");
_Logger.Debug(binaryString);
x = Convert.ToInt32(binaryString, 2);
}
catch
{
responses.Add(ChatResponse.CommandError(client, "no value specified. setting x to 1"));
//return;
}
}
if (!int.TryParse(command[2], out int y))
{
responses.Add(ChatResponse.CommandError(client, "Good Job!"));
}
IBuffer res = BufferProvider.Provide();
res.WriteInt32(2);
router.Send(client, (ushort)AreaPacketId.recv_situation_start, res, ServerType.Area);
res = BufferProvider.Provide();
res.WriteInt32(0); // 0 = normal 1 = cinematic
res.WriteByte(0);
//Router.Send(client, (ushort)AreaPacketId.recv_event_start, res, ServerType.Area);
switch (command[0])
{
case "itemobject":
RecvDataNotifyLocalItemobjectData itemObject = new RecvDataNotifyLocalItemobjectData(client.character, x);
router.Send(client.map, itemObject);
break;
case "itemcharapost":
RecvItemCharaPostNotify itemCharaPost = new RecvItemCharaPostNotify(x, (byte)y);
router.Send(client.map, itemCharaPost);
break;
case "itemuse":
RecvItemUseNotify itemUseNotify = new RecvItemUseNotify(x, y);
router.Send(client.map, itemUseNotify);
RecvItemUse itemUse = new RecvItemUse(0 /*success*/, y);
router.Send(client.map, itemUse);
break;
case "dispitem":
RecvSoulDispItemNotifyData dispItem = new RecvSoulDispItemNotifyData(x);
router.Send(client.map, dispItem);
break;
case "templeopen":
RecvTempleNotifyOpen templeOpen = new RecvTempleNotifyOpen((byte)x);
router.Send(client.map, templeOpen);
break;
case "wantedstate":
RecvWantedUpdateState wantedState = new RecvWantedUpdateState(x);
router.Send(client.map, wantedState);
RecvWantedUpdateStateNotify wantedStateNotify = new RecvWantedUpdateStateNotify((int)client.character.instanceId, x);
router.Send(client.map, wantedStateNotify);
break;
case "jailmoney":
RecvWantedJailUpdateMoney jailMoney = new RecvWantedJailUpdateMoney();
router.Send(client.map, jailMoney);
break;
case "lootaccess":
RecvLootAccessObject lootAcess = new RecvLootAccessObject();
router.Send(client.map, lootAcess);
break;
case "partygetitem":
//arearecv
RecvPartyNotifyGetItem recvPartyNotifyGetItem = new RecvPartyNotifyGetItem(client.character.instanceId);
router.Send(recvPartyNotifyGetItem, client);
//message recv
res = BufferProvider.Provide();
res.WriteUInt32(client.character.instanceId);
res.WriteCString(" a Dagger or any long string named object ");
res.WriteByte(20);
router.Send(client.map, (ushort)MsgPacketId.recv_party_notify_get_item, res, ServerType.Msg);
break;
case "partygetmoney":
RecvPartyNotifyGetMoney recvPartyNotifyGetMoney = new RecvPartyNotifyGetMoney(client.character.instanceId);
router.Send(client.map, recvPartyNotifyGetMoney);
break;
case "partybuff":
RecvPartyNotifyAttachBuff recvPartyNotifyAttachBuff = new RecvPartyNotifyAttachBuff();
router.Send(client.map, recvPartyNotifyAttachBuff);
break;
case "partydragon":
RecvPartyNotifyUpdateDragon recvPartyNotifyUpdateDragon = new RecvPartyNotifyUpdateDragon(client.character.instanceId);
router.Send(client.map, recvPartyNotifyUpdateDragon);
break;
case "partymap":
RecvPartyNotifyUpdateMap recvPartyNotifyUpdateMap = new RecvPartyNotifyUpdateMap(client);
router.Send(client.map, recvPartyNotifyUpdateMap);
break;
case "partysync":
RecvPartyNotifyUpdateSyncLevel recvPartyNotifyUpdateSyncLevel = new RecvPartyNotifyUpdateSyncLevel(client);
router.Send(client.map, recvPartyNotifyUpdateSyncLevel);
break;
case "ap":
RecvCharaUpdateAp recvCharaUpdateAp = new RecvCharaUpdateAp(Util.GetRandomNumber(0, 200));
router.Send(client.map, recvCharaUpdateAp);
client.character.gp.SetCurrent(25);
break;
case "ac":
RecvCharaUpdateAc recvCharaUpdateAc = new RecvCharaUpdateAc(Util.GetRandomNumber(0, 200));
router.Send(client.map, recvCharaUpdateAc);
break;
case "iobject":
//SendDataNotifyItemObjectData
// objectid : %d, stateflag : %d, type : %d\n
res = BufferProvider.Provide();
res.WriteInt32(12345); //object instance ID
res.WriteFloat(client.character.x); //Initial X
res.WriteFloat(client.character.y); //Initial Y
res.WriteFloat(client.character.z); //Initial Z
res.WriteFloat(client.character.x); //Final X
res.WriteFloat(client.character.y); //Final Y
res.WriteFloat(client.character.z); //Final Z
res.WriteByte(client.character.heading); //View offset
res.WriteInt32(0); // ?
res.WriteUInt32(client.character.instanceId); // ?
res.WriteUInt32(0); // ?
res.WriteInt32(0b1); //object state. 1 = lootable .
res.WriteInt32(2); //type
router.Send(client.map, (ushort)AreaPacketId.recv_data_notify_itemobject_data, res, ServerType.Area);
break;
case "o2716":
res = BufferProvider.Provide();
res.WriteUInt32(0); //errhceck
router.Send(client, 0x2716, res, ServerType.Area);
break;
case "o4abb":
res = BufferProvider.Provide();
res.WriteUInt32(0);
res.WriteUInt16(0);
router.Send(client, 0x4abb, res, ServerType.Area);
break;
case "ob684":
Recv0Xb684 recv0Xb684 = new Recv0Xb684();
router.Send(client.map, recv0Xb684);
break;
case "ob4978":
Recv0X4978 recv0X4978 = new Recv0X4978();
router.Send(client.map, recv0X4978);
break;
case "ob5418":
Recv0X5418 recv0X5418 = new Recv0X5418();
router.Send(client.map, recv0X5418);
break;
case "ob10da":
Recv0X10Da recv0X10Da = new Recv0X10Da();
router.Send(client.map, recv0X10Da);
break;
case "ob8d62":
Recv0X8D62 recv0X8D62 = new Recv0X8D62();
router.Send(client.map, recv0X8D62);
break;
case "ob9201":
Recv0X9201 recv0X9201 = new Recv0X9201();
router.Send(client.map, recv0X9201);
break;
case "ob9ca1":
Recv0X9Ca1 recv0X9Ca1 = new Recv0X9Ca1();
router.Send(client.map, recv0X9Ca1);
break;
case "obba61":
Recv0XBa61 recv0XBa61 = new Recv0XBa61();
router.Send(client.map, recv0XBa61);
break;
case "obd1f6":
Recv0Xd1F6 recv0Xd1F6 = new Recv0Xd1F6();
router.Send(client.map, recv0Xd1F6);
break;
case "obe8b9":
Recv0Xe8B9 recv0Xe8B9 = new Recv0Xe8B9();
router.Send(client.map, recv0Xe8B9);
break;
case "partnersummon":
RecvSoulPartnerSummonStartNotify recvSoulPartnerSummonStartNotify = new RecvSoulPartnerSummonStartNotify();
router.Send(client.map, recvSoulPartnerSummonStartNotify);
RecvSoulPartnerSummonExecR recvSoulPartnerSummonExecR = new RecvSoulPartnerSummonExecR();
router.Send(client.map, recvSoulPartnerSummonExecR);
RecvSoulPartnerUnlockAvatar recvSoulPartnerUnlockAvatar = new RecvSoulPartnerUnlockAvatar();
router.Send(client.map, recvSoulPartnerUnlockAvatar);
RecvSoulPartnerNotifyAvatar recvSoulPartnerNotifyAvatar = new RecvSoulPartnerNotifyAvatar();
router.Send(client.map, recvSoulPartnerNotifyAvatar);
break;
case "selectraise":
RecvDbgSelectRaise recvDbgSelectRaise = new RecvDbgSelectRaise();
router.Send(client.map, recvDbgSelectRaise);
break;
case "dragonpos":
RecvSelfDragonPosNotify recvSelfDragonPosNotify = new RecvSelfDragonPosNotify(client, (byte)x);
router.Send(client.map, recvSelfDragonPosNotify);
break;
case "dragonwarp":
RecvSelfDragonWarpNotify recvSelfDragonWarpNotify = new RecvSelfDragonWarpNotify((int)client.character.instanceId + 100);
router.Send(client.map, recvSelfDragonWarpNotify);
break;
case "exdragon":
RecvDataNotifyNpcExDragon recvDataNotifyNpcExDragon = new RecvDataNotifyNpcExDragon((uint)x);
router.Send(client.map, recvDataNotifyNpcExDragon);
break;
case "level":
RecvEventStart recvEventStart = new RecvEventStart(0, 0);
router.Send(recvEventStart, client);
Experience experience = new Experience();
client.character.level++;
client.character.hp.SetMax(client.character.hp.max + 10);
client.character.mp.SetMax(client.character.mp.max + 10);
client.character.strength += (ushort)Util.GetRandomNumber(0, 2);
client.character.vitality += (ushort)Util.GetRandomNumber(0, 2);
client.character.dexterity += (ushort)Util.GetRandomNumber(0, 2);
client.character.agility += (ushort)Util.GetRandomNumber(0, 2);
client.character.intelligence += (ushort)Util.GetRandomNumber(0, 2);
client.character.piety += (ushort)Util.GetRandomNumber(0, 2);
client.character.luck += (ushort)Util.GetRandomNumber(0, 2);
int luckyShot = Util.GetRandomNumber(0, client.character.luck);
if (luckyShot > client.character.luck * .8)
{
client.character.hp.SetMax(client.character.hp.max + 10);
client.character.mp.SetMax(client.character.mp.max + 10);
client.character.strength = (ushort)(Util.GetRandomNumber(-2, 2) + client.character.strength);
client.character.vitality = (ushort)(Util.GetRandomNumber(-2, 2) + client.character.vitality);
client.character.dexterity = (ushort)(Util.GetRandomNumber(-2, 2) + client.character.dexterity);
client.character.agility = (ushort)(Util.GetRandomNumber(-2, 2) + client.character.agility);
client.character.intelligence = (ushort)(Util.GetRandomNumber(-2, 2) + client.character.intelligence);
client.character.piety = (ushort)(Util.GetRandomNumber(-2, 2) + client.character.piety);
client.character.luck = (ushort)(Util.GetRandomNumber(-2, 2) + client.character.luck);
}
RecvCharaUpdateLvDetailStart recvCharaUpdateLvDetailStart = new RecvCharaUpdateLvDetailStart();
RecvCharaUpdateLv recvCharaUpdateLv = new RecvCharaUpdateLv(client.character);
RecvCharaUpdateLvDetail recvCharaUpdateLvDetail = new RecvCharaUpdateLvDetail(client.character, experience);
RecvCharaUpdateLvDetail2 recvCharaUpdateLvDetail2 = new RecvCharaUpdateLvDetail2(client.character, experience);
RecvCharaUpdateLvDetailEnd recvCharaUpdateLvDetailEnd = new RecvCharaUpdateLvDetailEnd();
RecvCharaUpdateMaxHp recvCharaUpdateMaxHp = new RecvCharaUpdateMaxHp(client.character.hp.max);
RecvCharaUpdateMaxMp recvCharaUpdateMaxMp = new RecvCharaUpdateMaxMp(client.character.mp.max);
RecvCharaUpdateAbility recvCharaUpdateAbilityStr = new RecvCharaUpdateAbility((int)RecvCharaUpdateAbility.Ability.Str, client.character.strength, client.character.battleParam.plusStrength);
RecvCharaUpdateAbility recvCharaUpdateAbilityVit = new RecvCharaUpdateAbility((int)RecvCharaUpdateAbility.Ability.Vit, client.character.vitality, client.character.battleParam.plusVitality);
RecvCharaUpdateAbility recvCharaUpdateAbilityDex = new RecvCharaUpdateAbility((int)RecvCharaUpdateAbility.Ability.Dex, client.character.dexterity, client.character.battleParam.plusDexterity);
RecvCharaUpdateAbility recvCharaUpdateAbilityAgi = new RecvCharaUpdateAbility((int)RecvCharaUpdateAbility.Ability.Agi, client.character.agility, client.character.battleParam.plusAgility);
RecvCharaUpdateAbility recvCharaUpdateAbilityInt = new RecvCharaUpdateAbility((int)RecvCharaUpdateAbility.Ability.Int, client.character.intelligence, client.character.battleParam.plusIntelligence);
RecvCharaUpdateAbility recvCharaUpdateAbilityPie = new RecvCharaUpdateAbility((int)RecvCharaUpdateAbility.Ability.Pie, client.character.piety, client.character.battleParam.plusPiety);
RecvCharaUpdateAbility recvCharaUpdateAbilityLuk = new RecvCharaUpdateAbility((int)RecvCharaUpdateAbility.Ability.Luk, client.character.luck, client.character.battleParam.plusLuck);
router.Send(recvCharaUpdateLvDetailStart, client);
router.Send(recvCharaUpdateMaxHp, client);
router.Send(recvCharaUpdateMaxMp, client);
router.Send(recvCharaUpdateAbilityStr, client);
router.Send(recvCharaUpdateAbilityVit, client);
router.Send(recvCharaUpdateAbilityDex, client);
router.Send(recvCharaUpdateAbilityAgi, client);
router.Send(recvCharaUpdateAbilityInt, client);
router.Send(recvCharaUpdateAbilityPie, client);
router.Send(recvCharaUpdateAbilityLuk, client);
router.Send(recvCharaUpdateLv, client);
router.Send(recvCharaUpdateLvDetail, client);
router.Send(recvCharaUpdateLvDetail2, client);
router.Send(recvCharaUpdateLvDetailEnd, client);
break;
case "questworks":
RecvQuestGetMissionQuestWorks recvQuestGetMissionQuestWorks = new RecvQuestGetMissionQuestWorks();
router.Send(client.map, recvQuestGetMissionQuestWorks);
break;
case "roguehistory":
RecvQuestGetRogueMissionQuestHistoryR recvQuestGetRogueMissionQuestHistoryR = new RecvQuestGetRogueMissionQuestHistoryR();
router.Send(client.map, recvQuestGetRogueMissionQuestHistoryR);
break;
case "debug":
//recv_data_notify_debug_object_data = 0x6510,
IBuffer resJ = BufferProvider.Provide();
resJ.WriteUInt32(400000221);
int numEntries = 0x20;
resJ.WriteInt32(numEntries); //less than or equal to 0x20
for (int i = 0; i < numEntries; i++)
{
resJ.WriteFloat(client.character.x + Util.GetRandomNumber(10, 50));
resJ.WriteFloat(client.character.y + Util.GetRandomNumber(10, 50));
resJ.WriteFloat(client.character.z + Util.GetRandomNumber(10, 50));
}
resJ.WriteByte(0);
resJ.WriteByte(0);
resJ.WriteByte(0);
router.Send(client.map, (ushort)AreaPacketId.recv_data_notify_debug_object_data, resJ,
ServerType.Area);
break;
case "interface":
RecvTradeNotifyInterfaceStatus recvTradeNotifyInterfaceStatus = new RecvTradeNotifyInterfaceStatus(x);
router.Send(client.map, recvTradeNotifyInterfaceStatus);
break;
case "maxhp":
RecvCharaUpdateMaxHp recvCharaUpdateMaxHp1 = new RecvCharaUpdateMaxHp(client.character.hp.max + 100);
client.character.hp.SetMax(client.character.hp.max + 100);
router.Send(client, recvCharaUpdateMaxHp1.ToPacket());
break;
default: //you don't know what you're doing do you?
_Logger.Error($"There is no recv of type : {command[0]} ");
{
responses.Add(ChatResponse.CommandError(client,
$"{command[0]} is not a valid command."));
}
break;
}
res = BufferProvider.Provide();
//Router.Send(client, (ushort)AreaPacketId.recv_situation_end, res, ServerType.Area);
res = BufferProvider.Provide();
res.WriteByte(0);
//Router.Send(client, (ushort)AreaPacketId.recv_event_end, res, ServerType.Area);
//Router.Send(client, (ushort)AreaPacketId.recv_event_end, res, ServerType.Area);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
switch (command[0])
{
case "mob":
responses.Add(ChatResponse.CommandError(client, "Mob instance ids for current map:"));
foreach (KeyValuePair <uint, MonsterSpawn> monster in client.map.monsterSpawns)
{
MonsterSpawn mobHolder = server.instances.GetInstance(monster.Key) as MonsterSpawn;
if (mobHolder != null)
{
responses.Add(ChatResponse.CommandError(client, $"{mobHolder.name} has instance id {mobHolder.instanceId}"));
}
}
break;
case "npc":
responses.Add(ChatResponse.CommandError(client, "Npc instance ids for current map:"));
foreach (KeyValuePair <uint, NpcSpawn> npc in client.map.npcSpawns)
{
NpcSpawn npcHolder = server.instances.GetInstance(npc.Key) as NpcSpawn;
if (npcHolder != null)
{
responses.Add(ChatResponse.CommandError(client, $"{npcHolder.name} has instance id {npcHolder.instanceId}"));
}
}
break;
case "maptran":
responses.Add(ChatResponse.CommandError(client, "Map transition instance ids for current map:"));
foreach (KeyValuePair <uint, MapTransition> mapTran in client.map.mapTransitions)
{
MapTransition mapTranHolder = server.instances.GetInstance(mapTran.Key) as MapTransition;
responses.Add(ChatResponse.CommandError(client, $"Map transition {mapTranHolder.id} has instance id {mapTranHolder.instanceId}"));
}
break;
case "gimmick":
responses.Add(ChatResponse.CommandError(client, "Gimmick instance ids for current map:"));
foreach (KeyValuePair <uint, Gimmick> gimmick in client.map.gimmickSpawns)
{
Gimmick gimmickHolder = server.instances.GetInstance(gimmick.Key) as Gimmick;
responses.Add(ChatResponse.CommandError(client, $"Gimmick {gimmickHolder.id} has instance id {gimmickHolder.instanceId}"));
}
break;
case "ggate":
responses.Add(ChatResponse.CommandError(client, "Ggate instance ids for current map:"));
foreach (KeyValuePair <uint, GGateSpawn> ggate in client.map.gGateSpawns)
{
GGateSpawn ggateHolder = server.instances.GetInstance(ggate.Key) as GGateSpawn;
responses.Add(ChatResponse.CommandError(client, $"Ggate {ggateHolder.id} has instance id {ggateHolder.instanceId}"));
}
break;
default:
_Logger.Error($"Unable to searc for: {command[0]} ");
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
if (!int.TryParse(command[1], out int x))
{
responses.Add(ChatResponse.CommandError(client, "Please provide a value. model Id or instance Id"));
return;
}
if (!int.TryParse(command[2], out int y))
{
responses.Add(ChatResponse.CommandError(client, "Good Job!"));
}
GGateSpawn myGGateSpawn = new GGateSpawn();
IBuffer res = BufferProvider.Provide();
switch (command[0])
{
case "spawn"
: //spawns a new object on the map at your position. makes a sign above it. and jumps over it
myGGateSpawn = new GGateSpawn();
server.instances.AssignInstance(myGGateSpawn);
myGGateSpawn.modelId = x;
myGGateSpawn.x = client.character.x;
myGGateSpawn.y = client.character.y;
myGGateSpawn.z = client.character.z;
myGGateSpawn.heading = client.character.heading;
myGGateSpawn.mapId = client.character.mapId;
myGGateSpawn.name = "";
myGGateSpawn.title = "";
myGGateSpawn.size = 100;
myGGateSpawn.active = 0;
myGGateSpawn.glow = 2;
myGGateSpawn.interaction = 1;
//Add a sign above them so you know their ID.
res = BufferProvider.Provide();
res.WriteUInt32(myGGateSpawn
.instanceId); // Unique Object ID. Crash if already in use (dont use your character ID)
res.WriteInt32(myGGateSpawn.serialId); // Serial ID for Interaction? from npc.csv????
res.WriteByte(myGGateSpawn.interaction); // 0 = Text, 1 = F to examine , 2 or above nothing
res.WriteCString($"You spawned a GGateSpawn model : {myGGateSpawn.modelId}"); //"0x5B" //Name
res.WriteCString(
$"The Instance ID of your GGateSpawn is: {myGGateSpawn.instanceId}"); //"0x5B" //Title
res.WriteFloat(client.character.x); //X Pos
res.WriteFloat(client.character.y); //Y Pos
res.WriteFloat(client.character.z); //Z Pos
res.WriteByte(client.character.heading); //view offset
res.WriteInt32(myGGateSpawn
.modelId); // Optional Model ID. Warp Statues. Gaurds, Pedistals, Etc., to see models refer to the model_common.csv
res.WriteInt16(myGGateSpawn.size); // size of the object
res.WriteInt32(myGGateSpawn
.active); // 0 = collision, 1 = no collision (active/Inactive?) //rename this to state...... >.>
res.WriteInt32(myGGateSpawn
.glow); //0= no effect color appear, //Red = 0bxx1x | Gold = obxxx1 |blue = 0bx1xx
router.Send(client.map, (ushort)AreaPacketId.recv_data_notify_ggate_stone_data, res,
ServerType.Area);
//Jump over your GGateSpawn
res = BufferProvider.Provide();
res.WriteUInt32(client.character.instanceId);
res.WriteFloat(client.character.x);
res.WriteFloat(client.character.y);
res.WriteFloat(client.character.z + 500);
res.WriteByte(client.character.heading);
res.WriteByte(client.character.movementAnim);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
responses.Add(ChatResponse.CommandError(client, $"Spawned GGateSpawn {myGGateSpawn.modelId} with instance id {myGGateSpawn.instanceId}"));
if (command[2] == "add"
) //if you want to send your GGateSpawn straight to the DB. type Add at the end of the spawn command.
{
if (!server.database.InsertGGateSpawn(myGGateSpawn))
{
responses.Add(ChatResponse.CommandError(client,
"myGGateSpawn could not be saved to database"));
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Added GGateSpawn {myGGateSpawn.id} to the database"));
}
}
break;
case "move": //move a GGateSpawn to your current position and heading
myGGateSpawn = server.instances.GetInstance((uint)x) as GGateSpawn;
myGGateSpawn.x = client.character.x;
myGGateSpawn.y = client.character.y;
myGGateSpawn.z = client.character.z;
myGGateSpawn.heading = client.character.heading;
res.WriteUInt32(myGGateSpawn.instanceId);
res.WriteFloat(client.character.x);
res.WriteFloat(client.character.y);
res.WriteFloat(client.character.z);
res.WriteByte(client.character.heading);
res.WriteByte(0xA);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
//Jump away from GGateSpawn
res = BufferProvider.Provide();
res.WriteUInt32(client.character.instanceId);
res.WriteFloat(client.character.x - 125);
res.WriteFloat(client.character.y);
res.WriteFloat(client.character.z + 50);
res.WriteByte(client.character.heading);
res.WriteByte(client.character.movementAnim);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
break;
case "heading": //only update the heading to your current heading
myGGateSpawn = server.instances.GetInstance((uint)x) as GGateSpawn;
myGGateSpawn.heading = client.character.heading;
res.WriteUInt32(myGGateSpawn.instanceId);
res.WriteFloat(myGGateSpawn.x);
res.WriteFloat(myGGateSpawn.y);
res.WriteFloat(myGGateSpawn.z);
res.WriteByte(client.character.heading);
res.WriteByte(0xA);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
break;
case "rotate": //rotates a GGateSpawn to a specified heading
int newHeading = y;
myGGateSpawn = server.instances.GetInstance((uint)x) as GGateSpawn;
myGGateSpawn.heading = (byte)newHeading;
myGGateSpawn.heading = (byte)y;
res.WriteUInt32(myGGateSpawn.instanceId);
res.WriteFloat(myGGateSpawn.x);
res.WriteFloat(myGGateSpawn.y);
res.WriteFloat(myGGateSpawn.z);
res.WriteByte((byte)y);
res.WriteByte(0xA);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
_Logger.Debug($"GGateSpawn {myGGateSpawn.instanceId} has been rotated to {y}*2 degrees.");
break;
case "height": //adjusts the height of GGateSpawn by current value +- Y
myGGateSpawn = server.instances.GetInstance((uint)x) as GGateSpawn;
myGGateSpawn.z = myGGateSpawn.z + y;
res.WriteUInt32(myGGateSpawn.instanceId);
res.WriteFloat(myGGateSpawn.x);
res.WriteFloat(myGGateSpawn.y);
res.WriteFloat(myGGateSpawn.z);
res.WriteByte(myGGateSpawn.heading);
res.WriteByte(0xA);
router.Send(client.map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
_Logger.Debug($"GGateSpawn {myGGateSpawn.instanceId} has been adjusted by a height of {y}.");
break;
case "add": //Adds a new entry to the database
myGGateSpawn = server.instances.GetInstance((uint)x) as GGateSpawn;
myGGateSpawn.updated = DateTime.Now;
if (!server.database.InsertGGateSpawn(myGGateSpawn))
{
responses.Add(ChatResponse.CommandError(client, "myGGateSpawn could not be saved to database"));
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Added GGateSpawn {myGGateSpawn.id} to the database"));
}
break;
case "update": //Updates an existing entry in the database
myGGateSpawn = server.instances.GetInstance((uint)x) as GGateSpawn;
myGGateSpawn.updated = DateTime.Now;
if (!server.database.UpdateGGateSpawn(myGGateSpawn))
{
responses.Add(ChatResponse.CommandError(client, "myGGateSpawn could not be saved to database"));
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Updated GGateSpawn {myGGateSpawn.id} in the database"));
}
break;
case "remove": //removes a GGateSpawn from the database
myGGateSpawn = server.instances.GetInstance((uint)x) as GGateSpawn;
if (!server.database.DeleteGGateSpawn(myGGateSpawn.id))
{
responses.Add(ChatResponse.CommandError(client,
"myGGateSpawn could not be deleted from database"));
return;
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Removed GGateSpawn {myGGateSpawn.id} from the database"));
}
res.WriteUInt32(myGGateSpawn.instanceId);
router.Send(client.map, (ushort)AreaPacketId.recv_object_disappear_notify, res, ServerType.Area);
break;
case "state": //updates GGate State.
res.WriteUInt32(myGGateSpawn.instanceId);
res.WriteInt32(y);
router.Send(client.map, (ushort)AreaPacketId.recv_npc_ggate_state_update_notify, res,
ServerType.Area);
break;
default: //you don't know what you're doing do you?
_Logger.Error($"There is no recv of type : {command[0]} ");
{
responses.Add(ChatResponse.CommandError(client,
$"{command[0]} is not a valid GGateSpawn command."));
}
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command.Length < 1)
{
responses.Add(ChatResponse.CommandError(client, "To few arguments"));
return;
}
if (!int.TryParse(command[0], out int itemId))
{
responses.Add(ChatResponse.CommandError(client, $"Invalid Number: {command[0]}"));
return;
}
if (client.character == null)
{
responses.Add(ChatResponse.CommandError(client, "Character is null"));
return;
}
if (!server.settingRepository.itemInfo.ContainsKey(itemId))
{
responses.Add(ChatResponse.CommandError(client, $"ItemId: '{itemId}' does not exist"));
return;
}
ItemSpawnParams spawmParam = new ItemSpawnParams();
spawmParam.itemStatuses = ItemStatuses.Identified;
if (command.Length > 1 && command[1] == "u")
{
spawmParam.itemStatuses = ItemStatuses.Unidentified;
}
ItemService itemService = new ItemService(client.character);
ItemInstance itemInstance = itemService.SpawnItemInstance(ItemZoneType.AdventureBag, itemId, spawmParam);
byte itemZoneOverride = 0;
IBuffer res = BufferProvider.Provide();
res.WriteInt32(2);
router.Send(client, (ushort)AreaPacketId.recv_situation_start, res, ServerType.Area);
if (command.Length > 1 && command[1] == "u")
{
if (command.Length > 2 && command[2] != "")
{
itemZoneOverride = byte.Parse(command[2]);
}
else
{
itemZoneOverride = (byte)itemInstance.location.zoneType;
}
_Logger.Debug(itemInstance.type.ToString());
RecvItemInstanceUnidentified recvItemInstanceUnidentified = new RecvItemInstanceUnidentified(client, itemInstance);
router.Send(client, recvItemInstanceUnidentified.ToPacket());
}
else
{
_Logger.Debug(itemInstance.type.ToString());
RecvItemInstance recvItemInstance = new RecvItemInstance(client, itemInstance);
router.Send(client, recvItemInstance.ToPacket());
}
res = BufferProvider.Provide();
router.Send(client, (ushort)AreaPacketId.recv_situation_end, res, ServerType.Area);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == "")
{
responses.Add(ChatResponse.CommandError(client,
$"Hi There! Type /Summon Character.Name Soul.Name to summon a character."));
responses.Add(ChatResponse.CommandError(client,
$"If they are offline, it will update their DB position to yours"));
responses.Add(ChatResponse.CommandError(client,
$"If they are online, it will warp them to your position."));
return;
}
if (command[1] == "")
{
responses.Add(ChatResponse.CommandError(client, $"Sooo close. you forgot the Soul.Name didn't you?"));
return;
}
bool soulFound = false;
foreach (Character theirCharacter in Server.Characters.GetAll())
{
Logger.Debug($"Comparing {theirCharacter.Name} to {command[0]}");
if (theirCharacter.Name == command[0])
{
Soul theirSoul = Server.Database.SelectSoulById(theirCharacter.SoulId);
responses.Add(ChatResponse.CommandError(client,
$"{theirCharacter.Name} {theirSoul.Name} is on Map {theirCharacter.MapId} with InstanceID {theirCharacter.InstanceId}"));
if (theirSoul.Name == command[1])
{
soulFound = true;
if (Server.Clients.GetBySoulName(theirSoul.Name) != null)
{
NecClient theirClient = Server.Clients.GetBySoulName(theirSoul.Name);
responses.Add(ChatResponse.CommandError(client,
$"{theirSoul.Name} is online, Moving them to you"));
if (theirClient.Character.MapId == client.Character.MapId)
{
IBuffer res = BufferProvider.Provide();
res.WriteUInt32(theirClient.Character.InstanceId);
res.WriteFloat(client.Character.X);
res.WriteFloat(client.Character.Y);
res.WriteFloat(client.Character.Z);
res.WriteByte(client.Character.Heading);
res.WriteByte(client.Character.movementAnim);
Router.Send(theirClient.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res,
ServerType.Area);
}
else
{
int X = (int)client.Character.X;
int Y = (int)client.Character.Y;
int Z = (int)client.Character.Z;
int Orietation = client.Character.Heading;
MapPosition mapPos = new MapPosition(X, Y, Z, (byte)Orietation);
client.Map.EnterForce(theirClient, mapPos);
}
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"updaing position to your current position"));
theirCharacter.X = client.Character.X;
theirCharacter.Y = client.Character.Y;
theirCharacter.Z = client.Character.Z;
theirCharacter.MapId = client.Character.MapId;
if (!Server.Database.UpdateCharacter(theirCharacter))
{
Logger.Error("Could not update the database with last known player position");
}
}
}
}
}
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 Character name."));
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
Character character2 = null;
if (uint.TryParse(command[1], out uint x))
{
IInstance instance = Server.Instances.GetInstance(x);
if (instance is Character character)
{
character2 = character;
}
else if (instance is DeadBody deadbody)
{
responses.Add(ChatResponse.CommandError(client, $"That's a dead body man. have some respect!"));
character2 = new Character();
character2.InstanceId = deadbody.InstanceId;
}
else
{
responses.Add(ChatResponse.CommandError(client, $"Please provide a character instance id"));
return;
}
}
if (!int.TryParse(command[2], out int y))
{
try
{
string binaryString = command[2];
binaryString = binaryString.Replace("0b", "");
Logger.Debug(binaryString);
y = Convert.ToInt32(binaryString, 2);
}
catch
{
responses.Add(ChatResponse.CommandError(client, $"Please provide a value to test"));
return;
}
}
switch (command[0])
{
case "hp":
IBuffer res = BufferProvider.Provide();
res.WriteInt32(y);
character2.Hp.setCurrent(y);
Router.Send(client, (ushort)AreaPacketId.recv_chara_update_hp, res, ServerType.Area);
break;
case "dead":
SendBattleReportStartNotify(client, character2);
//recv_battle_report_noact_notify_dead = 0xCDC9,
IBuffer res2 = BufferProvider.Provide();
res2.WriteUInt32(character2.InstanceId);
res2.WriteInt32(
y); // death type? 1 = death, 2 = death and message, 3 = unconscious, beyond that = nothing
res2.WriteInt32(0);
res2.WriteInt32(0);
Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_noact_notify_dead, res2,
ServerType.Area);
SendBattleReportEndNotify(client, character2);
break;
case "pose":
IBuffer res3 = BufferProvider.Provide();
//recv_battle_attack_pose_start_notify = 0x7CB2,
res3.WriteInt32(y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_attack_pose_start_notify, res3,
ServerType.Area);
break;
case "pose2":
IBuffer res4 = BufferProvider.Provide();
res4.WriteUInt32(character2.InstanceId); //Character ID
res4.WriteInt32(y); //Character pose
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_pose_notify, res4, ServerType.Area,
client);
break;
case "emotion":
//recv_emotion_notify_type = 0xF95B,
IBuffer res5 = BufferProvider.Provide();
res5.WriteUInt32(character2.InstanceId);
res5.WriteInt32(y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_emotion_notify_type, res5, ServerType.Area);
break;
case "deadstate":
//recv_charabody_notify_deadstate = 0xCC36, // Parent = 0xCB94 // Range ID = 03
IBuffer res6 = BufferProvider.Provide();
res6.WriteUInt32(character2.InstanceId);
res6.WriteInt32(
y); //4 here causes a cloud and the model to disappear, 5 causes a mist to happen and disappear
res6.WriteInt32(y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_charabody_notify_deadstate, res6,
ServerType.Area);
break;
case "start":
SendBattleReportStartNotify(client, character2);
IBuffer res7 = BufferProvider.Provide();
//recv_battle_report_action_item_enchant = 0x6BDC,
res7.WriteInt32(517);
res7.WriteInt32(y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_action_item_enchant, res7,
ServerType.Area);
SendBattleReportEndNotify(client, character2);
break;
case "end":
IBuffer res8 = BufferProvider.Provide();
Router.Send(client.Map, (ushort)AreaPacketId.recv_battle_report_end_notify, res8, ServerType.Area);
break;
case "gimmick":
//recv_data_notify_gimmick_data = 0xBFE9,
IBuffer res9 = BufferProvider.Provide();
res9.WriteInt32(y); //Gimmick instance id
res9.WriteFloat(client.Character.X + 100);
res9.WriteFloat(client.Character.Y);
res9.WriteFloat(client.Character.Z);
res9.WriteByte(client.Character.Heading);
res9.WriteInt32(y); //Gimmick number (from gimmick.csv)
res9.WriteInt32(0); //Gimmick State
Router.Send(client.Map, (ushort)AreaPacketId.recv_data_notify_gimmick_data, res9, ServerType.Area);
break;
case "bodystate": ///State of your dead body
//recv_charabody_state_update_notify = 0x1A0F,
IBuffer res10 = BufferProvider.Provide();
res10.WriteUInt32(character2.InstanceId);
res10.WriteInt32(y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_charabody_state_update_notify, res10,
ServerType.Area);
responses.Add(ChatResponse.CommandError(client,
$"setting bodyState to {y} for character {character2.Name}"));
break;
case "charastate": //state of your regular body
//recv_chara_notify_stateflag = 0x23D3,
IBuffer res11 = BufferProvider.Provide();
res11.WriteUInt32(character2.InstanceId);
res11.WriteInt32(y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_notify_stateflag, res11, ServerType.Area);
responses.Add(ChatResponse.CommandError(client,
$"setting charaState to {y} for character {character2.Name}"));
break;
case "spirit":
//recv_charabody_notify_spirit = 0x36A6,
IBuffer res12 = BufferProvider.Provide();
res12.WriteUInt32(character2.InstanceId);
res12.WriteByte((byte)y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_charabody_notify_spirit, res12, ServerType.Area);
break;
case "abyss": //lil marker in soul form of where you died if you jump off the map
//recv_charabody_self_notify_abyss_stead_pos = 0x679B,
IBuffer res13 = BufferProvider.Provide();
res13.WriteFloat(character2.X);
res13.WriteFloat(character2.Y);
res13.WriteFloat(character2.Z);
Router.Send(client.Map, (ushort)AreaPacketId.recv_charabody_self_notify_abyss_stead_pos, res13,
ServerType.Area);
break;
case "charadata":
RecvDataNotifyCharaData cData = new RecvDataNotifyCharaData(character2,
client.Soul.Name /*Should be client of supplied instanceID. this is a band-aid*/);
Router.Send(Server.Clients.GetAll(), cData.ToPacket());
break;
case "charabodydata":
//recv_data_notify_charabody_data = 0x906A,
DeadBody _deadBody = Server.Instances.GetInstance(character2.DeadBodyInstanceId) as DeadBody;
IBuffer res14 = BufferProvider.Provide();
res14.WriteUInt32(character2.DeadBodyInstanceId); //Instance ID of dead body
res14.WriteUInt32(character2.InstanceId); //Reference to actual player's instance ID
res14.WriteCString("soulname"); // Soul name
res14.WriteCString($"{character2.Name}"); // Character name
res14.WriteFloat(character2.X + 200); // X
res14.WriteFloat(character2.Y); // Y
res14.WriteFloat(character2.Z); // Z
res14.WriteByte(character2.Heading); // Heading
res14.WriteInt32(character2.Level); //??level?
int numEntries = 19;
res14.WriteInt32(numEntries); //less than or equal to 19
//Consolidated Frequently Used Code
LoadEquip.SlotSetup(res14, character2, numEntries);
res14.WriteInt32(numEntries);
//Consolidated Frequently Used Code
LoadEquip.EquipItems(res14, character2, numEntries);
res14.WriteInt32(numEntries);
//Consolidated Frequently Used Code
LoadEquip.EquipSlotBitMask(res14, character2, numEntries);
//Consolidated Frequently Used Code
LoadEquip.BasicTraits(res14, character2);
res14.WriteInt32(_deadBody
.ConnectionState); // 0 = bag, 1 for dead? (Can't enter soul form if this isn't 0 or 1 i think).
res14.WriteInt32(_deadBody.ModelType); //4 = ash pile, not sure what this is.
res14.WriteInt32(y);
res14.WriteInt32(_deadBody
.deathPose); //death pose 0 = faced down, 1 = head chopped off, 2 = no arm, 3 = faced down, 4 = chopped in half, 5 = faced down, 6 = faced down, 7 and up "T-pose" the body (ONLY SEND 1 IF YOU ARE CALLING THIS FOR THE FIRST TIME)
res14.WriteByte(_deadBody
.CriminalStatus); //crim status (changes icon on the end also), 0 = white, 1 = yellow, 2 = red, 3 = red with crim icon,
res14.WriteByte(_deadBody.BeginnerProtection); // (bool) Beginner protection
res14.WriteInt32(1);
Router.Send(client.Map, (ushort)AreaPacketId.recv_data_notify_charabody_data, res14,
ServerType.Area);
break;
case "scaleopen":
IBuffer res0 = BufferProvider.Provide();
res0.WriteInt32(0); //1 = cinematic, 0 Just start the event without cinematic
res0.WriteByte(0);
Router.Send(client, (ushort)AreaPacketId.recv_event_start, res0, ServerType.Area);
IBuffer res15 = BufferProvider.Provide();
//recv_raisescale_view_open = 0xC25D, // Parent = 0xC2E5 // Range ID = 01 // was 0xC25D
res15.WriteInt16(1); //Basic revival rate %
res15.WriteInt16(5); //Penalty %
res15.WriteInt16(
(short)y); //Offered item % (this probably changes with recv_raisescale_update_success_per)
res15.WriteInt16(4); //Dimento medal addition %
Router.Send(client, (ushort)AreaPacketId.recv_raisescale_view_open, res15, ServerType.Area);
break;
case "event":
IBuffer res16 = BufferProvider.Provide();
//recv_event_start = 0x1B5C,
res16.WriteInt32(0);
res16.WriteByte(0);
Router.Send(client, (ushort)AreaPacketId.recv_event_start, res16, ServerType.Area);
IBuffer res17 = BufferProvider.Provide();
//recv_event_quest_report = 0xE07E,
res17.WriteInt32(0);
Router.Send(client, (ushort)AreaPacketId.recv_event_quest_report, res17, ServerType.Area);
IBuffer res18 = BufferProvider.Provide();
//recv_event_block_message_end_no_object = 0x1AB,
//Router.Send(client, (ushort)AreaPacketId.recv_event_block_message_end_no_object, res18, ServerType.Area);
IBuffer res19 = BufferProvider.Provide();
Router.Send(client, (ushort)AreaPacketId.recv_event_sync, res19, ServerType.Area);
break;
case "popup":
IBuffer res22 = BufferProvider.Provide();
//recv_event_start = 0x1B5C,
res22.WriteInt32(0);
res22.WriteByte((byte)y);
//Router.Send(client, (ushort)AreaPacketId.recv_event_start, res22, ServerType.Area);
IBuffer res21 = BufferProvider.Provide();
//recv_normal_system_message = 0xAE2B,
res21.WriteCString("ToBeFound");
Router.Send(client, (ushort)AreaPacketId.recv_normal_system_message, res21, ServerType.Area);
IBuffer res23 = BufferProvider.Provide();
//recv_event_end = 0x99D,
res23.WriteByte((byte)y);
//Router.Send(client, (ushort)AreaPacketId.recv_event_end, res23, ServerType.Area);
break;
case "recv":
IBuffer res24 = BufferProvider.Provide();
//recv_auction_receive_item_r = 0xB1CA,
res24.WriteInt32(y);
Router.Send(client, (ushort)AreaPacketId.recv_auction_receive_gold_r, res24, ServerType.Area);
break;
case "string":
IBuffer res26 = BufferProvider.Provide();
//recv_charabody_notify_loot_item = 0x8CDE, // Parent = 0x8CC6 // Range ID = 01
res26.WriteByte(0);
res26.WriteByte(0);
res26.WriteInt16(0);
res26.WriteInt16((short)y);
res26.WriteCString("adad"); // Length 0x31
res26.WriteCString("adad"); // Length 0x5B
Router.Send(client, (ushort)AreaPacketId.recv_charabody_notify_loot_item, res26, ServerType.Area);
break;
case "ac":
IBuffer res27 = BufferProvider.Provide();
//recv_item_update_ac
res27.WriteInt64(10200101);
res27.WriteInt16((short)y);
Router.Send(client, (ushort)AreaPacketId.recv_item_update_ac, res27, ServerType.Area);
break;
case "alignment":
IBuffer res28 = BufferProvider.Provide();
//recv_chara_update_alignment_param = 0xB435,
res28.WriteInt32(1);
res28.WriteInt32(2);
res28.WriteInt32(3);
Router.Send(client, (ushort)AreaPacketId.recv_chara_update_alignment_param, res28,
ServerType.Area);
break;
case "shop":
IBuffer res29 = BufferProvider.Provide();
//recv_shop_notify_open = 0x52FD, // Parent = 0x5243 // Range ID = 02
res29.WriteInt16((short)y); //Shop type
res29.WriteInt32(0);
res29.WriteInt32(0);
res29.WriteByte(0);
Router.Send(client, (ushort)AreaPacketId.recv_shop_notify_open, res29, ServerType.Area);
break;
case "dura":
IBuffer res30 = BufferProvider.Provide();
res30.WriteInt64(10200101);
res30.WriteInt32(y); // MaxDura points
Router.Send(client, (ushort)AreaPacketId.recv_item_update_maxdur, res30, ServerType.Area);
//recv_item_update_durability = 0x1F5A,
IBuffer res31 = BufferProvider.Provide();
res31.WriteInt64(10200101);
res31.WriteInt32(y - 1);
Router.Send(client, (ushort)AreaPacketId.recv_item_update_durability, res31, ServerType.Area);
break;
case "sc":
IBuffer res32 = BufferProvider.Provide();
//recv_shop_sell_check_r = 0x4E8D,
res32.WriteInt32(0);
Router.Send(client, (ushort)AreaPacketId.recv_shop_sell_check_r, res32, ServerType.Area);
break;
case "view":
IBuffer res33 = BufferProvider.Provide();
//recv_chara_view_landing_notify = 0x14DA,
res33.WriteInt32(y);
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_view_landing_notify, res33,
ServerType.Area);
break;
case "itemnum":
IBuffer res34 = BufferProvider.Provide();
//recv_item_update_num = 0x5F8,
res34.WriteInt64(10200101);
res34.WriteByte(25);
Router.Send(client, (ushort)AreaPacketId.recv_item_update_num, res34, ServerType.Area);
break;
case "damage":
int hp = character2.Hp.current;
client.Character.Hp.Modify(-hp, character2.InstanceId);
IBuffer res35 = BufferProvider.Provide();
res35.WriteInt32(hp - hp);
Router.Send(client, (ushort)AreaPacketId.recv_chara_update_hp, res35, ServerType.Area);
break;
case "union":
IBuffer res36 = BufferProvider.Provide();
res36.WriteUInt32(client.Character.InstanceId);
res36.WriteInt32(8888 /*client.Character.UnionId*/);
res36.WriteCString("Trade_Union");
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_notify_union_data, res36, ServerType.Area);
break;
case "xunion":
IBuffer res37 = BufferProvider.Provide();
res37.WriteUInt32(client.Character.InstanceId);
res37.WriteInt32(0 /*client.Character.UnionId*/);
res37.WriteCString("");
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_notify_union_data, res37, ServerType.Area);
break;
case "itemforth":
IBuffer res38 = BufferProvider.Provide();
res38.WriteUInt32(client.Character.InstanceId); //item ID?
res38.WriteInt32(10200101); //Owner going 'forth' id?
res38.WriteUInt32(client.Character.InstanceId); //item state setting?
Router.Send(client.Map, (ushort)AreaPacketId.recv_chara_update_notify_item_forth, res38,
ServerType.Area);
break;
case "disconnect":
NecClient DeadManClient = Server.Clients.GetByCharacterInstanceId(x);
IBuffer res39 = BufferProvider.Provide();
res39.WriteUInt32(client.Character.InstanceId);
res39.WriteUInt32(client.Character.InstanceId);
res39.WriteUInt32(client.Character.InstanceId);
res39.WriteUInt32(client.Character.InstanceId);
res39.WriteUInt32(client.Character.InstanceId);
res39.WriteUInt32(client.Character.InstanceId);
res39.WriteUInt32(client.Character.InstanceId);
Router.Send(DeadManClient, (ushort)AreaPacketId.recv_chara_update_notify_item_forth, res39,
ServerType.Area);
break;
case "crime":
//for (byte i = 0; i < y; i++)
{
NecClient crimeClient = Server.Clients.GetByCharacterInstanceId(x);
IBuffer res40 = BufferProvider.Provide();
res40.WriteUInt32(crimeClient.Character.InstanceId);
res40.WriteByte((byte)y);
client.Character.criminalState = (byte)y;
Logger.Debug($"Setting crime level for Character {crimeClient.Character.Name} to {y}");
Router.Send(crimeClient, (ushort)AreaPacketId.recv_chara_update_notify_crime_lv, res40,
ServerType.Area);
Router.Send(crimeClient.Map, (ushort)AreaPacketId.recv_charabody_notify_crime_lv, res40,
ServerType.Area, crimeClient);
Thread.Sleep(400);
}
break;
case "inherit":
//for (byte i = 0; i < y; i++)
{
NecClient inheritClient = Server.Clients.GetByCharacterInstanceId(x);
IBuffer res41 = BufferProvider.Provide();
res41.WriteInt32(y);
res41.WriteInt32(0x64); //less than or equal to 0x64
for (int i = 0; i < 0x64; i++) //limit is the int32 above
{
res41.WriteInt32(i);
// TODO what ip is this? Area Msg ?? use -> Server.Setting.DataAreaIpAddress or Server.Setting.DataMsgIpAddress
res41.WriteFixedString("127.0.0.1", 0x10); //size is 0x10
}
res41.WriteUInt32(client.Character.InstanceId);
// TODO what ip is this? Area Msg ?? use -> Server.Setting.DataAreaIpAddress or Server.Setting.DataMsgIpAddress
res41.WriteFixedString("127.0.0.1", 0x10); //size is 0x10
res41.WriteByte((byte)y);
Router.Send(inheritClient, (ushort)MsgPacketId.recv_chara_get_inheritinfo_r, res41,
ServerType.Msg);
Thread.Sleep(400);
}
break;
default:
Logger.Error($"There is no recv of type : {command[0]} ");
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
List <PacketResponse> brList = new List <PacketResponse>();
//always start your battle reports
RecvBattleReportStartNotify brStart = new RecvBattleReportStartNotify(client.character.instanceId);
brList.Add(brStart);
RecvBattleReportEndNotify brEnd = new RecvBattleReportEndNotify();
IBuffer res36 = BufferProvider.Provide();
switch (command[0])
{
case "itemuse":
RecvBattleReportActionItemUse itemUse = new RecvBattleReportActionItemUse(50100302 /*camp*/);
brList.Add(itemUse);
break;
case "stealunidentified":
RecvBattleReportActionStealUnidentified stealUnidentified = new RecvBattleReportActionStealUnidentified(50100302 /*camp*/);
brList.Add(stealUnidentified);
break;
case "stealmoney":
RecvBattleReportActionStealMoney stealMoney = new RecvBattleReportActionStealMoney(50100302 /*camp*/);
brList.Add(stealMoney);
break;
case "97d9":
RecvBattleReportNoactNotifyHealAp o97d9 = new RecvBattleReportNoactNotifyHealAp();
brList.Add(o97d9);
break;
case "partygetitem":
RecvPartyNotifyGetItem recvPartyNotifyGetItem = new RecvPartyNotifyGetItem(client.character.instanceId);
router.Send(recvPartyNotifyGetItem, client);
IBuffer res = BufferProvider.Provide();
res.WriteInt32(200101);
res.WriteCString("Dagger");
res.WriteByte(20);
router.Send(client.map, (ushort)MsgPacketId.recv_party_notify_get_item, res, ServerType.Msg);
break;
case "partygetmoney":
RecvPartyNotifyGetMoney recvPartyNotifyGetMoney = new RecvPartyNotifyGetMoney(client.character.instanceId);
router.Send(client.map, recvPartyNotifyGetMoney);
break;
case "ac":
RecvBattleReportNotifyDamageAc recvBattleReportNotifyDamageAc = new RecvBattleReportNotifyDamageAc(client.character.instanceId, Util.GetRandomNumber(0, 250));
brList.Add(recvBattleReportNotifyDamageAc);
break;
default:
_Logger.Error($"There is no recv of type : {command[0]} ");
Task.Delay(TimeSpan.FromMilliseconds(10 * 1000)).ContinueWith
(t1 => { }
);
break;
}
//always end your battle reports
//brList.Add(brEnd);
router.Send(client, brList);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
Character character2 = null;
NpcSpawn npc2 = null;
Gimmick gimmick2 = null;
MonsterSpawn monsterSpawn2 = null;
if (uint.TryParse(command[0], out uint x))
{
IInstance instance = Server.Instances.GetInstance(x);
if (instance is Character character)
{
character2 = character;
}
else if (instance is NpcSpawn npc)
{
npc2 = npc;
}
else if (instance is Gimmick gimmick)
{
gimmick2 = gimmick;
}
else if (instance is MonsterSpawn monsterSpawn)
{
monsterSpawn2 = monsterSpawn;
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Please provide a character/npc/gimmick instance id"));
return;
}
}
IBuffer res = BufferProvider.Provide();
if (character2 != null)
{
res.WriteUInt32(client.Character.InstanceId);
res.WriteFloat(character2.X);
res.WriteFloat(character2.Y);
res.WriteFloat(character2.Z);
res.WriteByte(client.Character.Heading);
res.WriteByte(client.Character.movementAnim);
}
else if (npc2 != null)
{
res.WriteUInt32(client.Character.InstanceId);
res.WriteFloat(npc2.X);
res.WriteFloat(npc2.Y);
res.WriteFloat(npc2.Z);
res.WriteByte(client.Character.Heading);
res.WriteByte(client.Character.movementAnim);
}
else if (gimmick2 != null)
{
res.WriteUInt32(client.Character.InstanceId);
res.WriteFloat(gimmick2.X);
res.WriteFloat(gimmick2.Y);
res.WriteFloat(gimmick2.Z);
res.WriteByte(client.Character.Heading);
res.WriteByte(client.Character.movementAnim);
}
else if (monsterSpawn2 != null)
{
res.WriteUInt32(client.Character.InstanceId);
res.WriteFloat(monsterSpawn2.X);
res.WriteFloat(monsterSpawn2.Y);
res.WriteFloat(monsterSpawn2.Z);
res.WriteByte(client.Character.Heading);
res.WriteByte(client.Character.movementAnim);
}
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
Logger.Debug($"Entering");
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
}
Logger.Debug($"command [0]");
int.TryParse(command[1], out int x);
int.TryParse(command[2], out int y);
int.TryParse(command[3], out int z);
switch (command[0])
{
case "dagger":
Item item = null;
if (y == 0)
{
RecvCharaUpdateAlignment charAlign = new RecvCharaUpdateAlignment(1);
_server.Router.Send(charAlign, client);
item = SendItemInstanceUnidentified(client, 10200101, x, (int)ITEM_TYPE.DAGGER, "Dagger");
}
else
{
item = SendItemInstance(client, 10200101, (int)ITEM_TYPE.DAGGER, "Dagger");
}
if (item == null)
{
return;
}
Logger.Debug($"dagger instanceId [{item.InstanceId}]");
break;
case "healpot":
Item healItem = null;
if (y == 0)
{
healItem = SendItemInstanceUnidentified(client, 50100101, x, (int)ITEM_TYPE.DRUG, "Heal Pot");
}
else
{
//healItem = SendItemInstance(client, "Test");
}
Logger.Debug($"dagger instanceId [{healItem.InstanceId}]");
break;
case "create":
Item createItem = null;
if (y == 0)
{
createItem = SendItemInstanceUnidentified(client, x, 1, y, "");
}
else
{
//createItem = SendItemInstance(client, "Test");
}
Logger.Debug($"dagger instanceId [{createItem.InstanceId}]");
break;
case "draw":
RecvPartyNotifyAddDrawItem itemMsg = new RecvPartyNotifyAddDrawItem((ulong)x, 30.0F, 0);
_server.Router.Send(itemMsg, client);
break;
case "getitema":
IBuffer resa = BufferProvider.Provide();
//recv_normal_system_message = 0xAE2B,
resa.WriteInt32(x);
resa.WriteCString(command[3]);
resa.WriteByte((byte)y);
Router.Send(client, (ushort)AreaPacketId.recv_party_notify_get_item, resa, ServerType.Area);
break;
case "getitemm":
IBuffer resm = BufferProvider.Provide();
//recv_normal_system_message = 0xAE2B,
resm.WriteInt32(x);
resm.WriteCString(command[3]);
resm.WriteByte((byte)y);
Router.Send(client, (ushort)MsgPacketId.recv_party_notify_get_item, resm, ServerType.Msg);
break;
case "soulitem":
IBuffer res19 = BufferProvider.Provide();
res19.WriteInt32(Util.GetRandomNumber(62000001, 62000015)); //soul_dispitem.csv
Router.Send(client, (ushort)AreaPacketId.recv_soul_dispitem_notify_data, res19, ServerType.Area);
break;
case "soulmat":
for (int i = 0; i < x; i++)
{
IBuffer res20 = BufferProvider.Provide();
res20.WriteInt32(Util.GetRandomNumber(998000, 1000000));
res20.WriteFloat(client.Character.X); //X
res20.WriteFloat(client.Character.Y); //Y
res20.WriteFloat(client.Character.Z); //Z
res20.WriteFloat(client.Character.X + Util.GetRandomNumber(-300, 300)); //X
res20.WriteFloat(client.Character.Y + Util.GetRandomNumber(-300, 200)); //Y
res20.WriteFloat(client.Character.Z + 10); //Z
res20.WriteByte((byte)Util.GetRandomNumber(0, 255));
res20.WriteInt32(Util.GetRandomNumber(0, 199999));
res20.WriteInt32(Util.GetRandomNumber(0, 199999));
res20.WriteInt32(Util.GetRandomNumber(0, 199999));
res20.WriteInt32(Util.GetRandomNumber(0, 1000)); // bitmask 0bxxxxx1 = arch 0bxxxxx0 = no arch
y = Util.GetRandomNumber(1, 4);
if (y == 1)
{
Router.Send(client, (ushort)AreaPacketId.recv_data_notify_goldobject_data, res20,
ServerType.Area);
}
res20.WriteInt32(Util.GetRandomNumber(0, 199999));
if (y == 2)
{
Router.Send(client, (ushort)AreaPacketId.recv_data_notify_soulmaterialobject_data, res20,
ServerType.Area);
}
if (y == 3)
{
Router.Send(client, (ushort)AreaPacketId.recv_data_notify_itemobject_data, res20,
ServerType.Area);
}
}
break;
case "physics":
IBuffer res21 = BufferProvider.Provide();
res21.WriteInt64(x); //item instance id
res21.WriteInt16((short)y); //item's attack stat
Router.Send(client, (ushort)AreaPacketId.recv_item_update_physics, res21, ServerType.Area);
break;
case "leatherguard":
case "lg":
if (y == 0)
{
item = SendItemInstanceUnidentified(client, 100101, x, (int)ITEM_TYPE.HELMET, "Leather Guard");
}
else
{
item = SendItemInstance(client, 100101, (int)ITEM_TYPE.HELMET, "Leather Guard");
}
if (item == null)
{
return;
}
Logger.Debug($"dagger instanceId [{item.InstanceId}]");
break;
case "rottenleathermail":
case "rlm":
if (x == 0)
{
item = SendItemInstanceUnidentified(client, 200110, 1, y, "Rotten Leather Mail");
}
else
{
item = SendItemInstance(client, 200110, (int)ITEM_TYPE.COAT, "Rotten Leather Mail");
}
if (item == null)
{
return;
}
Logger.Debug($"dagger instanceId [{item.InstanceId}]");
break;
case "buff":
Buff[] selfBuffs = new Buff[1];
Buff testBuff = new Buff();
testBuff.buffId = x;
testBuff.unknown1 = y;
testBuff.unknown2 = z;
selfBuffs[0] = testBuff;
RecvSelfBuffNotify selfBuff = new RecvSelfBuffNotify(selfBuffs);
_server.Router.Send(selfBuff, client);
break;
case "itemt":
IBuffer res = BufferProvider.Provide();
res.WriteUInt64(invItem.InstanceId);
res.WriteInt16((short)x);
Router.Send(client, (ushort)AreaPacketId.recv_0x746F, res, ServerType.Area);
break;
case "testitem":
Item item1 = SendItemInstanceUnidentified(client, 10200101, 1, (int)ITEM_TYPE.DAGGER, "Dagger");
RecvItemTest recvTest = new RecvItemTest((ulong)item1.InstanceId, (ushort)x, (uint)y, (uint)z);
Router.Send(recvTest, client);
break;
default:
Logger.Error($"There is no recv of type : {command[0]} ");
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command.Length < 1)
{
responses.Add(ChatResponse.CommandError(client, "To few arguments"));
return;
}
switch (command[0])
{
case "map":
{
foreach (NecClient theirClient in client.map.clientLookup.GetAll())
{
responses.Add(ChatResponse.CommandInfo(client,
$"{theirClient.character.name} {theirClient.soul.name} is on Map {theirClient.character.mapId} with InstanceID {theirClient.character.instanceId}"));
}
break;
}
case "world":
{
foreach (NecClient theirClient in server.clients.GetAll())
{
if (theirClient.map != null)
{
responses.Add(ChatResponse.CommandInfo(client,
$"{theirClient.character.name} {theirClient.soul.name} is on Map {theirClient.character.mapId} with InstanceID {theirClient.character.instanceId}"));
}
}
break;
}
default:
foreach (NecClient otherClient in server.clients.GetAll())
{
Character character = otherClient.character;
if (character == null)
{
continue;
}
if (character.name.Equals(command[0], StringComparison.InvariantCultureIgnoreCase))
{
string mapName = "None";
Map map = client.map;
if (map != null)
{
mapName = $"{map.id} ({map.place})";
}
responses.Add(ChatResponse.CommandInfo(client,
$"CharacterName: {character.name} SoulId:{character.soulId} Map:{mapName} InstanceId: {character.instanceId}"));
return;
}
}
responses.Add(ChatResponse.CommandError(client, $"Character: '{command[0]}' not found"));
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
MonsterSpawn monsterSpawn = new 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;
}
server.instances.AssignInstance(monsterSpawn);
RecvDataNotifyMonsterData monsterData = new RecvDataNotifyMonsterData(monsterSpawn);
router.Send(client.map, monsterData);
//IBuffer res = BufferProvider.Provide();
//res.WriteUInt32((uint)monsterSetting.id);
////Toggles state between Alive(attackable), Dead(lootable), or Inactive(nothing).
//res.WriteInt32(_i);
//_i++;
//router.Send(client, (ushort)AreaPacketId.recv_monster_state_update_notify, res, ServerType.Area);
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
Character character2 = null;
if (uint.TryParse(command[1], out uint x))
{
IInstance instance = server.instances.GetInstance(x);
if (instance is Character character)
{
character2 = character;
}
else if (instance is DeadBody deadbody)
{
responses.Add(ChatResponse.CommandError(client, "That's a dead body man. have some respect!"));
character2 = new Character();
character2.instanceId = deadbody.instanceId;
}
else
{
responses.Add(ChatResponse.CommandError(client, "Please provide a character instance id"));
return;
}
}
if (!int.TryParse(command[2], out int y))
{
try
{
string binaryString = command[2];
binaryString = binaryString.Replace("0b", "");
_Logger.Debug(binaryString);
y = Convert.ToInt32(binaryString, 2);
}
catch
{
responses.Add(ChatResponse.CommandError(client, "Please provide a value to test"));
return;
}
}
switch (command[0])
{
case "hp":
IBuffer res = BufferProvider.Provide();
res.WriteInt32(y);
character2.hp.SetCurrent(y);
router.Send(client, (ushort)AreaPacketId.recv_chara_update_hp, res, ServerType.Area);
RecvCharaUpdateMaxHp recvCharaUpdateMaxHp1 = new RecvCharaUpdateMaxHp(y);
if (y > character2.hp.max)
{
router.Send(client, recvCharaUpdateMaxHp1.ToPacket());
}
break;
case "dead":
SendBattleReportStartNotify(client, character2);
//recv_battle_report_noact_notify_dead = 0xCDC9,
IBuffer res2 = BufferProvider.Provide();
res2.WriteUInt32(character2.instanceId);
res2.WriteInt32(2); // death type? 1 = death, 2 = death and message, 3 = unconscious, beyond that = nothing
res2.WriteInt32(2);
res2.WriteInt32(y);
router.Send(client.map, (ushort)AreaPacketId.recv_battle_report_noact_notify_dead, res2,
ServerType.Area);
SendBattleReportEndNotify(client, character2);
break;
case "pose2":
IBuffer res4 = BufferProvider.Provide();
res4.WriteUInt32(character2.instanceId); //Character ID
res4.WriteInt32(y); //Character pose
router.Send(client.map, (ushort)AreaPacketId.recv_chara_pose_notify, res4, ServerType.Area);
break;
case "emotion":
//recv_emotion_notify_type = 0xF95B,
IBuffer res5 = BufferProvider.Provide();
res5.WriteUInt32(character2.instanceId);
res5.WriteInt32(y);
router.Send(client.map, (ushort)AreaPacketId.recv_emotion_notify_type, res5, ServerType.Area);
break;
case "deadstate":
//recv_charabody_notify_deadstate = 0xCC36, // Parent = 0xCB94 // Range ID = 03
IBuffer res6 = BufferProvider.Provide();
res6.WriteUInt32(character2.deadBodyInstanceId);
res6.WriteInt32(y); //4 changes body to ash pile, 5 causes a mist to happen and disappear
res6.WriteInt32(y); // change type. unknown impact.
router.Send(client.map, (ushort)AreaPacketId.recv_charabody_notify_deadstate, res6,
ServerType.Area);
break;
case "start":
SendBattleReportStartNotify(client, character2);
IBuffer res7 = BufferProvider.Provide();
//recv_battle_report_action_item_enchant = 0x6BDC,
res7.WriteInt32(517);
res7.WriteInt32(y);
router.Send(client.map, (ushort)AreaPacketId.recv_battle_report_action_item_enchant, res7,
ServerType.Area);
SendBattleReportEndNotify(client, character2);
break;
case "end":
IBuffer res8 = BufferProvider.Provide();
router.Send(client.map, (ushort)AreaPacketId.recv_battle_report_end_notify, res8, ServerType.Area);
break;
case "bodystate": ///State of your dead body
//recv_charabody_state_update_notify = 0x1A0F,
IBuffer res10 = BufferProvider.Provide();
res10.WriteUInt32(character2.deadBodyInstanceId);
res10.WriteInt32(y); //0b0 = disconnected backpack, 0b1 = normal, 0b100 = title:On 0b10000=invisible. nothing above ob1 << 5
router.Send(client.map, (ushort)AreaPacketId.recv_charabody_state_update_notify, res10, ServerType.Area);
responses.Add(ChatResponse.CommandError(client, $"setting bodyState to {y} for character {character2.name}"));
break;
case "charastate": //state of your regular body
//recv_chara_notify_stateflag = 0x23D3,
IBuffer res11 = BufferProvider.Provide();
res11.WriteUInt32(character2.instanceId);
res11.WriteInt64(y);
router.Send(client.map, (ushort)AreaPacketId.recv_chara_notify_stateflag, res11, ServerType.Area);
responses.Add(ChatResponse.CommandError(client,
$"setting charaState to {y} for character {character2.name}"));
break;
case "spirit":
//recv_charabody_notify_spirit = 0x36A6, // Dead-Body online status toggle. 0 = disconnected client. 1 = connected
NecClient necClient = client.map.clientLookup.GetByCharacterInstanceId(character2.instanceId);
IBuffer res12 = BufferProvider.Provide();
res12.WriteUInt32(character2.deadBodyInstanceId);
res12.WriteByte((byte)y);
router.Send(necClient, (ushort)AreaPacketId.recv_charabody_notify_spirit, res12, ServerType.Area);
break;
case "abyss": //lil marker in soul form of where you died if you jump off the map
//recv_charabody_self_notify_abyss_stead_pos = 0x679B,
IBuffer res13 = BufferProvider.Provide();
res13.WriteFloat(character2.x);
res13.WriteFloat(character2.y);
res13.WriteFloat(character2.z);
router.Send(client.map, (ushort)AreaPacketId.recv_charabody_self_notify_abyss_stead_pos, res13,
ServerType.Area);
break;
case "charadata":
RecvDataNotifyCharaData cData = new RecvDataNotifyCharaData(character2,
client.soul.name /*Should be client of supplied instanceID. this is a band-aid*/);
router.Send(server.clients.GetAll(), cData.ToPacket());
break;
case "charabodydata":
//recv_data_notify_charabody_data = 0x906A,
DeadBody deadBody = server.instances.GetInstance(character2.deadBodyInstanceId) as DeadBody;
IBuffer res14 = BufferProvider.Provide();
res14.WriteUInt32(character2.deadBodyInstanceId); //Instance ID of dead body
res14.WriteUInt32(character2.instanceId); //Reference to actual player's instance ID
res14.WriteCString("soulname"); // Soul name
res14.WriteCString($"{character2.name}"); // Character name
res14.WriteFloat(character2.x + 200); // X
res14.WriteFloat(character2.y); // Y
res14.WriteFloat(character2.z); // Z
res14.WriteByte(character2.heading); // Heading
res14.WriteInt32(character2.level); //??level?
int numEntries = 19;
res14.WriteInt32(numEntries); //less than or equal to 19
//Consolidated Frequently Used Code
//LoadEquip.SlotSetup(res14, character2, numEntries);
res14.WriteInt32(numEntries);
//Consolidated Frequently Used Code
//LoadEquip.EquipItems(res14, character2, numEntries);
res14.WriteInt32(numEntries);
//Consolidated Frequently Used Code
//LoadEquip.EquipSlotBitMask(res14, character2, numEntries);
//Traits
res14.WriteUInt32(character2.raceId); //race
res14.WriteUInt32(character2.sexId);
res14.WriteByte(character2.hairId); //hair
res14.WriteByte(character2.hairColorId); //color
res14.WriteByte(character2.faceId); //face
res14.WriteInt32(deadBody
.connectionState); // 0 = bag, 1 for dead? (Can't enter soul form if this isn't 0 or 1 i think).
res14.WriteInt32(deadBody.modelType); //4 = ash pile, not sure what this is.
res14.WriteInt32(y);
res14.WriteInt32(deadBody
.deathPose); //death pose 0 = faced down, 1 = head chopped off, 2 = no arm, 3 = faced down, 4 = chopped in half, 5 = faced down, 6 = faced down, 7 and up "T-pose" the body (ONLY SEND 1 IF YOU ARE CALLING THIS FOR THE FIRST TIME)
res14.WriteByte(deadBody
.criminalStatus); //crim status (changes icon on the end also), 0 = white, 1 = yellow, 2 = red, 3 = red with crim icon,
res14.WriteByte(deadBody.beginnerProtection); // (bool) Beginner protection
res14.WriteInt32(1);
router.Send(client.map, (ushort)AreaPacketId.recv_data_notify_charabody_data, res14,
ServerType.Area);
break;
case "event":
IBuffer res16 = BufferProvider.Provide();
//recv_event_start = 0x1B5C,
res16.WriteInt32(0);
res16.WriteByte(0);
router.Send(client, (ushort)AreaPacketId.recv_event_start, res16, ServerType.Area);
IBuffer res17 = BufferProvider.Provide();
//recv_event_quest_report = 0xE07E,
res17.WriteInt32(0);
router.Send(client, (ushort)AreaPacketId.recv_event_quest_report, res17, ServerType.Area);
IBuffer res18 = BufferProvider.Provide();
//recv_event_block_message_end_no_object = 0x1AB,
//Router.Send(client, (ushort)AreaPacketId.recv_event_block_message_end_no_object, res18, ServerType.Area);
IBuffer res19 = BufferProvider.Provide();
router.Send(client, (ushort)AreaPacketId.recv_event_sync, res19, ServerType.Area);
break;
case "popup":
IBuffer res22 = BufferProvider.Provide();
//recv_event_start = 0x1B5C,
res22.WriteInt32(0);
res22.WriteByte((byte)y);
//Router.Send(client, (ushort)AreaPacketId.recv_event_start, res22, ServerType.Area);
IBuffer res21 = BufferProvider.Provide();
//recv_normal_system_message = 0xAE2B,
res21.WriteCString("ToBeFound");
router.Send(client, (ushort)AreaPacketId.recv_normal_system_message, res21, ServerType.Area);
IBuffer res23 = BufferProvider.Provide();
//recv_event_end = 0x99D,
res23.WriteByte((byte)y);
//Router.Send(client, (ushort)AreaPacketId.recv_event_end, res23, ServerType.Area);
break;
case "recv":
IBuffer res24 = BufferProvider.Provide();
//recv_auction_receive_item_r = 0xB1CA,
res24.WriteInt32(y);
router.Send(client, (ushort)AreaPacketId.recv_auction_receive_gold_r, res24, ServerType.Area);
break;
case "atk": //udates settings 1-22 on the attribute tab
res = BufferProvider.Provide();
res.WriteInt32(y);
res.WriteInt16(888);
router.Send(client, (ushort)AreaPacketId.recv_chara_update_atk_magic_attr, res, ServerType.Area);
break;
case "ability": //udates settings 1-7 on the ability tab
res = BufferProvider.Provide();
res.WriteInt32(y); //attribute
res.WriteInt16(10); //base
res.WriteInt16(25); //total
router.Send(client, (ushort)AreaPacketId.recv_chara_update_ability, res, ServerType.Area);
break;
case "battle": //udates settings 1-7 on the ability tab
res = BufferProvider.Provide();
res.WriteInt16(10);
res.WriteInt16(10);
res.WriteInt16(10);
res.WriteInt16(10);
res.WriteInt16(10);
res.WriteInt16(10);
res.WriteInt16(10);
res.WriteInt16(10);
router.Send(client, (ushort)AreaPacketId.recv_chara_update_battle_base_param, res, ServerType.Area);
break;
case "alignment":
IBuffer res28 = BufferProvider.Provide();
//recv_chara_update_alignment_param = 0xB435,
res28.WriteInt32(1);
res28.WriteInt32(2);
res28.WriteInt32(3);
router.Send(client, (ushort)AreaPacketId.recv_chara_update_alignment_param, res28, ServerType.Area);
res28 = BufferProvider.Provide();
res28.WriteInt32(y); //Alignment ID
router.Send(client, (ushort)AreaPacketId.recv_chara_update_alignment, res28, ServerType.Area);
break;
case "shop":
IBuffer res29 = BufferProvider.Provide();
//recv_shop_notify_open = 0x52FD, // Parent = 0x5243 // Range ID = 02
res29.WriteInt16((short)y); //Shop type
res29.WriteInt32(0);
res29.WriteInt32(0);
res29.WriteByte(0);
router.Send(client, (ushort)AreaPacketId.recv_shop_notify_open, res29, ServerType.Area);
break;
case "sc":
IBuffer res32 = BufferProvider.Provide();
//recv_shop_sell_check_r = 0x4E8D,
res32.WriteInt32(0);
router.Send(client, (ushort)AreaPacketId.recv_shop_sell_check_r, res32, ServerType.Area);
break;
case "view":
IBuffer res33 = BufferProvider.Provide();
//recv_chara_view_landing_notify = 0x14DA,
res33.WriteInt32(y);
router.Send(client.map, (ushort)AreaPacketId.recv_chara_view_landing_notify, res33,
ServerType.Area);
break;
case "damage":
int hp = character2.hp.current;
client.character.hp.Modify(-hp, character2.instanceId);
IBuffer res35 = BufferProvider.Provide();
res35.WriteInt32(hp - hp);
router.Send(client, (ushort)AreaPacketId.recv_chara_update_hp, res35, ServerType.Area);
break;
case "itemforth":
IBuffer res38 = BufferProvider.Provide();
res38.WriteUInt32(200000002); //item ID?
res38.WriteInt32(200101); //Owner going 'forth' id?
res38.WriteUInt32(200201); //item state setting?
res38.WriteByte(1); //newJp
router.Send(client.map, (ushort)AreaPacketId.recv_chara_update_notify_item_forth, res38,
ServerType.Area);
break;
case "disconnect":
NecClient deadManClient = server.clients.GetByCharacterInstanceId(x);
IBuffer res39 = BufferProvider.Provide();
res39.WriteUInt32(client.character.instanceId);
res39.WriteUInt32(client.character.instanceId);
res39.WriteUInt32(client.character.instanceId);
res39.WriteUInt32(client.character.instanceId);
res39.WriteUInt32(client.character.instanceId);
res39.WriteUInt32(client.character.instanceId);
res39.WriteUInt32(client.character.instanceId);
router.Send(deadManClient, (ushort)AreaPacketId.recv_chara_update_notify_item_forth, res39,
ServerType.Area);
break;
case "crime":
//for (byte i = 0; i < y; i++)
{
NecClient crimeClient = server.clients.GetByCharacterInstanceId(x);
IBuffer res40 = BufferProvider.Provide();
res40.WriteUInt32(crimeClient.character.instanceId);
res40.WriteByte((byte)y);
client.character.criminalState = (byte)y;
_Logger.Debug($"Setting crime level for Character {crimeClient.character.name} to {y}");
router.Send(crimeClient, (ushort)AreaPacketId.recv_chara_update_notify_crime_lv, res40, ServerType.Area);
router.Send(crimeClient.map, (ushort)AreaPacketId.recv_charabody_notify_crime_lv, res40, ServerType.Area, crimeClient);
Thread.Sleep(400);
}
break;
case "inherit":
//for (byte i = 0; i < y; i++)
{
NecClient inheritClient = server.clients.GetByCharacterInstanceId(x);
IBuffer res41 = BufferProvider.Provide();
res41.WriteInt32(y);
res41.WriteInt32(0x64); //less than or equal to 0x64
for (int i = 0; i < 0x64; i++) //limit is the int32 above
{
res41.WriteInt32(i);
// TODO what ip is this? Area Msg ?? use -> Server.Setting.DataAreaIpAddress or Server.Setting.DataMsgIpAddress
res41.WriteFixedString("127.0.0.1", 0x10); //size is 0x10
}
res41.WriteUInt32(client.character.instanceId);
// TODO what ip is this? Area Msg ?? use -> Server.Setting.DataAreaIpAddress or Server.Setting.DataMsgIpAddress
res41.WriteFixedString("127.0.0.1", 0x10); //size is 0x10
res41.WriteByte((byte)y);
router.Send(inheritClient, (ushort)MsgPacketId.recv_chara_get_inheritinfo_r, res41,
ServerType.Msg);
Thread.Sleep(400);
}
break;
case "seqmask":
IBuffer res43 = BufferProvider.Provide();
//95 torso ?
//55 full armor too ?
//93 full armor ?
// 27 full armor ?
//11 under ?
// 38 = boots and cape
//byte y = unchecked((byte)110111);
//byte y = unchecked ((byte)Util.GetRandomNumber(0, 100)); // for the moment i only get the armor on this way :/
/*int[] EquipBitMask = new int[]
* {
* 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288,
* 1048576, 2097152
* };*/
res43.WriteInt64(180201);
res43.WriteInt32(y);
router.Send(client.map, (ushort)AreaPacketId.recv_item_update_spirit_eqmask, res43, ServerType.Area);
break;
default:
_Logger.Error($"There is no recv of type : {command[0]} ");
break;
}
}
public override void Execute(string[] command, NecClient client, ChatMessage message,
List <ChatResponse> responses)
{
if (command[0] == null)
{
responses.Add(ChatResponse.CommandError(client, $"Invalid argument: {command[0]}"));
return;
}
if (!int.TryParse(command[1], out int x))
{
responses.Add(ChatResponse.CommandError(client, $"Please provide a value. model Id or instance Id"));
return;
}
if (!int.TryParse(command[2], out int y))
{
responses.Add(ChatResponse.CommandError(client, $"Good Job!"));
}
Gimmick myGimmick = new Gimmick();
IBuffer res = BufferProvider.Provide();
switch (command[0])
{
case "spawn"
: //spawns a new object on the map at your position. makes a sign above it. and jumps over it
myGimmick = Server.Instances.CreateInstance <Gimmick>();
myGimmick.ModelId = x;
myGimmick.X = client.Character.X;
myGimmick.Y = client.Character.Y;
myGimmick.Z = client.Character.Z;
myGimmick.Heading = client.Character.Heading;
myGimmick.State = 0xA;
myGimmick.MapId = client.Character.MapId;
res.WriteUInt32(myGimmick.InstanceId);
res.WriteFloat(client.Character.X);
res.WriteFloat(client.Character.Y);
res.WriteFloat(client.Character.Z);
res.WriteByte(client.Character.Heading);
res.WriteInt32(x); //Gimmick number (from gimmick.csv)
res.WriteInt32(0); //Gimmick State
Router.Send(client.Map, (ushort)AreaPacketId.recv_data_notify_gimmick_data, res, ServerType.Area);
Logger.Debug($"You just created a gimmick with instance ID {myGimmick.InstanceId}");
//Add a sign above them so you know their ID.
GGateSpawn gGateSpawn = Server.Instances.CreateInstance <GGateSpawn>();
res = BufferProvider.Provide();
res.WriteUInt32(gGateSpawn
.InstanceId); // Unique Object ID. Crash if already in use (dont use your character ID)
res.WriteInt32(gGateSpawn.SerialId); // Serial ID for Interaction? from npc.csv????
res.WriteByte(0); // 0 = Text, 1 = F to examine , 2 or above nothing
res.WriteCString($"You spawned a Gimmick model : {myGimmick.ModelId}"); //"0x5B" //Name
res.WriteCString($"The Instance ID of your Gimmick is: {myGimmick.InstanceId}"); //"0x5B" //Title
res.WriteFloat(client.Character.X); //X Pos
res.WriteFloat(client.Character.Y); //Y Pos
res.WriteFloat(client.Character.Z + 200); //Z Pos
res.WriteByte(client.Character.Heading); //view offset
res.WriteInt32(gGateSpawn
.ModelId); // Optional Model ID. Warp Statues. Gaurds, Pedistals, Etc., to see models refer to the model_common.csv
res.WriteInt16(gGateSpawn.Size); // size of the object
res.WriteInt32(gGateSpawn.Active); // 0 = collision, 1 = no collision (active/Inactive?)
res.WriteInt32(gGateSpawn
.Glow); //0= no effect color appear, //Red = 0bxx1x | Gold = obxxx1 |blue = 0bx1xx
Router.Send(client.Map, (ushort)AreaPacketId.recv_data_notify_ggate_stone_data, res,
ServerType.Area);
//Jump over your gimmick
res = BufferProvider.Provide();
res.WriteUInt32(client.Character.InstanceId);
res.WriteFloat(client.Character.X);
res.WriteFloat(client.Character.Y);
res.WriteFloat(client.Character.Z + 500);
res.WriteByte(client.Character.Heading);
res.WriteByte(client.Character.movementAnim);
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
responses.Add(ChatResponse.CommandError(client, $"Spawned gimmick {myGimmick.ModelId}"));
if (command[2] == "add"
) //if you want to send your gimmick straight to the DB. type Add at the end of the spawn command.
{
if (!Server.Database.InsertGimmick(myGimmick))
{
responses.Add(ChatResponse.CommandError(client,
"myGimmick could not be saved to database"));
return;
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Added gimmick {myGimmick.Id} to the database"));
}
}
break;
case "move": //move a gimmick to your current position and heading
myGimmick = Server.Instances.GetInstance((uint)x) as Gimmick;
myGimmick.X = client.Character.X;
myGimmick.Y = client.Character.Y;
myGimmick.Z = client.Character.Z;
myGimmick.Heading = client.Character.Heading;
res.WriteUInt32(myGimmick.InstanceId);
res.WriteFloat(client.Character.X);
res.WriteFloat(client.Character.Y);
res.WriteFloat(client.Character.Z);
res.WriteByte(client.Character.Heading);
res.WriteByte(0xA);
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
//Jump away from gimmick
res = BufferProvider.Provide();
res.WriteUInt32(client.Character.InstanceId);
res.WriteFloat(client.Character.X - 125);
res.WriteFloat(client.Character.Y);
res.WriteFloat(client.Character.Z + 50);
res.WriteByte(client.Character.Heading);
res.WriteByte(client.Character.movementAnim);
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
break;
case "heading": //only update the heading to your current heading
myGimmick = Server.Instances.GetInstance((uint)x) as Gimmick;
myGimmick.Heading = client.Character.Heading;
res.WriteUInt32(myGimmick.InstanceId);
res.WriteFloat(myGimmick.X);
res.WriteFloat(myGimmick.Y);
res.WriteFloat(myGimmick.Z);
res.WriteByte(client.Character.Heading);
res.WriteByte(0xA);
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
break;
case "rotate": //rotates a gimmick to a specified heading
int newHeading = y;
myGimmick = Server.Instances.GetInstance((uint)x) as Gimmick;
myGimmick.Heading = (byte)newHeading;
myGimmick.Heading = (byte)y;
res.WriteUInt32(myGimmick.InstanceId);
res.WriteFloat(myGimmick.X);
res.WriteFloat(myGimmick.Y);
res.WriteFloat(myGimmick.Z);
res.WriteByte((byte)y);
res.WriteByte(0xA);
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
Logger.Debug($"Gimmick {myGimmick.InstanceId} has been rotated to {y}*2 degrees.");
break;
case "height": //adjusts the height of gimmick by current value +- Y
myGimmick = Server.Instances.GetInstance((uint)x) as Gimmick;
myGimmick.Z = myGimmick.Z + y;
res.WriteUInt32(myGimmick.InstanceId);
res.WriteFloat(myGimmick.X);
res.WriteFloat(myGimmick.Y);
res.WriteFloat(myGimmick.Z);
res.WriteByte(myGimmick.Heading);
res.WriteByte(0xA);
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_point_move_notify, res, ServerType.Area);
Logger.Debug($"Gimmick {myGimmick.InstanceId} has been adjusted by a height of {y}.");
break;
case "add": //Adds a new entry to the database
myGimmick = Server.Instances.GetInstance((uint)x) as Gimmick;
myGimmick.Updated = DateTime.Now;
if (!Server.Database.InsertGimmick(myGimmick))
{
responses.Add(ChatResponse.CommandError(client, "myGimmick could not be saved to database"));
return;
}
else
{
responses.Add(
ChatResponse.CommandError(client, $"Added gimmick {myGimmick.Id} to the database"));
}
break;
case "update": //Updates an existing entry in the database
myGimmick = Server.Instances.GetInstance((uint)x) as Gimmick;
myGimmick.Updated = DateTime.Now;
if (!Server.Database.UpdateGimmick(myGimmick))
{
responses.Add(ChatResponse.CommandError(client, "myGimmick could not be saved to database"));
return;
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Updated gimmick {myGimmick.Id} in the database"));
}
break;
case "remove": //removes a gimmick from the database
myGimmick = Server.Instances.GetInstance((uint)x) as Gimmick;
if (!Server.Database.DeleteGimmick(myGimmick.Id))
{
responses.Add(ChatResponse.CommandError(client,
"myGimmick could not be deleted from database"));
return;
}
else
{
responses.Add(ChatResponse.CommandError(client,
$"Removed gimmick {myGimmick.Id} from the database"));
}
res.WriteUInt32(myGimmick.InstanceId);
Router.Send(client.Map, (ushort)AreaPacketId.recv_object_disappear_notify, res, ServerType.Area);
break;
default: //you don't know what you're doing do you?
Logger.Error($"There is no recv of type : {command[0]} ");
{
responses.Add(ChatResponse.CommandError(client, $"{command[0]} is not a valid gimmick command."));
}
break;
}
}
