Esempio n. 1
0
        public static string Run(string[] args, Loudness loud = Loudness.NORMAL, string solutionDir = null)
        {
            if (solutionDir == null)
            {
                solutionDir = SolutionUtilities.GetSolutionDir();
            }

            string stdout, stderr;
            int    ret = CaideExe.Execute(args, solutionDir, out stdout, out stderr);

            if (ret != 0)
            {
                if (loud >= Loudness.NORMAL)
                {
                    Logger.LogError("caide.exe error. Return code {0}\n{1}\n{2}", ret, stdout, stderr);
                }
                if (loud >= Loudness.LOUD)
                {
                    MessageBox.Show(string.Format("caide.exe error. Return code {0}\n{1}\n{2}", ret, stdout, stderr));
                }
                return(null);
            }

            return(stdout);
        }
        private void AnnounceNewCrewmember(GameObject player)
        {
            PlayerScript playerScript          = player.GetComponent <PlayerScript>();
            Occupation   playerOccupation      = playerScript.mind.occupation;
            string       playerName            = player.ExpensiveName();
            Loudness     annoucementImportance = GetAnnouncementImportance(playerOccupation);

            ChatChannel chatChannels  = ChatChannel.Common;
            string      commonMessage = $"{playerName} has signed up as {playerOccupation.DisplayName}.";
            string      deptMessage   = $"{playerName}, {playerOccupation.DisplayName}, is the department head.";

            // Get the channel of the newly joined head from their occupation.
            if (channelFromJob.ContainsKey(playerOccupation.JobType))
            {
                BroadcastCommMsg(channelFromJob[playerOccupation.JobType], deptMessage, annoucementImportance);
            }

            // Announce the arrival on the CentComm channel if is a CentComm occupation.
            if (JobCategories.CentCommJobs.Contains(playerOccupation.JobType))
            {
                chatChannels = ChatChannel.CentComm;
            }
            else if (playerOccupation.IsCrewmember == false)
            {
                // Don't announce non-crewmembers like wizards, fugitives at all (they don't have their own chat channel).
                return;
            }

            BroadcastCommMsg(chatChannels, commonMessage, GetAnnouncementImportance(playerOccupation));
        }
Esempio n. 3
0
    public void UpdateClientChat(string message, ChatChannel channels, bool isOriginator, GameObject recipient,
                                 Loudness loudness, ChatModifier modifiers)
    {
        if (string.IsNullOrEmpty(message))
        {
            return;
        }

        trySendingTTS(message);

        if (PlayerManager.LocalPlayerScript == null)
        {
            channels = ChatChannel.OOC;
        }

        if (channels != ChatChannel.None)
        {
            // replace action messages with chat bubble
            if (channels.HasFlag(ChatChannel.Combat) || channels.HasFlag(ChatChannel.Action) ||
                channels.HasFlag(ChatChannel.Examine) || modifiers.HasFlag(ChatModifier.Emote))
            {
                if (isOriginator)
                {
                    ChatBubbleManager.Instance.ShowAction(Regex.Replace(message, "<.*?>", string.Empty), recipient);
                }
            }

            ChatUI.Instance.AddChatEntry(message);
        }
    }
Esempio n. 4
0
        /// <summary>
        /// Do not use this message directly. If you need to do work with the chat system use
        /// the Chat API (the only exception to this rule is if you just need to send 1 msg to 1 client from the server
        /// i.e syndi special roles)
        /// </summary>
        public static NetMessage Send(GameObject recipient, ChatChannel channels, ChatModifier chatMods, string chatMessage,
                                      Loudness loudness     = Loudness.NORMAL, string othersMsg = "",
                                      GameObject originator = null, string speaker              = "", bool stripTags = true)
        {
            uint origin = NetId.Empty;

            if (originator != null)
            {
                origin = originator.GetComponent <NetworkIdentity>().netId;
            }

            NetMessage msg =
                new NetMessage {
                Recipient     = recipient.GetComponent <NetworkIdentity>().netId,
                Channels      = channels,
                ChatModifiers = chatMods,
                Message       = chatMessage,
                OthersMessage = othersMsg,
                Originator    = origin,
                Speaker       = speaker,
                StripTags     = stripTags,
                Loudness      = loudness
            };

            SendTo(recipient, msg, Category.Chat, 2);
            return(msg);
        }
Esempio n. 5
0
    void Start()
    {
        source = GetComponent <AudioSource>();
        loud   = GetComponentInChildren <Loudness>();

        source.loop  = true;
        source.clip  = paacjs[Random.Range(0, paacjs.Length)];
        source.pitch = 1 + Random.Range(-0.35f, 0.35f);
        source.Play();

        GameController.PaacjUp();
    }
        //This is only used to send the chat input on the client to the server
        public static NetMessage Send(string message, ChatChannel channels, Loudness loudness = Loudness.NORMAL)
        {
            NetMessage msg = new NetMessage
            {
                Channels        = channels,
                ChatMessageText = message,
                Loudness        = loudness
            };

            Send(msg);
            return(msg);
        }
Esempio n. 7
0
        public override LocalEmbed ToEmbed()
        {
            var embed = base.ToEmbed();

            embed.AddField("Type", Type.Transform(To.TitleCase), true);
            embed.AddField("Loudness", Loudness.ToString("+0.00;-#.00"), true);

            if (Velocity != 0)
            {
                embed.AddField("Velocity", Velocity.ToString("+0.00;-#.00"), true);
            }
            if (DurabilityBurn != 0)
            {
                embed.AddField("Durability Burn", $"{DurabilityBurn:+0.00;-#.00}%", true);
            }

            return(embed);
        }
Esempio n. 8
0
    /// <summary>
    /// Broadcast a comm. message to chat, by machine. Useful for e.g. AutomatedAnnouncer.
    /// </summary>
    /// <param name="sentByMachine">Machine broadcasting the message</param>
    /// <param name="message">The message to broadcast.</param>
    /// <param name="channels">The channels to broadcast on.</param>
    /// <param name="chatModifiers">Chat modifiers to use e.g. ChatModifier.ColdlyState.</param>
    /// <param name="broadcasterName">Optional name for the broadcaster. Pulls name from GameObject if not used.</param>
    /// <param name="voiceLevel">How loud is this message?</param>
    public static void AddCommMsgByMachineToChat(
        GameObject sentByMachine, string message, ChatChannel channels, Loudness voiceLevel,
        ChatModifier chatModifiers = ChatModifier.None, string broadcasterName = default)
    {
        if (string.IsNullOrWhiteSpace(message))
        {
            return;
        }

        var chatEvent = new ChatEvent
        {
            message    = message,
            modifiers  = chatModifiers,
            speaker    = broadcasterName != default ? broadcasterName : sentByMachine.ExpensiveName(),
            position   = sentByMachine.WorldPosServer(),
            channels   = channels,
            originator = sentByMachine,
            VoiceLevel = voiceLevel
        };

        InvokeChatEvent(chatEvent);
    }
Esempio n. 9
0
        public static string Run(string[] args, Loudness loud = Loudness.NORMAL, string solutionDir = null)
        {
            if (solutionDir == null)
            {
                solutionDir = SolutionUtilities.GetSolutionDir();
            }

            string stdout, stderr;
            int ret = CaideExe.Execute(args, solutionDir, out stdout, out stderr);
            if (ret != 0)
            {
                if (loud >= Loudness.NORMAL)
                {
                    Logger.LogError("caide.exe error. Return code {0}\n{1}\n{2}", ret, stdout, stderr);
                }
                if (loud >= Loudness.LOUD)
                {
                    MessageBox.Show(string.Format("caide.exe error. Return code {0}\n{1}\n{2}", ret, stdout, stderr));
                }
                return null;
            }

            return stdout;
        }
Esempio n. 10
0
 public Dog(Loudness loudness)
 {
     Loudness = loudness;
 }
Esempio n. 11
0
    public void PropagateChatToClients(ChatEvent chatEvent)
    {
        List <ConnectedPlayer> players = PlayerList.Instance.AllPlayers;
        Loudness loud = chatEvent.VoiceLevel;

        //Local chat range checks:
        if (chatEvent.channels.HasFlag(ChatChannel.Local) ||
            chatEvent.channels.HasFlag(ChatChannel.Combat) ||
            chatEvent.channels.HasFlag(ChatChannel.Action))
        {
            for (int i = players.Count - 1; i >= 0; i--)
            {
                if (players[i].Script == null)
                {
                    //joined viewer, don't message them
                    players.RemoveAt(i);
                    continue;
                }

                if (players[i].Script.gameObject == chatEvent.originator)
                {
                    //Always send the originator chat to themselves
                    continue;
                }

                if (players[i].Script.IsGhost && players[i].Script.IsPlayerSemiGhost == false)
                {
                    //send all to ghosts
                    continue;
                }

                if (chatEvent.position == TransformState.HiddenPos)
                {
                    //show messages with no provided position to everyone
                    continue;
                }

                //Send chat to PlayerChatLocation pos, usually just the player object but for AI is its vessel
                var playerPosition = players[i].Script.PlayerChatLocation.OrNull()?.AssumedWorldPosServer()
                                     ?? players[i].Script.gameObject.AssumedWorldPosServer();

                //Do player position to originator distance check
                if (DistanceCheck(playerPosition) == false)
                {
                    //Distance check failed so if we are Ai, then try send action and combat messages to their camera location
                    //as well as if possible
                    if (chatEvent.channels.HasFlag(ChatChannel.Local) == false &&
                        players[i].Script.PlayerState == PlayerScript.PlayerStates.Ai &&
                        players[i].Script.TryGetComponent <AiPlayer>(out var aiPlayer) &&
                        aiPlayer.IsCarded == false)
                    {
                        playerPosition = players[i].Script.gameObject.AssumedWorldPosServer();

                        //Check camera pos
                        if (DistanceCheck(playerPosition))
                        {
                            //Camera can see player, allow Ai to see action/combat messages
                            continue;
                        }
                    }

                    //Player failed distance checks remove them
                    players.RemoveAt(i);
                }

                bool DistanceCheck(Vector3 playerPos)
                {
                    //TODO maybe change this to (chatEvent.position - playerPos).sqrMagnitude > 196f to avoid square root for performance?
                    if (Vector2.Distance(chatEvent.position, playerPos) > 14f)
                    {
                        //Player in the list is too far away for local chat, remove them:
                        return(false);
                    }

                    //Within range, but check if they are in another room or hiding behind a wall
                    if (MatrixManager.Linecast(chatEvent.position, LayerTypeSelection.Walls,
                                               layerMask, playerPos).ItHit)
                    {
                        //If it hit a wall remove that player
                        return(false);
                    }

                    //Player can see the position
                    return(true);
                }
            }



            if (chatEvent.originator != null)
            {
                //Get NPCs in vicinity
                var npcs = Physics2D.OverlapCircleAll(chatEvent.position, 14f, npcMask);
                foreach (Collider2D coll in npcs)
                {
                    var npcPosition = coll.gameObject.AssumedWorldPosServer();
                    if (MatrixManager.Linecast(chatEvent.position, LayerTypeSelection.Walls,
                                               layerMask, npcPosition).ItHit == false)
                    {
                        //NPC is in hearing range, pass the message on: Physics2D.OverlapCircleAll(chatEvent.originator.AssumedWorldPosServer(), 8f, itemsMask);
                        var mobAi = coll.GetComponent <MobAI>();
                        if (mobAi != null)
                        {
                            mobAi.LocalChatReceived(chatEvent);
                        }
                    }
                }

                if (radioCheckIsOnCooldown == false)
                {
                    CheckForRadios(chatEvent);
                }
            }
        }

        for (var i = 0; i < players.Count; i++)
        {
            ChatChannel channels = chatEvent.channels;

            if (channels.HasFlag(ChatChannel.Combat) || channels.HasFlag(ChatChannel.Local) ||
                channels.HasFlag(ChatChannel.System) || channels.HasFlag(ChatChannel.Examine) ||
                channels.HasFlag(ChatChannel.Action))
            {
                //Binary check here to avoid speaking in local when speaking on binary
                if (!channels.HasFlag(ChatChannel.Binary) ||
                    (players[i].Script.IsGhost && players[i].Script.IsPlayerSemiGhost == false))
                {
                    UpdateChatMessage.Send(players[i].GameObject, channels, chatEvent.modifiers, chatEvent.message,
                                           loud, chatEvent.messageOthers,
                                           chatEvent.originator, chatEvent.speaker, chatEvent.stripTags);

                    continue;
                }
            }

            if (players[i].Script == null)
            {
                channels &= ChatChannel.OOC;
            }
            else
            {
                channels &= players[i].Script.GetAvailableChannelsMask(false);
            }

            //if the mask ends up being a big fat 0 then don't do anything
            if (channels != ChatChannel.None)
            {
                UpdateChatMessage.Send(players[i].GameObject, channels, chatEvent.modifiers, chatEvent.message, loud,
                                       chatEvent.messageOthers,
                                       chatEvent.originator, chatEvent.speaker, chatEvent.stripTags);
            }
        }

        if (rconManager != null)
        {
            string message = $"{chatEvent.speaker} {chatEvent.message}";
            if ((namelessChannels & chatEvent.channels) != chatEvent.channels)
            {
                message = $"<b>[{chatEvent.channels}]</b> {message}";
            }

            RconManager.AddChatLog(message);
        }
    }
Esempio n. 12
0
File: Zone.cs Progetto: wasabii/rnet
 void ReceiveLoudness(byte value)
 {
     loudness = (Loudness)value;
     RaisePropertyChanged("Loudness");
 }
Esempio n. 13
0
    /// <summary>
    /// This should only be called via UpdateChatMessage
    /// on the client. Do not use for anything else!
    /// </summary>
    public static void ProcessUpdateChatMessage(uint recipientUint, uint originatorUint, string message,
                                                string messageOthers, ChatChannel channels, ChatModifier modifiers, string speaker, GameObject recipient, Loudness loudness, bool stripTags = true)
    {
        var isOriginator = true;

        if (recipientUint != originatorUint)
        {
            isOriginator = false;
            if (!string.IsNullOrEmpty(messageOthers))
            {
                //If there is a message in MessageOthers then determine
                //if it should be the main message or not.
                message = messageOthers;
            }
        }

        if (GhostValidationRejection(originatorUint, channels))
        {
            return;
        }

        var msg = ProcessMessageFurther(message, speaker, channels, modifiers, loudness, originatorUint, stripTags);

        ChatRelay.Instance.UpdateClientChat(msg, channels, isOriginator, recipient, loudness, modifiers);
    }
Esempio n. 14
0
    /// <summary>
    /// Processes message further for the chat log.
    /// Adds text styling, color and channel prefixes depending on the message and its modifiers.
    /// </summary>
    /// <returns>The chat message, formatted to suit the chat log.</returns>
    public static string ProcessMessageFurther(string message, string speaker, ChatChannel channels,
                                               ChatModifier modifiers, Loudness loudness, uint originatorUint = 0, bool stripTags = true)
    {
        playedSound = false;
        //Highlight in game name by bolding and underlining if possible
        //Dont play sound here as it could be examine or action, we only play sound for someone speaking
        message = HighlightInGameName(message, false);

        //Skip everything if system message
        if (channels.HasFlag(ChatChannel.System))
        {
            return(message);
        }

        //Skip everything in case of combat channel
        if (channels.HasFlag(ChatChannel.Combat))
        {
            return(AddMsgColor(channels, $"<i>{message}</i>"));            //POC
        }

        //Skip everything if it is an action or examine message or if it is a local message
        //without a speaker (which is used by machines)
        if (channels.HasFlag(ChatChannel.Examine) ||
            channels.HasFlag(ChatChannel.Action) ||
            channels.HasFlag(ChatChannel.Local) && string.IsNullOrEmpty(speaker))
        {
            return(AddMsgColor(channels, $"<i>{message}</i>"));
        }

        // Skip everything if the message is a local warning
        if (channels.HasFlag(ChatChannel.Warning))
        {
            return(AddMsgColor(channels, $"<i>{message}</i>"));
        }

        if (stripTags)
        {
            message = StripTags(message);

            //Bold names again after tag stripping
            message = HighlightInGameName(message);
        }

        //Check for emote. If found skip chat modifiers, make sure emote is only in Local channel
        if ((modifiers & ChatModifier.Emote) == ChatModifier.Emote)
        {
            // /me message
            channels = ChatChannel.Local;

            message = AddMsgColor(channels, $"<i><b>{speaker}</b> {message}</i>");
            return(message);
        }

        //Check for OOC. If selected, remove all other channels and modifiers (could happen if UI f***s up or someone tampers with it)
        if (channels.HasFlag(ChatChannel.OOC))
        {
            //ooc name quick fix
            var name = Regex.Replace(speaker, @"\t\n\r", "");
            if (string.IsNullOrWhiteSpace(name))
            {
                name = "nerd";
            }

            //highlight OOC name by bolding and underlining if possible
            message = HighlightName(message, ServerData.Auth.CurrentUser.DisplayName);

            message = AddMsgColor(channels, $"[ooc] <b>{name}: {message}</b>");
            return(message);
        }

        //Ghosts don't get modifiers
        if (channels.HasFlag(ChatChannel.Ghost))
        {
            string[] _ghostVerbs = { "cries", "moans" };
            return(AddMsgColor(channels, $"[dead] <b>{speaker}</b> {_ghostVerbs.PickRandom()}: {message}"));
        }
        string verb = "says,";

        if ((modifiers & ChatModifier.Mute) == ChatModifier.Mute)
        {
            return("");
        }

        if ((modifiers & ChatModifier.Whisper) == ChatModifier.Whisper)
        {
            verb    = "whispers,";
            message = $"<i>{message}</i>";
        }
        else if ((modifiers & ChatModifier.Sing) == ChatModifier.Sing)
        {
            verb     = "sings,";
            message += " ♫";
        }
        else if ((modifiers & ChatModifier.Yell) == ChatModifier.Yell)
        {
            verb    = "yells,";
            message = $"<b>{message}</b>";
        }
        else if ((modifiers & ChatModifier.Query) == ChatModifier.Query)
        {
            verb = "queries,";
        }
        else if ((modifiers & ChatModifier.State) == ChatModifier.State)
        {
            verb = "states,";
        }
        else if ((modifiers & ChatModifier.ColdlyState) == ChatModifier.ColdlyState)
        {
            verb = "coldly states,";
        }
        else if ((modifiers & ChatModifier.Exclaim) == ChatModifier.Exclaim)
        {
            verb = "exclaims,";
        }
        else if ((modifiers & ChatModifier.Question) == ChatModifier.Question)
        {
            verb = "asks,";
        }

        var chan = $"[{channels.ToString().ToLower().Substring(0, 3)}] ";

        if (channels.HasFlag(ChatChannel.Command))
        {
            chan = "[cmd] ";
        }

        if (channels.HasFlag(ChatChannel.Local))
        {
            chan = "";
        }

        var textSize = loudness switch
        {
            Loudness.QUIET => ChatTemplates.SmallText,
            Loudness.LOUD => ChatTemplates.LargeText,
            Loudness.SCREAMING => ChatTemplates.VeryLargeText,
            Loudness.EARRAPE => ChatTemplates.ExtremelyLargeText,
            _ => message.Contains("!!") ? ChatTemplates.LargeText : ChatTemplates.NormalText,
        };

        return(AddMsgColor(channels,
                           $"{chan}<b>{speaker}</b> {verb}"                              // [cmd]  Username says,
                           + "  "                                                        // Two hair spaces. This triggers Text-to-Speech.
                           + $"<size={textSize}>" + "\"" + message + "\"" + "</size>")); // "This text will be spoken by TTS!"
    }
Esempio n. 15
0
 public Cat(Loudness loudness)
 {
     Loudness = loudness;
 }
Esempio n. 16
0
 public Cat()
 {
     Loudness = Loudness.LOW;
 }
Esempio n. 17
0
    /// <summary>
    /// Send a Chat Msg from a player to the selected Chat Channels
    /// Server only
    /// </summary>
    public static void AddChatMsgToChat(ConnectedPlayer sentByPlayer, string message, ChatChannel channels, Loudness loudness = Loudness.NORMAL)
    {
        message = AutoMod.ProcessChatServer(sentByPlayer, message);
        if (string.IsNullOrWhiteSpace(message))
        {
            return;
        }

        //Sanity check for null username
        if (string.IsNullOrWhiteSpace(sentByPlayer.Username))
        {
            Logger.Log($"Null/empty Username, Details: Username: {sentByPlayer.Username}, ClientID: {sentByPlayer.ClientId}, IP: {sentByPlayer.Connection.address}",
                       Category.Admin);
            return;
        }

        var player = sentByPlayer.Script;

        //Check to see whether this player is allowed to send on the chosen channels
        if (player != null)
        {
            channels &= player.GetAvailableChannelsMask(true);
        }
        else
        {
            //If player is null, must be in lobby therefore lock to OOC
            channels = ChatChannel.OOC;
        }

        if (channels == ChatChannel.None)
        {
            return;
        }

        // The exact words that leave the player's mouth (or that are narrated). Already includes HONKs, stutters, etc.
        // This step is skipped when speaking in the OOC channel.
        (string message, ChatModifier chatModifiers)processedMessage = (string.Empty, ChatModifier.None);          // Placeholder values
        bool isOOC = channels.HasFlag(ChatChannel.OOC);

        if (!isOOC)
        {
            processedMessage = ProcessMessage(sentByPlayer, message);

            if (string.IsNullOrWhiteSpace(processedMessage.message))
            {
                return;
            }
        }

        var chatEvent = new ChatEvent
        {
            message    = isOOC ? message : processedMessage.message,
            modifiers  = (player == null) ? ChatModifier.None : processedMessage.chatModifiers,
            speaker    = (player == null) ? sentByPlayer.Username : player.playerName,
            position   = (player == null) ? TransformState.HiddenPos : player.PlayerChatLocation.AssumedWorldPosServer(),
            channels   = channels,
            originator = (player == null) ? sentByPlayer.GameObject : player.PlayerChatLocation,
            VoiceLevel = loudness
        };

        //This is to make sure OOC doesn't break
        if (sentByPlayer.Job != JobType.NULL)
        {
            CheckVoiceLevel(sentByPlayer.Script, chatEvent.channels);
        }


        if (channels.HasFlag(ChatChannel.OOC))
        {
            chatEvent.speaker = StripAll(sentByPlayer.Username);

            var isAdmin = PlayerList.Instance.IsAdmin(sentByPlayer.UserId);

            if (isAdmin)
            {
                chatEvent.speaker = "<color=red>[A]</color> " + chatEvent.speaker;
            }
            else if (PlayerList.Instance.IsMentor(sentByPlayer.UserId))
            {
                chatEvent.speaker = "<color=#6400ff>[M]</color> " + chatEvent.speaker;
            }

            if (Instance.OOCMute && !isAdmin)
            {
                return;
            }

            //http/https links in OOC chat
            if (isAdmin || !GameManager.Instance.AdminOnlyHtml)
            {
                if (htmlRegex.IsMatch(chatEvent.message))
                {
                    var messageParts = chatEvent.message.Split(' ');

                    var builder = new StringBuilder();

                    foreach (var part in messageParts)
                    {
                        if (!htmlRegex.IsMatch(part))
                        {
                            builder.Append(part);
                            builder.Append(" ");
                            continue;
                        }

                        builder.Append($"<link={part}><color=blue>{part}</color></link> ");
                    }

                    chatEvent.message = builder.ToString();

                    //TODO have a config file available to whitelist/blacklist links if all players are allowed to post links
                    //disables client side tag protection to allow <link=></link> tag
                    chatEvent.stripTags = false;
                }
            }

            ChatRelay.Instance.PropagateChatToClients(chatEvent);

            var strippedSpeaker = StripTags(chatEvent.speaker);

            //Sends OOC message to a discord webhook
            DiscordWebhookMessage.Instance.AddWebHookMessageToQueue(DiscordWebhookURLs.DiscordWebhookOOCURL, message, strippedSpeaker, ServerData.ServerConfig.DiscordWebhookOOCMentionsID);

            if (!ServerData.ServerConfig.DiscordWebhookSendOOCToAllChat)
            {
                return;
            }

            //Send it to All chat
            DiscordWebhookMessage.Instance.AddWebHookMessageToQueue(DiscordWebhookURLs.DiscordWebhookAllChatURL, $"[{ChatChannel.OOC}]  {message}\n", strippedSpeaker);

            return;
        }

        // TODO the following code uses player.playerHealth, but ConciousState would be more appropriate.
        // Check if the player is allowed to talk:
        if (player != null)
        {
            if (player.playerHealth != null)
            {
                if (!player.IsDeadOrGhost && player.mind.IsMiming && !processedMessage.chatModifiers.HasFlag(ChatModifier.Emote))
                {
                    AddWarningMsgFromServer(sentByPlayer.GameObject, "You can't talk because you made a vow of silence.");
                    return;
                }

                if (player.playerHealth.IsCrit)
                {
                    if (!player.playerHealth.IsDead)
                    {
                        return;
                    }
                    else
                    {
                        chatEvent.channels = ChatChannel.Ghost;
                    }
                }
                else if (!player.playerHealth.IsDead && !player.IsGhost)
                {
                    //Control the chat bubble
                    player.playerNetworkActions.ServerToggleChatIcon(true, processedMessage.message, channels, processedMessage.chatModifiers);
                }
            }
        }

        InvokeChatEvent(chatEvent);
    }
Esempio n. 18
0
 public Dog()
 {
     Loudness = Loudness.LOW;
 }
 private void BroadcastCommMsg(ChatChannel chatChannels, string message, Loudness importance)
 {
     Chat.AddCommMsgByMachineToChat(gameObject, message, chatChannels, importance, ChatModifier.ColdlyState, machineName);
 }
Esempio n. 20
0
 public Mouse(Loudness loudness)
 {
     Loudness = loudness;
 }
Esempio n. 21
0
 public Mouse()
 {
     Loudness = Loudness.LOW;
 }