Esempio n. 1
0
        /// <summary>
        /// Sends a packet through the socket.
        /// </summary>
        /// <param name="packID">The packet ID.</param>
        /// <param name="data">The data.</param>
        public void SendPacket(long packID, byte[] data)
        {
            if (RelevantSocket == null)
            {
                return;
            }
            DataStream outp = new DataStream();
            DataWriter dw   = new DataWriter(outp);

            dw.WriteInt(data.Length);
            dw.WriteVarInt(packID);
            dw.WriteBytes(data);
            SentWaiting += data.Length;
            try
            {
                RelevantSocket.BeginSend(data, 0, data.Length, SocketFlags.None, SendComplete, data.Length);
            }
            catch (Exception ex)
            {
                CommonUtilities.CheckException(ex);
                RelevantSocket.Close();
                RelevantSocket = null;
                SysConsole.Output(OutputType.INFO, "[Connections:Error] " + ex.ToString());
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Gets a language document for the specified parameters.
        /// </summary>
        /// <param name="id">The document ID.</param>
        /// <param name="Files">The file system.</param>
        /// <param name="lang">The language to enforce for this read, if any.</param>
        /// <param name="confs">The custom configuration set to use, if any.</param>
        /// <returns></returns>
        public FDSSection GetLangDoc(string id, FileEngine Files, string lang = null, Dictionary <string, FDSSection> confs = null)
        {
            if (lang == null)
            {
                lang = CurrentLanguage;
            }
            if (confs == null)
            {
                confs = LanguageDocuments;
            }
            string idlow = id.ToLowerFast();

            if (LanguageDocuments.TryGetValue(idlow, out FDSSection doc))
            {
                return(doc);
            }
            string path = "info/text/" + idlow + "_" + lang + ".fds";

            if (Files.TryReadFileText(path, out string dat))
            {
                try
                {
                    doc = new FDSSection(dat);
                    LanguageDocuments[idlow] = doc;
                    return(doc);
                }
                catch (Exception ex)
                {
                    CommonUtilities.CheckException(ex);
                    SysConsole.Output("Reading language documents", ex);
                }
            }
            LanguageDocuments[idlow] = null;
            return(null);
        }
        /// <summary>
        /// Speaks aloud some text.
        /// </summary>
        /// <param name="text">The text.</param>
        /// <param name="male">Whether to be male (if not, female).</param>
        /// <param name="rate">The rate at which to speak.</param>
        public static void Speak(string text, bool male, int rate)
        {
            Task.Factory.StartNew(() =>
            {
                try
                {
#if WINDOWS
                    if (TrySpeech)
                    {
                        SpeechSynthesizer speech = new SpeechSynthesizer();
                        VoiceInfo vi             = null;
                        foreach (InstalledVoice v in speech.GetInstalledVoices())
                        {
                            if (!v.Enabled)
                            {
                                continue;
                            }
                            if (vi == null)
                            {
                                vi = v.VoiceInfo;
                            }
                            else if ((male && v.VoiceInfo.Gender == VoiceGender.Male) || (!male && v.VoiceInfo.Gender == VoiceGender.Female))
                            {
                                vi = v.VoiceInfo;
                                break;
                            }
                        }
                        if (vi == null)
                        {
                            TrySpeech = false;
                        }
                        else
                        {
                            speech.SelectVoice(vi.Name);
                            speech.Rate = rate;
                            speech.Speak(text);
                        }
                    }
#endif
                }
                catch (Exception ex)
                {
                    CommonUtilities.CheckException(ex);
                    TrySpeech = false;
                }
                if (!TrySpeech)
                {
                    // TODO: Rate!
                    String addme = male ? " -p 40" : " -p 95";
                    Process p    = Process.Start("espeak", "\"" + text.Replace("\"", " quote ") + "\"" + addme);
                    Console.WriteLine(p.MainModule.FileName);
                }
            });
        }
Esempio n. 4
0
 /// <summary>
 /// Gets a string output for this stack note.
 /// </summary>
 /// <returns>The string output.</returns>
 public override string ToString()
 {
     try
     {
         return(Note + " (" + (Related ?? "None") + ")");
     }
     catch (Exception ex)
     {
         CommonUtilities.CheckException(ex);
         return(Note + "(Exception parsing Related: " + ex.ToString() + ")");
     }
 }
Esempio n. 5
0
 /// <summary>
 /// Run every frame to tick any network updates.
 /// </summary>
 public void Tick()
 {
     try
     {
         int avail = RelevantSocket.Available;
         if (!IsReady)
         {
             while (avail > 0)
             {
                 int rd = RelevantSocket.Receive(OneByteHolder, 1, SocketFlags.None);
                 if (rd <= 0)
                 {
                     break;
                 }
                 if (OneByteHolder[0] == 0)
                 {
                     string str = StringConversionHelper.UTF8Encoding.GetString(ReadData.ToArray());
                     if (!str.StartsWith(HEADER))
                     {
                         throw new Exception("Connection refused: Not a game engine proper connection.");
                     }
                     str = str.Substring(HEADER.Length);
                     int      nextLine = str.IndexOf('\n');
                     string   FGEData  = str.Substring(0, nextLine);
                     string[] keys     = FGEData.Split(':');
                     int      chan     = int.Parse(keys[0]);
                     if (!Network.Channels.Contains(chan))
                     {
                         throw new Exception("Connection refused: Invalid (non-registered) channel.");
                     }
                     Channel            = chan;
                     str                = str.Substring(nextLine + 1);
                     OpeningInformation = str;
                     if (Network.WantsReady?.Invoke(this) ?? true)
                     {
                         // TODO: Send counter header, all default packets, etc.
                         IsReady = true;
                     }
                     else
                     {
                         throw new Exception("Connection refused: Rejected by game systems.");
                     }
                     ReadData.SetLength(0);
                     return;
                 }
                 ReadData.WriteByte(OneByteHolder[0]);
                 if (ReadData.Length > Network.HeaderLimit)
                 {
                     throw new Exception("Connection refused: Too much header data.");
                 }
                 avail = RelevantSocket.Available;
             }
             return;
         }
         // If we reached here, IsReady = true.
         while (avail > 0)
         {
             int rd = RelevantSocket.Receive(KiloByteHolder, Math.Min(avail, KiloByteHolder.Length), SocketFlags.None);
             if (rd <= 0)
             {
                 return;
             }
             ReadData.Write(KiloByteHolder, 0, rd);
             if (ReadData.Length > Network.MaxPacketWaiting)
             {
                 throw new Exception("Connection quick-closed: massive packet!");
             }
             if (ReadData.Length > 5)
             {
                 rd = ReadData.Read(KiloByteHolder, 0, 4);
                 int d = BitConverter.ToInt32(KiloByteHolder, 0);
                 if (ReadData.Length >= d)
                 {
                     byte[] packet = new byte[d];
                     rd = 0;
                     while (rd < d)
                     {
                         int trd = ReadData.Read(packet, rd, d);
                         if (trd <= 0)
                         {
                             throw new Exception("Connection quick-closed: streaming error.");
                         }
                         rd += trd;
                     }
                     DataStream packStr = new DataStream(packet);
                     DataReader reader  = new DataReader(packStr);
                     long       pid     = reader.ReadVarInt();
                     ProcessPacket(pid, reader);
                     if (ReadData.Length == 0)
                     {
                         ReadData.Ind = 0;
                     }
                 }
                 else
                 {
                     ReadData.Ind -= rd;
                 }
             }
             avail = RelevantSocket.Available;
         }
     }
     catch (Exception ex)
     {
         CommonUtilities.CheckException(ex);
         RelevantSocket.Close();
         RelevantSocket = null;
         SysConsole.Output(OutputType.INFO, "[Connections:Error] " + ex.Message);
     }
 }