public void chatToClients(ChatPacket p)
{
foreach (Guid item in this.server.ClientList)
{
threadSafeToComBox("Sending to: " + item.ToString() + "\r\n");
server.Send(p, item);
}
}
public GUIBoard()
{
InitializeComponent();
clientGui.DataReceived += ClientGui_DataReceived;
clientGui.Start();
ChatPacket temp = new ChatPacket(0003, "Client", "Client connected.", this.GameID.ToString());
clientGui.Send(temp);
}
private void Enter(object sender, KeyEventArgs e)
{
if(e.KeyCode == Keys.Enter)
{
ChatPacket toSend = new ChatPacket(0003, "Bobby", ChatLine.Text, this.GameID.ToString());
clientGui.Send(toSend);
ChatLine.Clear();
}
}
public void HandlePacket(EndPoint senderEndPoint, ChatPacket receivedData)
{
if (_packetHandlers.ContainsKey(receivedData.ChatDataIdentifier))
{
Server.Broadcast(_packetHandlers[receivedData.ChatDataIdentifier](senderEndPoint, receivedData));
}
else
{
Logger.WriteLine("Bad packet received.");
Server.Kick(senderEndPoint);
}
}
public static void Animation(Session session, params string[] parameters)
{
uint animationId;
try
{
animationId = Convert.ToUInt32(parameters[0]);
}
catch (Exception)
{
ChatPacket.SendServerMessage(session, "Invalid Animation value", ChatMessageType.Broadcast);
return;
}
UniversalMotion motion = new UniversalMotion(MotionStance.Standing, new MotionItem((MotionCommand)animationId));
session.Player.HandleActionMotion(motion);
}
public int Send(Chat_Model_Base model, Type type, int to_id, bool promise = true, Func <Coop_Model_ACK, bool> onReceiveAck = null, Func <Coop_Model_Base, bool> onPreResend = null)
{
int result = 0;
ChatPacket chatPacket = new ChatPacket();
ChatPacketHeader chatPacketHeader2 = chatPacket.header = new ChatPacketHeader(0, model.commandId, fromId);
chatPacket.model = model;
PacketStream stream = chatPacket.Serialize();
if (model.commandId == 502)
{
goto IL_0040;
}
goto IL_0040;
IL_0040:
NativeSend(stream);
return(result);
}
public override void Handle()
{
// this check is also done clientside, see: PlayerDesc::PlayerIsPSR
if (!session.Player.IsAdmin && !session.Player.IsArch && !session.Player.IsPsr)
{
return;
}
uint cell = position.Cell;
uint cellX = (cell >> 3);
//TODO: Wrap command in a check to confirm session.character IsAdvocate or higher access level
//TODO: Maybe output to chat window coords teleported to.
//ChatPacket.SendSystemMessage(session, $"Teleporting to: 0.0[N/S], 0.0[E/W]");
ChatPacket.SendSystemMessage(session, "Teleporting...");
session.Player.Teleport(position);
}
/// <summary>
/// Handles teleporting a player to the lifestone (/ls or /lifestone command)
/// </summary>
public void HandleActionTeleToLifestone()
{
if (Sanctuary != null)
{
// FIXME(ddevec): I should probably make a better interface for this
UpdateVital(Mana, Mana.Current / 2);
if (CombatMode != CombatMode.NonCombat)
{
// this should be handled by a different thing, probably a function that forces player into peacemode
var updateCombatMode = new GameMessagePrivateUpdatePropertyInt(this, PropertyInt.CombatMode, (int)CombatMode.NonCombat);
SetCombatMode(CombatMode.NonCombat);
Session.Network.EnqueueSend(updateCombatMode);
}
EnqueueBroadcast(new GameMessageSystemChat($"{Name} is recalling to the lifestone.", ChatMessageType.Recall));
EnqueueBroadcastMotion(motionLifestoneRecall);
var startPos = new Position(Location);
// Wait for animation
ActionChain lifestoneChain = new ActionChain();
// Then do teleport
lifestoneChain.AddDelaySeconds(DatManager.PortalDat.ReadFromDat <MotionTable>(MotionTableId).GetAnimationLength(MotionCommand.LifestoneRecall));
lifestoneChain.AddAction(this, () =>
{
var endPos = new Position(Location);
if (startPos.SquaredDistanceTo(endPos) > RecallMoveThresholdSq)
{
Session.Network.EnqueueSend(new GameEventWeenieError(Session, WeenieError.YouHaveMovedTooFar));
return;
}
Teleport(Sanctuary);
});
lifestoneChain.EnqueueChain();
}
else
{
ChatPacket.SendServerMessage(Session, "Your spirit has not been attuned to a sanctuary location.", ChatMessageType.Broadcast);
}
}
public static void SetVital(Session session, params string[] parameters)
{
string paramVital = parameters[0].ToLower();
string paramValue = parameters[1];
bool relValue = paramValue[0] == '+' || paramValue[0] == '-';
int value = int.MaxValue;
if (!int.TryParse(paramValue, out value))
{
ChatPacket.SendServerMessage(session, "setvital Error: Invalid set value", ChatMessageType.Broadcast);
return;
}
// Parse args...
CreatureVital vital = null;
if (paramVital == "health" || paramVital == "hp")
{
vital = session.Player.Health;
}
else if (paramVital == "stamina" || paramVital == "stam" || paramVital == "sp")
{
vital = session.Player.Stamina;
}
else if (paramVital == "mana" || paramVital == "mp")
{
vital = session.Player.Mana;
}
else
{
ChatPacket.SendServerMessage(session, "setvital Error: Invalid vital", ChatMessageType.Broadcast);
return;
}
if (!relValue)
{
session.Player.UpdateVital(vital, (uint)value);
}
else
{
session.Player.DeltaVital(vital, value);
}
}
public static void EquipTest(Session session, params string[] parameters)
{
if (!(parameters?.Length > 0))
{
ChatPacket.SendServerMessage(session, "Usage: @equiptest (hex)clothingTableId [palette_index].\neg '@equiptest 0x100005fd'",
ChatMessageType.Broadcast);
return;
}
uint modelId;
try
{
if (parameters[0].StartsWith("0x"))
{
string strippedmodelid = parameters[0].Substring(2);
modelId = UInt32.Parse(strippedmodelid, System.Globalization.NumberStyles.HexNumber);
}
else
{
modelId = UInt32.Parse(parameters[0], System.Globalization.NumberStyles.HexNumber);
}
int palOption = -1;
if (parameters.Length > 1)
{
palOption = Int32.Parse(parameters[1]);
}
if ((modelId >= 0x10000001) && (modelId <= 0x1000086B))
{
session.Player.TestWieldItem(session, modelId, palOption);
}
else
{
ChatPacket.SendServerMessage(session, "Please enter a value greater than 0x10000000 and less than 0x1000086C",
ChatMessageType.Broadcast);
}
}
catch (Exception)
{
ChatPacket.SendServerMessage(session, "Please enter a value greater than 0x10000000 and less than 0x1000086C", ChatMessageType.Broadcast);
}
}
private void ProcessChat(ChatPacket obj)
{
// Do some validation on chat and then send it off
var user = ServiceContainer.Users[obj.Sender];
// Sending this to nothing is useless
if (user.CurrentSession == null)
{
return;
}
var newMessage = user.Name + ": " + obj.Message;
foreach (var recipient in user.CurrentSession.Users)
{
var packet = new ChatPacket(newMessage);
ClientNetworkManager.Instance.SendPacket(packet, recipient.Connection);
}
}
private static void HandleWorldChat(GameSession session, string message, ChatType type)
{
List <Item> playerInventoryItems = new(session.Player.Inventory.Items.Values);
Item voucher = playerInventoryItems.FirstOrDefault(x => x.Tag == "FreeWorldChatCoupon");
if (voucher != null)
{
session.Send(NoticePacket.Notice(SystemNotice.UsedWorldChatVoucher, NoticeType.ChatAndFastText));
InventoryController.Consume(session, voucher.Uid, 1);
}
else if (!session.Player.Wallet.RemoveMerets(30))
{
session.Send(ChatPacket.Error(session.Player, SystemNotice.InsufficientMerets, ChatType.NoticeAlert));
return;
}
MapleServer.BroadcastPacketAll(ChatPacket.Send(session.Player, message, type));
}
public async override void Handle()
{
var result = await Session.Player.AddFriend(friendName);
switch (result)
{
case Enum.AddFriendResult.AlreadyInList:
ChatPacket.SendServerMessage(Session, "That character is already in your friends list", ChatMessageType.Broadcast);
break;
case Enum.AddFriendResult.FriendWithSelf:
ChatPacket.SendServerMessage(Session, "Sorry, but you can't be friends with yourself.", ChatMessageType.Broadcast);
break;
case Enum.AddFriendResult.CharacterDoesNotExist:
ChatPacket.SendServerMessage(Session, "That character does not exist", ChatMessageType.Broadcast);
break;
}
}
private static void HandleWhisperChat(GameSession session, string recipient, string message)
{
Player recipientPlayer = GameServer.Storage.GetPlayerByName(recipient);
if (recipientPlayer == null)
{
session.Send(ChatPacket.Error(session.Player, SystemNotice.UnableToWhisper, ChatType.WhisperFail));
return;
}
if (BuddyManager.IsBlocked(session.Player, recipientPlayer))
{
session.Send(ChatPacket.Error(session.Player, SystemNotice.UnableToWhisper, ChatType.WhisperFail));
return;
}
recipientPlayer.Session.Send(ChatPacket.Send(session.Player, message, ChatType.WhisperFrom));
session.Send(ChatPacket.Send(recipientPlayer, message, ChatType.WhisperTo));
}
private void OnReceiveMessage(ChatPacket packet)
{
Chat_Model_BroadcastClanMessage_Response chat_Model_BroadcastClanMessage_Response = packet.model as Chat_Model_BroadcastClanMessage_Response;
int result = 0;
int result2 = 0;
int.TryParse(chat_Model_BroadcastClanMessage_Response.SenderId, out result);
int.TryParse(chat_Model_BroadcastClanMessage_Response.Id, out result2);
if (result == 0)
{
if (this.onReceiveNotification != null)
{
this.onReceiveNotification(chat_Model_BroadcastClanMessage_Response.Message);
}
}
else if (chat_Model_BroadcastClanMessage_Response.Message.Contains(STAMP_SYMBOL_BEGIN))
{
string s = chat_Model_BroadcastClanMessage_Response.Message.Substring(STAMP_SYMBOL_BEGIN.Length, 8);
int result3 = -1;
int.TryParse(s, out result3);
if (this.onReceiveStamp != null)
{
ClanChatLogMessageData clanChatLogMessageData = new ClanChatLogMessageData();
clanChatLogMessageData.uuid = chat_Model_BroadcastClanMessage_Response.Uuid;
clanChatLogMessageData.id = result2;
clanChatLogMessageData.fromUserId = result;
clanChatLogMessageData.senderName = chat_Model_BroadcastClanMessage_Response.SenderName;
clanChatLogMessageData.stampId = result3;
this.onReceiveStamp(clanChatLogMessageData);
}
}
else if (this.onReceiveText != null)
{
ClanChatLogMessageData clanChatLogMessageData2 = new ClanChatLogMessageData();
clanChatLogMessageData2.uuid = chat_Model_BroadcastClanMessage_Response.Uuid;
clanChatLogMessageData2.id = result2;
clanChatLogMessageData2.fromUserId = result;
clanChatLogMessageData2.senderName = chat_Model_BroadcastClanMessage_Response.SenderName;
clanChatLogMessageData2.message = chat_Model_BroadcastClanMessage_Response.Message;
this.onReceiveText(clanChatLogMessageData2);
}
}
public static void HandleTele(Session session, params string[] parameters)
{
// Used PhatAC source to implement most of this. Thanks Pea!
// usage: @tele [name] longitude latitude
// This command teleports yourself (or the specified character) to the given longitude and latitude.
// @tele - Teleports you(or a player) to some location.
if (session.Player.IsAdvocate && session.Player.AdvocateLevel < 5)
{
return;
}
List <CommandParameterHelpers.ACECommandParameter> aceParams = new List <CommandParameterHelpers.ACECommandParameter>()
{
new CommandParameterHelpers.ACECommandParameter()
{
Type = CommandParameterHelpers.ACECommandParameterType.Player,
Required = false,
DefaultValue = session.Player
},
new CommandParameterHelpers.ACECommandParameter()
{
Type = CommandParameterHelpers.ACECommandParameterType.Location,
Required = true,
ErrorMessage = "You must supply a location to teleport to.\nExample: /tele 37s,67w"
}
};
if (!CommandParameterHelpers.ResolveACEParameters(session, parameters, aceParams))
{
return;
}
// TODO: Check if water block?
ChatPacket.SendServerMessage(session, $"Position: [Cell: 0x{aceParams[1].AsPosition.LandblockId.Landblock:X4} | Offset: {aceParams[1].AsPosition.PositionX}, " +
$"{aceParams[1].AsPosition.PositionY}, {aceParams[1].AsPosition.PositionZ} | Facing: {aceParams[1].AsPosition.RotationX}, {aceParams[1].AsPosition.RotationY}, " +
$"{ aceParams[1].AsPosition.RotationZ}, {aceParams[1].AsPosition.RotationW}]", ChatMessageType.Broadcast);
aceParams[0].AsPlayer.Teleport(aceParams[1].AsPosition);
}
public static void CreateStaticCreature(Session session, params string[] parameters)
{
Creature newC = null;
if (!(parameters?.Length > 0))
{
ChatPacket.SendServerMessage(session, "Usage: @createcreature [static] weenieClassId",
ChatMessageType.Broadcast);
return;
}
if (parameters?[0] == "static")
{
if (parameters?.Length > 1)
{
uint weenie = Convert.ToUInt32(parameters[1]);
newC = MonsterFactory.SpawnCreature(weenie, true, session.Player.Location.InFrontOf(2.0f));
}
else
{
ChatPacket.SendServerMessage(session, "Specify a valid weenieClassId after the static option.",
ChatMessageType.Broadcast);
return;
}
}
else
{
uint weenie = Convert.ToUInt32(parameters[0]);
newC = MonsterFactory.SpawnCreature(weenie, false, session.Player.Location.InFrontOf(2.0f));
}
if (newC != null)
{
ChatPacket.SendServerMessage(session, $"Now spawning {newC.Name}.",
ChatMessageType.Broadcast);
LandblockManager.AddObject(newC);
}
else
{
ChatPacket.SendServerMessage(session, "Couldn't find that creature in the database or save it's location.",
ChatMessageType.Broadcast);
}
}
public static void Main()
{
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("AppSettings.json", false, true)
.Build();
var networkerSettings = config.GetSection("Horizon");
var server = new ServerBuilder()
.UseTcp(networkerSettings.GetValue <int>("TcpPort"))
.ConfigureLogging(loggingBuilder =>
{
loggingBuilder.AddConfiguration(config.GetSection("Logging"));
loggingBuilder.AddConsole();
})
.RegisterPacketHandler <ChatPacket, ChatPacketHandler>()
.UseProtobufNet()
.Build();
server.Start();
var gameClient = new GameClient();
gameClient.Client.Connect();
var packet = new ChatPacket
{
Message = "Hello Google Protobuf"
};
using (var file = File.Create("chat.bin"))
{
Serializer.Serialize(file, packet);
}
while (server.Information.IsRunning)
{
gameClient.Client.Send(packet);
Thread.Sleep(1000);
}
}
public void SpendXp(Enum.Ability ability, uint amount)
{
uint baseValue = character.Abilities[ability].Base;
uint result = SpendAbilityXp(character.Abilities[ability], amount);
bool isSecondary = (ability == Enum.Ability.Health || ability == Enum.Ability.Stamina || ability == Enum.Ability.Mana);
uint ranks = character.Abilities[ability].Ranks;
uint newValue = character.Abilities[ability].UnbuffedValue;
string messageText = "";
if (result > 0u)
{
GameMessage abilityUpdate;
if (!isSecondary)
{
abilityUpdate = new GameMessagePrivateUpdateAbility(Session, ability, ranks, baseValue, result);
}
else
{
abilityUpdate = new GameMessagePrivateUpdateVital(Session, ability, ranks, baseValue, result, character.Abilities[ability].Current);
}
// checks if max rank is achieved and plays fireworks w/ special text
if (IsAbilityMaxRank(ranks, isSecondary))
{
// fireworks
PlayParticleEffect(Effect.WeddingBliss);
messageText = $"Your base {ability} is now {newValue} and has reached its upper limit!";
}
else
{
messageText = $"Your base {ability} is now {newValue}!";
}
var xpUpdate = new GameMessagePrivateUpdatePropertyInt64(Session, PropertyInt64.AvailableExperience, character.AvailableExperience);
var soundEvent = new GameMessageSound(this.Guid, Network.Enum.Sound.RaiseTrait, 1f);
var message = new GameMessageSystemChat(messageText, ChatMessageType.Advancement);
Session.Network.EnqueueSend(abilityUpdate, xpUpdate, soundEvent, message);
}
else
{
ChatPacket.SendServerMessage(Session, $"Your attempt to raise {ability} has failed.", ChatMessageType.Broadcast);
}
}
public override void Handle()
{
var targetSession = WorldManager.FindByPlayerName(target);
if (targetSession == null)
{
var statusMessage = new GameEventDisplayStatusMessage(Session, StatusMessageType1.CharacterNotAvailable);
NetworkManager.SendWorldMessages(Session, new GameMessage[] { statusMessage });
}
else
{
if (Session.Player != targetSession.Player)
{
ChatPacket.SendServerMessage(Session, $"You tell {target}, \"'{message}'\"", ChatMessageType.OutgoingTell);
}
var tell = new GameEventTell(targetSession, message, Session.Player.Name, Session.Player.Guid.Full, targetSession.Player.Guid.Full, ChatMessageType.PrivateTell);
NetworkManager.SendWorldMessages(targetSession, new GameMessage[] { tell });
}
}
protected virtual void PacketUpdate()
{
if (!stopPacketUpdate)
{
int i = 0;
for (int count = packets.Count; i < count; i++)
{
if (stopPacketUpdate)
{
break;
}
ChatPacket packet = packets[i];
if (HandleCoopEvent(packet))
{
AddDeleteQueue(packet);
}
}
EraseUsedPacket();
}
}
/// <summary>
/// Remove a single friend and update the database.
/// </summary>
/// <param name="friendId">The ObjectGuid of the friend that is being removed</param>
public void HandleActionRemoveFriend(ObjectGuid friendId)
{
var friendToRemove = Character.CharacterPropertiesFriendList.SingleOrDefault(f => f.FriendId == friendId.Full);
// Not in friend list
if (friendToRemove == null)
{
ChatPacket.SendServerMessage(Session, "That character is not in your friends list!", ChatMessageType.Broadcast);
return;
}
// remove friend in DB
if (Character.TryRemoveFriend(friendId, out var entity) && entity.Id != 0)
{
DatabaseManager.Shard.RemoveEntity(entity, null);
}
// send network message
Session.Network.EnqueueSend(new GameEventFriendsListUpdate(Session, GameEventFriendsListUpdate.FriendsUpdateTypeFlag.FriendRemoved, friendToRemove));
}
public static async void Handle(ClientMessage message, Session session)
{
var friendName = message.Payload.ReadString16L().Trim();
var result = await session.Player.AddFriend(friendName);
switch (result)
{
case Enum.AddFriendResult.AlreadyInList:
ChatPacket.SendServerMessage(session, "That character is already in your friends list", ChatMessageType.Broadcast);
break;
case Enum.AddFriendResult.FriendWithSelf:
ChatPacket.SendServerMessage(session, "Sorry, but you can't be friends with yourself.", ChatMessageType.Broadcast);
break;
case Enum.AddFriendResult.CharacterDoesNotExist:
ChatPacket.SendServerMessage(session, "That character does not exist", ChatMessageType.Broadcast);
break;
}
}
public static void TestCorpse(Session session, params string[] parameters)
{
if (session.Player.SelectedTarget != 0)
{
var target = new ObjectGuid(session.Player.SelectedTarget);
var wo = LandblockManager.GetWorldObject(session, target);
if (target.IsCreature())
{
if (wo != null)
{
(wo as Creature).OnKill(session);
}
}
}
else
{
ChatPacket.SendServerMessage(session, "No creature selected.", ChatMessageType.Broadcast);
}
}
/// <summary>
/// Adds a friend and updates the database.
/// </summary>
/// <param name="friendName">The name of the friend that is being added.</param>
public void HandleActionAddFriend(string friendName)
{
if (string.Equals(friendName, Name, StringComparison.CurrentCultureIgnoreCase))
{
ChatPacket.SendServerMessage(Session, "Sorry, but you can't be friends with yourself.", ChatMessageType.Broadcast);
}
// Check if friend exists
if (Friends.SingleOrDefault(f => string.Equals(f.Name, friendName, StringComparison.CurrentCultureIgnoreCase)) != null)
{
ChatPacket.SendServerMessage(Session, "That character is already in your friends list", ChatMessageType.Broadcast);
}
// TODO: check if player is online first to avoid database hit??
// Get character record from DB
throw new System.NotImplementedException();
/* TODO fix for new EF model
* DatabaseManager.Shard.GetObjectInfoByName(friendName, ((ObjectInfo friendInfo) =>
* {
* if (friendInfo == null)
* {
* ChatPacket.SendServerMessage(Session, "That character does not exist", ChatMessageType.Broadcast);
* return;
* }
*
* Friend newFriend = new Friend();
* newFriend.Name = friendInfo.Name;
* newFriend.Id = new ObjectGuid(friendInfo.Guid);
*
* // Save to DB, assume success
* DatabaseManager.Shard.AddFriend(Guid.Low, newFriend.Id.Low, (() =>
* {
* // Add to character object
* Character.AddFriend(newFriend);
*
* // Send packet
* Session.Network.EnqueueSend(new GameEventFriendsListUpdate(Session, GameEventFriendsListUpdate.FriendsUpdateTypeFlag.FriendAdded, newFriend));
* }));
* }));*/
}
public static void HandleTeleportLOC(Session session, params string[] parameters)
{
try
{
uint cell;
if (parameters[0].StartsWith("0x"))
{
string strippedcell = parameters[0].Substring(2);
cell = (uint)int.Parse(strippedcell, System.Globalization.NumberStyles.HexNumber);
}
else
{
cell = (uint)int.Parse(parameters[0], System.Globalization.NumberStyles.HexNumber);
}
var positionData = new float[7];
for (uint i = 0u; i < 7u; i++)
{
float position;
if (!float.TryParse(parameters[i + 1].Trim(new Char[] { ' ', '[', ']' }), out position))
{
return;
}
positionData[i] = position;
}
session.Player.Teleport(new Position(cell, positionData[0], positionData[1], positionData[2], positionData[4], positionData[5], positionData[6], positionData[3]));
}
catch (Exception)
{
ChatPacket.SendServerMessage(session, "Invalid arguments for @teleloc", ChatMessageType.Broadcast);
ChatPacket.SendServerMessage(session, "Hint: @teleloc follows the same number order as displayed from @loc output", ChatMessageType.Broadcast);
ChatPacket.SendServerMessage(session, "Usage: @teleloc cell [x y z] (qw qx qy qz)", ChatMessageType.Broadcast);
ChatPacket.SendServerMessage(session, "Example: @teleloc 0x7F0401AD [12.319900 -28.482000 0.005000] -0.338946 0.000000 0.000000 -0.940806", ChatMessageType.Broadcast);
ChatPacket.SendServerMessage(session, "Example: @teleloc 0x7F0401AD 12.319900 -28.482000 0.005000 -0.338946 0.000000 0.000000 -0.940806", ChatMessageType.Broadcast);
ChatPacket.SendServerMessage(session, "Example: @teleloc 7F0401AD 12.319900 -28.482000 0.005000", ChatMessageType.Broadcast);
}
}
/// <summary>
/// Handle the !Unf request
/// </summary>
/// <param name="chatEvent"></param>
private void HandleUnfCommand(ChatEvent chatEvent)
{
// Create the chat response message
ChatPacket response = new ChatPacket();
// Set the player Identifier top reply to
response.Event.PlayerId = chatEvent.PlayerId;
response.Event.ChatType = ChatTypes.Private;
response.Event.SoundCode = SoundCodes.Ohhhhh;
if (chatEvent.PlayerName == "PsyOps")
{
response.Event.Message = "Unf always and forever!";
}
else
{
response.Event.Message = "Im sorry silly lil person, I belong to PsyOps!";
}
m_session.TransmitPacket(response);
}
public void SpendXp(Skill skill, uint amount)
{
uint baseValue = 0;
uint result = SpendSkillXp(character.Skills[skill], amount);
if (result > 0u)
{
uint ranks = character.Skills[skill].Ranks;
uint newValue = character.Skills[skill].UnbuffedValue;
var status = character.Skills[skill].Status;
var xpUpdate = new GameMessagePrivateUpdatePropertyInt64(Session, PropertyInt64.AvailableExperience, character.AvailableExperience);
var ablityUpdate = new GameMessagePrivateUpdateSkill(Session, skill, status, ranks, baseValue, result);
var soundEvent = new GameMessageSound(this.Guid, Network.Enum.Sound.AbilityIncrease, 1f);
var message = new GameMessageSystemChat($"Your base {skill} is now {newValue}!", ChatMessageType.Broadcast);
NetworkManager.SendWorldMessages(Session, new GameMessage[] { xpUpdate, ablityUpdate, soundEvent, message });
}
else
{
ChatPacket.SendServerMessage(Session, $"Your attempt to raise {skill} has failed.", ChatMessageType.Broadcast);
}
}
public static void Handle(ClientMessage message, Session session)
{
var target = message.Payload.ReadString16L();
var position = new Position(message.Payload);
// this check is also done clientside, see: PlayerDesc::PlayerIsPSR
if (!session.Player.IsAdmin && !session.Player.IsArch && !session.Player.IsPsr)
{
return;
}
uint cell = position.LandblockId.Raw;
uint cellX = (cell >> 3);
// TODO: Wrap command in a check to confirm session.character IsAdvocate or higher access level
// TODO: Maybe output to chat window coords teleported to.
// ChatPacket.SendSystemMessage(session, $"Teleporting to: 0.0[N/S], 0.0[E/W]");
ChatPacket.SendServerMessage(session, "Teleporting...", ChatMessageType.Broadcast);
session.Player.Teleport(position);
}
/// <summary>
/// Remove a single friend and update the database.
/// </summary>
/// <param name="friendId">The ObjectGuid of the friend that is being removed</param>
public void HandleActionRemoveFriend(ObjectGuid friendId)
{
Friend friendToRemove = Friends.SingleOrDefault(f => f.Id.Low == friendId.Low);
// Not in friend list
if (friendToRemove == null)
{
ChatPacket.SendServerMessage(Session, "That character is not in your friends list!", ChatMessageType.Broadcast);
return;
}
// Remove from DB
DatabaseManager.Shard.DeleteFriend(Guid.Low, friendId.Low, (() =>
{
// Remove from character object
HandleActionRemoveFriend(friendId);
// Send packet
Session.Network.EnqueueSend(new GameEventFriendsListUpdate(Session, GameEventFriendsListUpdate.FriendsUpdateTypeFlag.FriendRemoved, friendToRemove));
}));
}
private void HandleVoteKick(GameSession session, PacketReader packet)
{
long charId = packet.ReadLong();
Party party = GameServer.PartyManager.GetPartyById(session.Player.PartyId);
if (party == null)
{
return;
}
Player kickedPlayer = GameServer.Storage.GetPlayerById(charId);
if (kickedPlayer == null)
{
return;
}
party.BroadcastPacketParty(ChatPacket.Send(session.Player, session.Player.Name + " voted to kick " + kickedPlayer.Name, ChatType.NoticeAlert3));
//TODO: Keep a counter of vote kicks for a player?
}
public static void HandleDebugEcho(Session session, params string[] parameters)
{
try
{
if (Enum.TryParse(parameters[1], true, out ChatMessageType cmt))
{
if (Enum.IsDefined(typeof(ChatMessageType), cmt))
{
ChatPacket.SendServerMessage(session, parameters[0], cmt);
}
else
{
ChatPacket.SendServerMessage(session, parameters[0], ChatMessageType.Broadcast);
}
}
}
catch (Exception)
{
ChatPacket.SendServerMessage(session, parameters[0], ChatMessageType.Broadcast);
}
}
/// <summary>
/// Handle the !help request
/// </summary>
/// <param name="chatEvent"></param>
private void HandleBotHelpCommand(ChatEvent chatEvent)
{
// Create the chat response message
ChatPacket response = new ChatPacket();
// Set the player Identifier top reply to
response.Event.PlayerId = chatEvent.PlayerId;
response.Event.ChatType = ChatTypes.Private;
// Show the header block
response.Event.Message = "< ===================== >";
m_session.TransmitPacket(response);
response.Event.Message = "< BattleCore Help >";
m_session.TransmitPacket(response);
response.Event.Message = "< ===================== >";
m_session.TransmitPacket(response);
if (chatEvent.ModLevel >= ModLevels.SMod)
{
response.Event.Message = "< !blist | Lists loaded and available behaviors";
m_session.TransmitPacket(response);
response.Event.Message = "< !load | Load a behavior ";
m_session.TransmitPacket(response);
response.Event.Message = "< !unload | Unload a behavior";
m_session.TransmitPacket(response);
response.Event.Message = "< !listbots | list available bots";
m_session.TransmitPacket(response);
response.Event.Message = "< !spawn Bot:Arena | Spawn a new bot in arena";
m_session.TransmitPacket(response);
response.Event.Message = "< !kill | kills the bot (must be PM)";
m_session.TransmitPacket(response);
}
// Show All Available Help Commands
response.Event.Message = "< !info | Display core information";
m_session.TransmitPacket(response);
response.Event.Message = "< ===================== >";
m_session.TransmitPacket(response);
}
private static void HandleJoin(GameSession session, PacketReader packet)
{
Party party = GameServer.PartyManager.GetPartyById(session.Player.PartyId);
if (party == null)
{
return;
}
long clubId = packet.ReadLong();
Club club = GameServer.ClubManager.GetClubById(clubId);
if (club == null)
{
return;
}
if (club.Leader.CharacterId == session.Player.CharacterId)
{
party.BroadcastPacketParty(ClubPacket.UpdatePlayerClubList(session.Player, club));
}
else
{
int response = packet.ReadInt(); // 0 = accept, 76 (0x4C) = reject
if (response == 0)
{
party.BroadcastPacketParty(ClubPacket.ConfirmCreate(club.Id));
club.Leader.Session.Send(ClubPacket.Join(session.Player, club));
club.Leader.Session.Send(ClubPacket.Establish(club));
// TODO add member to club (club.AddMember(session.Player);)
}
else
{
// TODO update to proper rejection packet
party.Leader.Session.Send(ChatPacket.Send(party.Leader, session.Player.Name + " declined the invitation.", ChatType.NoticeAlert2));
}
}
}
private void button3_Click(object sender, EventArgs e)
{
ChatPacket toSend = new ChatPacket(0003, "Bobby", ChatLine.Text, this.GameID.ToString());
clientGui.Send(toSend);
ChatLine.Clear();
}
private void Logout()
{
try
{
if (_clientSocket != null)
{
// Initialize a packet object to store the data to be sent.
var sendData = new ChatPacket()
{
ChatDataIdentifier = DataIdentifier.LogOut,
ChatName = _chatName,
ChatMessage = null
};
// Get packet as byte array.
var data = sendData.Serialize();
// Send packet to the server.
_clientSocket.SendTo(data, 0, data.Length, SocketFlags.None, _serverEndPoint);
}
}
catch (Exception ex)
{
Logger.WriteLine("Logout error!");
Logger.WriteLine(ex.Message);
}
finally
{
// Close the socket.
_clientSocket.Close();
_clientSocket = null;
}
}
private void toClient_Click(object sender, EventArgs e)
{
ChatPacket sendPacket = new ChatPacket(0000, "Server", "Welcome to Scrabble!", "0");
chatToClients(sendPacket);
}
