msg.AvailableCommands = commands.ToArray();
- _netMgr.ServerSendMessage(msg, session.ConnectedClient);
+ _netMgr.ServerSendMessage(msg, session.Channel);
}
private void PlayerStatusChanged(object? sender, SessionStatusEventArgs e)
private static bool IsLocal(ICommonSession player)
{
- var ep = player.ConnectedClient.RemoteEndPoint;
+ var ep = player.Channel.RemoteEndPoint;
var addr = ep.Address;
if (addr.IsIPv4MappedToIPv6)
{
if (e.NewStatus != SessionStatus.Connected || _cachedRoleBans.ContainsKey(e.Session.UserId))
return;
- var netChannel = e.Session.ConnectedClient;
+ var netChannel = e.Session.Channel;
ImmutableArray<byte>? hwId = netChannel.UserData.HWId.Length == 0 ? null : netChannel.UserData.HWId;
await CacheDbRoleBans(e.Session.UserId, netChannel.RemoteEndPoint.Address, hwId);
return;
// If they are, kick them
var message = banDef.FormatBanMessage(_cfg, _localizationManager);
- targetPlayer.ConnectedClient.Disconnect(message);
+ targetPlayer.Channel.Disconnect(message);
}
#endregion
};
_sawmill.Debug($"Sent rolebans to {pSession.Name}");
- _netManager.ServerSendMessage(bans, pSession.ConnectedClient);
+ _netManager.ServerSendMessage(bans, pSession.Channel);
}
public void PostInject()
-using System.Collections.Immutable;
+using System.Collections.Immutable;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
if (_playerManager.TryGetSessionByUsername(playerName, out var session))
{
var userId = session.UserId;
- var address = session.ConnectedClient.RemoteEndPoint.Address;
- var hwId = session.ConnectedClient.UserData.HWId;
+ var address = session.Channel.RemoteEndPoint.Address;
+ var hwId = session.Channel.UserData.HWId;
return new LocatedPlayerData(userId, address, hwId, session.Name);
}
// Check people currently on the server, the easiest case.
if (_playerManager.TryGetSessionById(userId, out var session))
{
- var address = session.ConnectedClient.RemoteEndPoint.Address;
- var hwId = session.ConnectedClient.UserData.HWId;
+ var address = session.Channel.RemoteEndPoint.Address;
+ var hwId = session.Channel.UserData.HWId;
return new LocatedPlayerData(userId, address, hwId, session.Name);
}
-using Content.Shared.Administration;
+using Content.Shared.Administration;
using JetBrains.Annotations;
using Robust.Shared.Player;
okAction.Invoke(v1);
else
{
- session.ConnectedClient.Disconnect("Replied with invalid quick dialog data.");
+ session.Channel.Disconnect("Replied with invalid quick dialog data.");
cancelAction?.Invoke();
}
}),
okAction.Invoke(v1, v2);
else
{
- session.ConnectedClient.Disconnect("Replied with invalid quick dialog data.");
+ session.Channel.Disconnect("Replied with invalid quick dialog data.");
cancelAction?.Invoke();
}
}),
okAction.Invoke(v1, v2, v3);
else
{
- session.ConnectedClient.Disconnect("Replied with invalid quick dialog data.");
+ session.Channel.Disconnect("Replied with invalid quick dialog data.");
cancelAction?.Invoke();
}
}),
okAction.Invoke(v1, v2, v3, v4);
else
{
- session.ConnectedClient.Disconnect("Replied with invalid quick dialog data.");
+ session.Channel.Disconnect("Replied with invalid quick dialog data.");
cancelAction?.Invoke();
}
}),
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
using Content.Shared.Administration;
using Robust.Server.Player;
using Robust.Shared.Enums;
{
if (!_openDialogs.ContainsKey(msg.DialogId) || !_openDialogsByUser[args.SenderSession.UserId].Contains(msg.DialogId))
{
- args.SenderSession.ConnectedClient.Disconnect($"Replied with invalid quick dialog data with id {msg.DialogId}.");
+ args.SenderSession.Channel.Disconnect($"Replied with invalid quick dialog data with id {msg.DialogId}.");
return;
}
foreach (var admin in _adminManager.ActiveAdmins)
{
- RaiseNetworkEvent(updateEv, admin.ConnectedClient);
+ RaiseNetworkEvent(updateEv, admin.Channel);
}
}
foreach (var admin in _adminManager.ActiveAdmins)
{
- RaiseNetworkEvent(playerInfoChangedEvent, admin.ConnectedClient);
+ RaiseNetworkEvent(playerInfoChangedEvent, admin.Channel);
}
}
if (!obj.IsAdmin)
{
- RaiseNetworkEvent(new FullPlayerListEvent(), obj.Player.ConnectedClient);
+ RaiseNetworkEvent(new FullPlayerListEvent(), obj.Player.Channel);
return;
}
ev.PlayersInfo = _playerList.Values.ToList();
- RaiseNetworkEvent(ev, playerSession.ConnectedClient);
+ RaiseNetworkEvent(ev, playerSession.Channel);
}
private PlayerInfo GetPlayerInfo(SessionData data, ICommonSession? session)
Icon = new SpriteSpecifier.Texture(new ("/Textures/Interface/gavel.svg.192dpi.png")),
Act = () =>
{
- _ghostKickManager.DoDisconnect(actorComponent.PlayerSession.ConnectedClient, "Smitten.");
+ _ghostKickManager.DoDisconnect(actorComponent.PlayerSession.Channel, "Smitten.");
},
Impact = LogImpact.Extreme,
Message = Loc.GetString("admin-smite-ghostkick-description")
// Notify player
if (_playerManager.TryGetSessionById(message.UserId, out var session))
{
- if (!admins.Contains(session.ConnectedClient))
+ if (!admins.Contains(session.Channel))
{
// If _overrideClientName is set, we generate a new message with the override name. The admins name will still be the original name for the webhooks.
if (_overrideClientName != string.Empty)
overrideMsgText = $"{senderSession.Name}: {escapedText}"; // Not an admin, name is not overridden.
}
- RaiseNetworkEvent(new BwoinkTextMessage(message.UserId, senderSession.UserId, overrideMsgText), session.ConnectedClient);
+ RaiseNetworkEvent(new BwoinkTextMessage(message.UserId, senderSession.UserId, overrideMsgText), session.Channel);
}
else
- RaiseNetworkEvent(msg, session.ConnectedClient);
+ RaiseNetworkEvent(msg, session.Channel);
}
}
// No admin online, let the player know
var systemText = Loc.GetString("bwoink-system-starmute-message-no-other-users");
var starMuteMsg = new BwoinkTextMessage(message.UserId, SystemUserId, systemText);
- RaiseNetworkEvent(starMuteMsg, senderSession.ConnectedClient);
+ RaiseNetworkEvent(starMuteMsg, senderSession.Channel);
}
// Returns all online admins with AHelp access
{
return _adminManager.ActiveAdmins
.Where(p => _adminManager.GetAdminData(p)?.HasFlag(AdminFlags.Adminhelp) ?? false)
- .Select(p => p.ConnectedClient)
+ .Select(p => p.Channel)
.ToList();
}
{
var message = Loc.GetString(antagGreeting);
var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", message));
- _chatManager.ChatMessageToOne(Shared.Chat.ChatChannel.Server, message, wrappedMessage, default, false, mind.Session.ConnectedClient, Color.FromHex(greetingColor));
+ _chatManager.ChatMessageToOne(Shared.Chat.ChatChannel.Server, message, wrappedMessage, default, false, mind.Session.Channel, Color.FromHex(greetingColor));
}
}
}
public void DispatchServerMessage(ICommonSession player, string message, bool suppressLog = false)
{
var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", FormattedMessage.EscapeText(message)));
- ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, player.ConnectedClient);
+ ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, player.Channel);
if (!suppressLog)
_adminLogger.Add(LogType.Chat, LogImpact.Low, $"Server message to {player:Player}: {message}");
public void SendAdminAnnouncement(string message)
{
- var clients = _adminManager.ActiveAdmins.Select(p => p.ConnectedClient);
+ var clients = _adminManager.ActiveAdmins.Select(p => p.Channel);
var wrappedMessage = Loc.GetString("chat-manager-send-admin-announcement-wrap-message",
("adminChannelName", Loc.GetString("chat-manager-admin-channel-name")), ("message", FormattedMessage.EscapeText(message)));
public void SendAdminAlert(string message)
{
- var clients = _adminManager.ActiveAdmins.Select(p => p.ConnectedClient);
+ var clients = _adminManager.ActiveAdmins.Select(p => p.Channel);
var wrappedMessage = Loc.GetString("chat-manager-send-admin-announcement-wrap-message",
("adminChannelName", Loc.GetString("chat-manager-admin-channel-name")), ("message", FormattedMessage.EscapeText(message)));
var prefs = _preferencesManager.GetPreferences(player.UserId);
colorOverride = prefs.AdminOOCColor;
}
- if (player.ConnectedClient.UserData.PatronTier is { } patron &&
+ if (player.Channel.UserData.PatronTier is { } patron &&
PatronOocColors.TryGetValue(patron, out var patronColor))
{
wrappedMessage = Loc.GetString("chat-manager-send-ooc-patron-wrap-message", ("patronColor", patronColor),("playerName", player.Name), ("message", FormattedMessage.EscapeText(message)));
return;
}
- var clients = _adminManager.ActiveAdmins.Select(p => p.ConnectedClient);
+ var clients = _adminManager.ActiveAdmins.Select(p => p.Channel);
var wrappedMessage = Loc.GetString("chat-manager-send-admin-chat-wrap-message",
("adminChannelName", Loc.GetString("chat-manager-admin-channel-name")),
("playerName", player.Name), ("message", FormattedMessage.EscapeText(message)));
foreach (var client in clients)
{
- var isSource = client != player.ConnectedClient;
+ var isSource = client != player.Channel;
ChatMessageToOne(ChatChannel.AdminChat,
message,
wrappedMessage,
var clients = new List<INetChannel>();
foreach (var recipient in filter.Recipients)
{
- clients.Add(recipient.ConnectedClient);
+ clients.Add(recipient.Channel);
}
ChatMessageToMany(channel, message, wrappedMessage, source, hideChat, recordReplay, clients, colorOverride, audioPath, audioVolume);
continue; // Won't get logged to chat, and ghosts are too far away to see the pop-up, so we just won't send it to them.
if (data.Range <= WhisperClearRange)
- _chatManager.ChatMessageToOne(ChatChannel.Whisper, message, wrappedMessage, source, false, session.ConnectedClient);
+ _chatManager.ChatMessageToOne(ChatChannel.Whisper, message, wrappedMessage, source, false, session.Channel);
//If listener is too far, they only hear fragments of the message
//Collisiongroup.Opaque is not ideal for this use. Preferably, there should be a check specifically with "Can Ent1 see Ent2" in mind
else if (_interactionSystem.InRangeUnobstructed(source, listener, WhisperMuffledRange, Shared.Physics.CollisionGroup.Opaque)) //Shared.Physics.CollisionGroup.Opaque
- _chatManager.ChatMessageToOne(ChatChannel.Whisper, obfuscatedMessage, wrappedobfuscatedMessage, source, false, session.ConnectedClient);
+ _chatManager.ChatMessageToOne(ChatChannel.Whisper, obfuscatedMessage, wrappedobfuscatedMessage, source, false, session.Channel);
//If listener is too far and has no line of sight, they can't identify the whisperer's identity
else
- _chatManager.ChatMessageToOne(ChatChannel.Whisper, obfuscatedMessage, wrappedUnknownMessage, source, false, session.ConnectedClient);
+ _chatManager.ChatMessageToOne(ChatChannel.Whisper, obfuscatedMessage, wrappedUnknownMessage, source, false, session.Channel);
}
_replay.RecordServerMessage(new ChatMessage(ChatChannel.Whisper, message, wrappedMessage, GetNetEntity(source), null, MessageRangeHideChatForReplay(range)));
{
wrappedMessage = Loc.GetString("chat-manager-send-admin-dead-chat-wrap-message",
("adminChannelName", Loc.GetString("chat-manager-admin-channel-name")),
- ("userName", player.ConnectedClient.UserName),
+ ("userName", player.Channel.UserName),
("message", FormattedMessage.EscapeText(message)));
_adminLogger.Add(LogType.Chat, LogImpact.Low, $"Admin dead chat from {player:Player}: {message}");
}
if (entRange == MessageRangeCheckResult.Disallowed)
continue;
var entHideChat = entRange == MessageRangeCheckResult.HideChat;
- _chatManager.ChatMessageToOne(channel, message, wrappedMessage, source, entHideChat, session.ConnectedClient, author: author);
+ _chatManager.ChatMessageToOne(channel, message, wrappedMessage, source, entHideChat, session.Channel, author: author);
}
_replay.RecordServerMessage(new ChatMessage(channel, message, wrappedMessage, GetNetEntity(source), null, MessageRangeHideChatForReplay(range)));
.AddWhereAttachedEntity(HasComp<GhostComponent>)
.Recipients
.Union(_adminManager.ActiveAdmins)
- .Select(p => p.ConnectedClient);
+ .Select(p => p.Channel);
}
private string SanitizeMessagePeriod(string message)
return;
if(GetGuide(prototype) is {} guide)
- RaiseNetworkEvent(new ResponseConstructionGuide(msg.ConstructionId, guide), args.SenderSession.ConnectedClient);
+ RaiseNetworkEvent(new ResponseConstructionGuide(msg.ConstructionId, guide), args.SenderSession.Channel);
}
private void AddDeconstructVerb(EntityUid uid, ConstructionComponent component, GetVerbsEvent<Verb> args)
-using Content.Shared.Eui;
+using Content.Shared.Eui;
using Robust.Shared.Network;
using Robust.Shared.Player;
msg.Id = Id;
msg.Message = message;
- netMgr.ServerSendMessage(msg, Player.ConnectedClient);
+ netMgr.ServerSendMessage(msg, Player.Channel);
}
/// <summary>
msg.Id = Id;
msg.State = state;
- netMgr.ServerSendMessage(msg, Player.ConnectedClient);
+ netMgr.ServerSendMessage(msg, Player.Channel);
}
internal void Initialize(EuiManager manager, ICommonSession player, uint id)
-using Content.Shared.Eui;
+using Content.Shared.Eui;
using Robust.Server.Player;
using Robust.Shared.Enums;
using Robust.Shared.Network;
msg.Type = MsgEuiCtl.CtlType.Open;
msg.OpenType = eui.GetType().Name;
- _net.ServerSendMessage(msg, player.ConnectedClient);
+ _net.ServerSendMessage(msg, player.Channel);
}
public void CloseEui(BaseEui eui)
var msg = new MsgEuiCtl();
msg.Id = eui.Id;
msg.Type = MsgEuiCtl.CtlType.Close;
- _net.ServerSendMessage(msg, eui.Player.ConnectedClient);
+ _net.ServerSendMessage(msg, eui.Player.Channel);
}
private void RxMsgMessage(MsgEuiMessage message)
GetNetEntity(target), 0, message, verbs?.ToList(), centerAtCursor
);
- RaiseNetworkEvent(ev, session.ConnectedClient);
+ RaiseNetworkEvent(ev, session.Channel);
}
private void ExamineInfoRequest(ExamineSystemMessages.RequestExamineInfoMessage request, EntitySessionEventArgs eventArgs)
{
var player = eventArgs.SenderSession;
var session = eventArgs.SenderSession;
- var channel = player.ConnectedClient;
+ var channel = player.Channel;
var entity = GetEntity(request.NetEntity);
if (session.AttachedEntity is not {Valid: true} playerEnt
}
var message = new PuddleOverlayDisableMessage();
- RaiseNetworkEvent(message, observer.ConnectedClient);
+ RaiseNetworkEvent(message, observer.Channel);
}
public override void Update(float frameTime)
{
foreach (var player in _playerManager.Sessions)
{
- RaiseNetworkEvent(GetStatusMsg(player), player.ConnectedClient);
+ RaiseNetworkEvent(GetStatusMsg(player), player.Channel);
}
}
_playerGameStatuses[playerUserId] = status;
if (!_playerManager.TryGetSessionById(playerUserId, out var playerSession))
continue;
- RaiseNetworkEvent(GetStatusMsg(playerSession), playerSession.ConnectedClient);
+ RaiseNetworkEvent(GetStatusMsg(playerSession), playerSession.Channel);
}
}
var status = ready ? PlayerGameStatus.ReadyToPlay : PlayerGameStatus.NotReadyToPlay;
_playerGameStatuses[player.UserId] = ready ? PlayerGameStatus.ReadyToPlay : PlayerGameStatus.NotReadyToPlay;
- RaiseNetworkEvent(GetStatusMsg(player), player.ConnectedClient);
+ RaiseNetworkEvent(GetStatusMsg(player), player.Channel);
// update server info to reflect new ready count
UpdateInfoText();
}
_playerGameStatuses[session.UserId] = PlayerGameStatus.JoinedGame;
_db.AddRoundPlayers(RoundId, session.UserId);
- RaiseNetworkEvent(new TickerJoinGameEvent(), session.ConnectedClient);
+ RaiseNetworkEvent(new TickerJoinGameEvent(), session.Channel);
}
private void PlayerJoinLobby(ICommonSession session)
_playerGameStatuses[session.UserId] = LobbyEnabled ? PlayerGameStatus.NotReadyToPlay : PlayerGameStatus.ReadyToPlay;
_db.AddRoundPlayers(RoundId, session.UserId);
- var client = session.ConnectedClient;
+ var client = session.Channel;
RaiseNetworkEvent(new TickerJoinLobbyEvent(), client);
RaiseNetworkEvent(GetStatusMsg(session), client);
RaiseNetworkEvent(GetInfoMsg(), client);
-using Content.Server.Chat.Managers;
+using Content.Server.Chat.Managers;
using Content.Server.GameTicking.Rules.Components;
using Content.Server.Station.Systems;
using Content.Shared.Chat;
var msg = Loc.GetString("rule-respawn-in-seconds", ("second", component.RespawnDelay.TotalSeconds));
var wrappedMsg = Loc.GetString("chat-manager-server-wrap-message", ("message", msg));
- _chatManager.ChatMessageToOne(ChatChannel.Server, msg, wrappedMsg, respawnTracker, false, actor.PlayerSession.ConnectedClient, Color.LimeGreen);
+ _chatManager.ChatMessageToOne(ChatChannel.Server, msg, wrappedMsg, respawnTracker, false, actor.PlayerSession.Channel, Color.LimeGreen);
component.RespawnQueue[actor.PlayerSession.UserId] = _timing.CurTime + component.RespawnDelay;
return true;
}
{
var message = Loc.GetString("rev-role-greeting");
var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", message));
- _chatManager.ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, mind.Session.ConnectedClient, Color.Red);
+ _chatManager.ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, mind.Session.Channel, Color.Red);
_audioSystem.PlayGlobal("/Audio/Ambience/Antag/headrev_start.ogg", ev.Target);
}
}
{
var message = Loc.GetString("head-rev-role-greeting");
var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", message));
- _chatManager.ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, mind.Session.ConnectedClient, Color.FromHex("#5e9cff"));
+ _chatManager.ChatMessageToOne(ChatChannel.Server, message, wrappedMessage, default, false, mind.Session.Channel, Color.FromHex("#5e9cff"));
}
}
}
// I went all the way to ChatManager.cs and all i got was this lousy T-shirt
// You got a free T-shirt!?!?
_chatManager.ChatMessageToOne(Shared.Chat.ChatChannel.Server, message,
- wrappedMessage, default, false, zombie.ConnectedClient, Color.Plum);
+ wrappedMessage, default, false, zombie.Channel, Color.Plum);
_audio.PlayGlobal(component.InitialInfectedSound, ownedEntity);
}
}
}
var response = new GhostWarpsResponseEvent(GetPlayerWarps(entity).Concat(GetLocationWarps()).ToList());
- RaiseNetworkEvent(response, args.SenderSession.ConnectedClient);
+ RaiseNetworkEvent(response, args.SenderSession.Channel);
}
private void OnGhostWarpToTargetRequest(GhostWarpToTargetRequestEvent msg, EntitySessionEventArgs args)
var response = new GhostUpdateGhostRoleCountEvent(GetGhostRolesInfo().Length);
foreach (var player in _playerManager.Sessions)
{
- RaiseNetworkEvent(response, player.ConnectedClient);
+ RaiseNetworkEvent(response, player.Channel);
}
}
}
if (args.NewStatus == SessionStatus.InGame)
{
var response = new GhostUpdateGhostRoleCountEvent(_ghostRoles.Count);
- RaiseNetworkEvent(response, args.Session.ConnectedClient);
+ RaiseNetworkEvent(response, args.Session.Channel);
}
}
-using Content.Server.Administration;
+using Content.Server.Administration;
using Content.Shared.Administration;
using Content.Shared.GhostKick;
using Robust.Server.Player;
return;
}
- ghostKick.DoDisconnect(player.ConnectedClient, reason);
+ ghostKick.DoDisconnect(player.Channel, reason);
}
}
-using Content.Server.Explosion.EntitySystems;
+using Content.Server.Explosion.EntitySystems;
using Robust.Shared.Player;
namespace Content.Server.GhostKick;
return;
_ghostKickManager.DoDisconnect(
- actor.PlayerSession.ConnectedClient,
+ actor.PlayerSession.Channel,
"Tripped over a kick mine, crashed through the fourth wall");
args.Handled = true;
-using Content.Shared.CCVar;
+using Content.Shared.CCVar;
using Content.Shared.Info;
using Robust.Shared.Configuration;
using Robust.Shared.ContentPack;
Logger.ErrorS("info", "Could not read server rules file.");
}
var response = new RulesMessage(title, rules);
- RaiseNetworkEvent(response, eventArgs.SenderSession.ConnectedClient);
+ RaiseNetworkEvent(response, eventArgs.SenderSession.Channel);
}
}
-using Content.Server.Administration;
+using Content.Server.Administration;
using Content.Shared.Administration;
using Content.Shared.CCVar;
using Content.Shared.Info;
message.PopupTime = seconds;
var player = IoCManager.Resolve<IPlayerManager>().GetSessionByUserId(located.UserId);
- netManager.ServerSendMessage(message, player.ConnectedClient);
+ netManager.ServerSendMessage(message, player.Channel);
}
}
RaiseNetworkEvent(new GridDragToggleMessage()
{
Enabled = _draggers.Contains(session),
- }, session.ConnectedClient);
+ }, session.Channel);
}
private void OnRequestVelocity(GridDragVelocityRequest ev, EntitySessionEventArgs args)
return;
var wrappedMessage = Loc.GetString("motd-wrap-message", ("motd", _messageOfTheDay));
- _chatManager.ChatMessageToOne(ChatChannel.Server, _messageOfTheDay, wrappedMessage, source: EntityUid.Invalid, hideChat: false, client: player.ConnectedClient);
+ _chatManager.ChatMessageToOne(ChatChannel.Server, _messageOfTheDay, wrappedMessage, source: EntityUid.Invalid, hideChat: false, client: player.Channel);
}
/// <summary>
var wrappedMessage = Loc.GetString("motd-wrap-message", ("motd", _messageOfTheDay));
shell.WriteLine(wrappedMessage);
if (shell.Player is { } player)
- _chatManager.ChatMessageToOne(ChatChannel.Server, _messageOfTheDay, wrappedMessage, source: EntityUid.Invalid, hideChat: false, client: player.ConnectedClient);
+ _chatManager.ChatMessageToOne(ChatChannel.Server, _messageOfTheDay, wrappedMessage, source: EntityUid.Invalid, hideChat: false, client: player.Channel);
}
#region Event Handlers
if (string.IsNullOrEmpty(motd))
{
shell.WriteLine(Loc.GetString("cmd-set-motd-cleared-motd-message"));
- _adminLogManager.Add(LogType.Chat, LogImpact.Low, $"{(player == null ? "LOCALHOST" : player.ConnectedClient.UserName):Player} cleared the MOTD for the server.");
+ _adminLogManager.Add(LogType.Chat, LogImpact.Low, $"{(player == null ? "LOCALHOST" : player.Channel.UserName):Player} cleared the MOTD for the server.");
}
else
{
shell.WriteLine(Loc.GetString("cmd-set-motd-set-motd-message", ("motd", motd)));
- _adminLogManager.Add(LogType.Chat, LogImpact.Low, $"{(player == null ? "LOCALHOST" : player.ConnectedClient.UserName):Player} set the MOTD for the server to \"{motd:motd}\"");
+ _adminLogManager.Add(LogType.Chat, LogImpact.Low, $"{(player == null ? "LOCALHOST" : player.Channel.UserName):Player} set the MOTD for the server to \"{motd:motd}\"");
}
}
{
Uid = GetNetEntity(uid),
Text = text.ToString(),
- }, session.ConnectedClient);
+ }, session.Channel);
}
}
// Keeping old plan
if ((session.Value & PathfindingDebugMode.Routes) == 0x0)
continue;
- RaiseNetworkEvent(new PathRouteMessage(request.Polys.Select(GetDebugPoly).ToList(), new Dictionary<DebugPathPoly, float>()), session.Key.ConnectedClient);
+ RaiseNetworkEvent(new PathRouteMessage(request.Polys.Select(GetDebugPoly).ToList(), new Dictionary<DebugPathPoly, float>()), session.Key.Channel);
}
}
}
}
- RaiseNetworkEvent(msg, pSession.ConnectedClient);
+ RaiseNetworkEvent(msg, pSession.Channel);
}
private void SendRoute(PathRequest request)
if (!IsRoute(session.Value))
continue;
- RaiseNetworkEvent(msg, session.Key.ConnectedClient);
+ RaiseNetworkEvent(msg, session.Key.Channel);
}
}
}
}
- RaiseNetworkEvent(msg, pSession.ConnectedClient);
+ RaiseNetworkEvent(msg, pSession.Channel);
}
private void SendBreadcrumbs(GridPathfindingChunk chunk, EntityUid gridUid)
if (!IsCrumb(session.Value))
continue;
- RaiseNetworkEvent(msg, session.Key.ConnectedClient);
+ RaiseNetworkEvent(msg, session.Key.Channel);
}
}
if (!IsPoly(session.Value))
continue;
- RaiseNetworkEvent(msg, session.Key.ConnectedClient);
+ RaiseNetworkEvent(msg, session.Key.Channel);
}
}
foreach (var player in _visPlayers)
{
- RaiseNetworkEvent(msg, player.ConnectedClient);
+ RaiseNetworkEvent(msg, player.Channel);
}
}
msg.Groups.Add(VisMakeGroupState(network));
}
- RaiseNetworkEvent(msg, player.ConnectedClient);
+ RaiseNetworkEvent(msg, player.Channel);
}
private NodeVis.GroupData VisMakeGroupState(BaseNodeGroup group)
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;
Trackers = roles
};
- _net.ServerSendMessage(msg, pSession.ConnectedClient);
+ _net.ServerSendMessage(msg, pSession.Channel);
}
/// <summary>
-using Content.Server.Administration;
+using Content.Server.Administration;
using Content.Server.Administration.Logs;
using Content.Server.Bible.Components;
using Content.Server.Chat.Managers;
var message = popupMessage == "" ? "" : popupMessage + (messageString == "" ? "" : $" \"{messageString}\"");
_popupSystem.PopupEntity(popupMessage, target.AttachedEntity.Value, target, PopupType.Large);
- _chatManager.ChatMessageToOne(ChatChannel.Local, messageString, message, EntityUid.Invalid, false, target.ConnectedClient);
+ _chatManager.ChatMessageToOne(ChatChannel.Local, messageString, message, EntityUid.Invalid, false, target.Channel);
_adminLogger.Add(LogType.AdminMessage, LogImpact.Low, $"{ToPrettyString(target.AttachedEntity.Value):player} received subtle message from {source.Name}: {message}");
}
// Should only be called via UserDbDataManager.
public async Task LoadData(ICommonSession session, CancellationToken cancel)
{
- if (!ShouldStorePrefs(session.ConnectedClient.AuthType))
+ if (!ShouldStorePrefs(session.Channel.AuthType))
{
// Don't store data for guests.
var prefsData = new PlayerPrefData
{
MaxCharacterSlots = MaxCharacterSlots
};
- _netManager.ServerSendMessage(msg, session.ConnectedClient);
+ _netManager.ServerSendMessage(msg, session.Channel);
}
}
}
}
var ev = new OnRadiationOverlayToggledEvent(isEnabled);
- RaiseNetworkEvent(ev, session.ConnectedClient);
+ RaiseNetworkEvent(ev, session.Channel);
}
/// <summary>
{
if (session.Status != SessionStatus.InGame)
_debugSessions.Remove(session);
- RaiseNetworkEvent(ev, session.ConnectedClient);
+ RaiseNetworkEvent(ev, session.Channel);
}
}
private void OnHeadsetReceive(EntityUid uid, HeadsetComponent component, ref RadioReceiveEvent args)
{
if (TryComp(Transform(uid).ParentUid, out ActorComponent? actor))
- _netMan.ServerSendMessage(args.ChatMsg, actor.PlayerSession.ConnectedClient);
+ _netMan.ServerSendMessage(args.ChatMsg, actor.PlayerSession.Channel);
}
private void OnEmpPulse(EntityUid uid, HeadsetComponent component, ref EmpPulseEvent args)
private void OnIntrinsicReceive(EntityUid uid, IntrinsicRadioReceiverComponent component, ref RadioReceiveEvent args)
{
if (TryComp(uid, out ActorComponent? actor))
- _netMan.ServerSendMessage(args.ChatMsg, actor.PlayerSession.ConnectedClient);
+ _netMan.ServerSendMessage(args.ChatMsg, actor.PlayerSession.Channel);
}
/// <summary>
if (e.NewStatus != SessionStatus.Connected || e.OldStatus != SessionStatus.Connecting)
return;
- RaiseNetworkEvent(new MsgSandboxStatus { SandboxAllowed = IsSandboxEnabled }, e.Session.ConnectedClient);
+ RaiseNetworkEvent(new MsgSandboxStatus { SandboxAllowed = IsSandboxEnabled }, e.Session.Channel);
}
private void SandboxRespawnReceived(MsgSandboxRespawn message, EntitySessionEventArgs args)
if (!IsSandboxEnabled)
return;
- var player = _playerManager.GetSessionByChannel(args.SenderSession.ConnectedClient);
+ var player = _playerManager.GetSessionByChannel(args.SenderSession.Channel);
if (player.AttachedEntity == null) return;
_ticker.Respawn(player);
if (!IsSandboxEnabled)
return;
- var player = _playerManager.GetSessionByChannel(args.SenderSession.ConnectedClient);
+ var player = _playerManager.GetSessionByChannel(args.SenderSession.Channel);
if (player.AttachedEntity is not { } attached)
{
return;
if (!IsSandboxEnabled)
return;
- var player = _playerManager.GetSessionByChannel(args.SenderSession.ConnectedClient);
+ var player = _playerManager.GetSessionByChannel(args.SenderSession.Channel);
_host.ExecuteCommand(player, _conGroupController.CanCommand(player, "aghost") ? "aghost" : "ghost");
}
if (!IsSandboxEnabled)
return;
- var player = _playerManager.GetSessionByChannel(args.SenderSession.ConnectedClient);
+ var player = _playerManager.GetSessionByChannel(args.SenderSession.Channel);
_host.ExecuteCommand(player, "suicide");
}
var msg = Loc.GetString("laws-notify");
var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", msg));
_chatManager.ChatMessageToOne(ChatChannel.Server, msg, wrappedMessage, default, false,
- actor.PlayerSession.ConnectedClient, colorOverride: Color.FromHex("#2ed2fd"));
+ actor.PlayerSession.Channel, colorOverride: Color.FromHex("#2ed2fd"));
}
private void OnToggleLawsScreen(EntityUid uid, SiliconLawBoundComponent component, ToggleLawsScreenEvent args)
var msg = Loc.GetString("laws-update-notify");
var wrappedMessage = Loc.GetString("chat-manager-server-wrap-message", ("message", msg));
- _chatManager.ChatMessageToOne(ChatChannel.Server, msg, wrappedMessage, default, false, actor.PlayerSession.ConnectedClient, colorOverride: Color.Red);
+ _chatManager.ChatMessageToOne(ChatChannel.Server, msg, wrappedMessage, default, false, actor.PlayerSession.Channel, colorOverride: Color.Red);
}
/// <summary>
-using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Content.Server.GameTicking;
using Content.Server.Station.Components;
private void OnPlayerJoinedLobby(PlayerJoinedLobbyEvent ev)
{
- RaiseNetworkEvent(_cachedAvailableJobs, ev.PlayerSession.ConnectedClient);
+ RaiseNetworkEvent(_cachedAvailableJobs, ev.PlayerSession.Channel);
}
private void OnStationRenamed(EntityUid uid, StationJobsComponent component, StationRenamedEvent args)
session.Players[player] = new TabletopSessionPlayerData { Camera = camera };
// Tell the gamer to open a viewport for the tabletop game
- RaiseNetworkEvent(new TabletopPlayEvent(GetNetEntity(uid), GetNetEntity(camera), Loc.GetString(tabletop.BoardName), tabletop.Size), player.ConnectedClient);
+ RaiseNetworkEvent(new TabletopPlayEvent(GetNetEntity(uid), GetNetEntity(camera), Loc.GetString(tabletop.BoardName), tabletop.Size), player.Channel);
}
/// <summary>
var response =
new VerbsResponseEvent(args.EntityUid, GetLocalVerbs(GetEntity(args.EntityUid), attached, verbTypes, force));
- RaiseNetworkEvent(response, player.ConnectedClient);
+ RaiseNetworkEvent(response, player.Channel);
}
/// <summary>
msg.Options[i] = ((ushort) entry.Votes, entry.Text);
}
- player.ConnectedClient.SendMessage(msg);
+ player.Channel.SendMessage(msg);
}
private void DirtyCanCallVoteAll()
msg.VotesUnavailable = votesUnavailable.ToArray();
}
- _netManager.ServerSendMessage(msg, player.ConnectedClient);
+ _netManager.ServerSendMessage(msg, player.Channel);
}
private bool CanCallVote(
-using Content.Server.Administration;
+using Content.Server.Administration;
using Content.Server.Database;
using Content.Shared.Administration;
using Content.Shared.CCVar;
if (!await db.GetWhitelistStatusAsync(session.UserId))
{
- net.DisconnectChannel(session.ConnectedClient, Loc.GetString("whitelist-not-whitelisted"));
+ net.DisconnectChannel(session.Channel, Loc.GetString("whitelist-not-whitelisted"));
}
}
}
projects / space-station-14.git / commitdiff