_EagleOwle_

PhotonStream

Jun 1st, 2020
102
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  /// <summary>
  2.     /// This container is used in OnPhotonSerializeView() to either provide incoming data of a PhotonView or for you to provide it.
  3.     /// </summary>
  4.     /// <remarks>
  5.     /// The IsWriting property will be true if this client is the "owner" of the PhotonView (and thus the GameObject).
  6.     /// Add data to the stream and it's sent via the server to the other players in a room.
  7.     /// On the receiving side, IsWriting is false and the data should be read.
  8.     ///
  9.     /// Send as few data as possible to keep connection quality up. An empty PhotonStream will not be sent.
  10.     ///
  11.     /// Use either Serialize() for reading and writing or SendNext() and ReceiveNext(). The latter two are just explicit read and
  12.     /// write methods but do about the same work as Serialize(). It's a matter of preference which methods you use.
  13.     /// </remarks>
  14.     /// \ingroup publicApi
  15.     public class PhotonStream
  16.     {
  17.         private List<object> writeData;
  18.         private object[] readData;
  19.         private int currentItem; //Используется для отслеживания следующего элемента для получения.
  20.  
  21.         /// <summary>Если true, этот клиент должен добавить данные в поток, чтобы отправить его.</summary>
  22.         public bool IsWriting { get; private set; }
  23.  
  24.         /// <summary>Если true, этот клиент должен прочитать данные, отправленные другим клиентом</summary>
  25.         public bool IsReading
  26.         {
  27.             get { return !this.IsWriting; }
  28.         }
  29.  
  30.         /// <summary>Count of items in the stream.</summary>
  31.         public int Count
  32.         {
  33.             get { return this.IsWriting ? this.writeData.Count : this.readData.Length; }
  34.         }
  35.  
  36.         /// <summary>
  37.         /// Creates a stream and initializes it. Used by PUN internally.
  38.         /// </summary>
  39.         public PhotonStream(bool write, object[] incomingData)
  40.         {
  41.             this.IsWriting = write;
  42.  
  43.             if (!write && incomingData != null)
  44.             {
  45.                 this.readData = incomingData;
  46.             }
  47.         }
  48.  
  49.         public void SetReadStream(object[] incomingData, int pos = 0)
  50.         {
  51.             this.readData = incomingData;
  52.             this.currentItem = pos;
  53.             this.IsWriting = false;
  54.         }
  55.  
  56.         internal void SetWriteStream(List<object> newWriteData, int pos = 0)
  57.         {
  58.             if (pos != newWriteData.Count)
  59.             {
  60.                 throw new Exception("SetWriteStream failed, because count does not match position value. pos: "+ pos + " newWriteData.Count:" + newWriteData.Count);
  61.             }
  62.             this.writeData = newWriteData;
  63.             this.currentItem = pos;
  64.             this.IsWriting = true;
  65.         }
  66.  
  67.         internal List<object> GetWriteStream()
  68.         {
  69.             return this.writeData;
  70.         }
  71.  
  72.  
  73.         [Obsolete("Either SET the writeData with an empty List or use Clear().")]
  74.         internal void ResetWriteStream()
  75.         {
  76.             this.writeData.Clear();
  77.         }
  78.  
  79.         /// <summary>Read next piece of data from the stream when IsReading is true.</summary>
  80.         public object ReceiveNext()
  81.         {
  82.             if (this.IsWriting)
  83.             {
  84.                 Debug.LogError("Error: you cannot read this stream that you are writing!");
  85.                 return null;
  86.             }
  87.  
  88.             object obj = this.readData[this.currentItem];
  89.             this.currentItem++;
  90.             return obj;
  91.         }
  92.  
  93.         /// <summary>Read next piece of data from the stream without advancing the "current" item.</summary>
  94.         public object PeekNext()
  95.         {
  96.             if (this.IsWriting)
  97.             {
  98.                 Debug.LogError("Error: you cannot read this stream that you are writing!");
  99.                 return null;
  100.             }
  101.  
  102.             object obj = this.readData[this.currentItem];
  103.             //this.currentItem++;
  104.             return obj;
  105.         }
  106.  
  107.         /// <summary>Add another piece of data to send it when IsWriting is true.</summary>
  108.         public void SendNext(object obj)
  109.         {
  110.             if (!this.IsWriting)
  111.             {
  112.                 Debug.LogError("Error: you cannot write/send to this stream that you are reading!");
  113.                 return;
  114.             }
  115.  
  116.             this.writeData.Add(obj);
  117.         }
  118.  
  119.         [Obsolete("writeData is a list now. Use and re-use it directly.")]
  120.         public bool CopyToListAndClear(List<object> target)
  121.         {
  122.             if (!this.IsWriting) return false;
  123.  
  124.             target.AddRange(this.writeData);
  125.             this.writeData.Clear();
  126.  
  127.             return true;
  128.         }
  129.  
  130.         /// <summary>Turns the stream into a new object[].</summary>
  131.         public object[] ToArray()
  132.         {
  133.             return this.IsWriting ? this.writeData.ToArray() : this.readData;
  134.         }
  135.  
  136.         /// <summary>
  137.         /// Will read or write the value, depending on the stream's IsWriting value.
  138.         /// </summary>
  139.         public void Serialize(ref bool myBool)
  140.         {
  141.             if (this.IsWriting)
  142.             {
  143.                 this.writeData.Add(myBool);
  144.             }
  145.             else
  146.             {
  147.                 if (this.readData.Length > this.currentItem)
  148.                 {
  149.                     myBool = (bool) this.readData[this.currentItem];
  150.                     this.currentItem++;
  151.                 }
  152.             }
  153.         }
  154.  
  155.         /// <summary>
  156.         /// Will read or write the value, depending on the stream's IsWriting value.
  157.         /// </summary>
  158.         public void Serialize(ref int myInt)
  159.         {
  160.             if (this.IsWriting)
  161.             {
  162.                 this.writeData.Add(myInt);
  163.             }
  164.             else
  165.             {
  166.                 if (this.readData.Length > this.currentItem)
  167.                 {
  168.                     myInt = (int) this.readData[this.currentItem];
  169.                     this.currentItem++;
  170.                 }
  171.             }
  172.         }
  173.  
  174.         /// <summary>
  175.         /// Will read or write the value, depending on the stream's IsWriting value.
  176.         /// </summary>
  177.         public void Serialize(ref string value)
  178.         {
  179.             if (this.IsWriting)
  180.             {
  181.                 this.writeData.Add(value);
  182.             }
  183.             else
  184.             {
  185.                 if (this.readData.Length > this.currentItem)
  186.                 {
  187.                     value = (string) this.readData[this.currentItem];
  188.                     this.currentItem++;
  189.                 }
  190.             }
  191.         }
  192.  
  193.         /// <summary>
  194.         /// Will read or write the value, depending on the stream's IsWriting value.
  195.         /// </summary>
  196.         public void Serialize(ref char value)
  197.         {
  198.             if (this.IsWriting)
  199.             {
  200.                 this.writeData.Add(value);
  201.             }
  202.             else
  203.             {
  204.                 if (this.readData.Length > this.currentItem)
  205.                 {
  206.                     value = (char) this.readData[this.currentItem];
  207.                     this.currentItem++;
  208.                 }
  209.             }
  210.         }
  211.  
  212.         /// <summary>
  213.         /// Will read or write the value, depending on the stream's IsWriting value.
  214.         /// </summary>
  215.         public void Serialize(ref short value)
  216.         {
  217.             if (this.IsWriting)
  218.             {
  219.                 this.writeData.Add(value);
  220.             }
  221.             else
  222.             {
  223.                 if (this.readData.Length > this.currentItem)
  224.                 {
  225.                     value = (short) this.readData[this.currentItem];
  226.                     this.currentItem++;
  227.                 }
  228.             }
  229.         }
  230.  
  231.         /// <summary>
  232.         /// Will read or write the value, depending on the stream's IsWriting value.
  233.         /// </summary>
  234.         public void Serialize(ref float obj)
  235.         {
  236.             if (this.IsWriting)
  237.             {
  238.                 this.writeData.Add(obj);
  239.             }
  240.             else
  241.             {
  242.                 if (this.readData.Length > this.currentItem)
  243.                 {
  244.                     obj = (float) this.readData[this.currentItem];
  245.                     this.currentItem++;
  246.                 }
  247.             }
  248.         }
  249.  
  250.         /// <summary>
  251.         /// Will read or write the value, depending on the stream's IsWriting value.
  252.         /// </summary>
  253.         public void Serialize(ref Player obj)
  254.         {
  255.             if (this.IsWriting)
  256.             {
  257.                 this.writeData.Add(obj);
  258.             }
  259.             else
  260.             {
  261.                 if (this.readData.Length > this.currentItem)
  262.                 {
  263.                     obj = (Player) this.readData[this.currentItem];
  264.                     this.currentItem++;
  265.                 }
  266.             }
  267.         }
  268.  
  269.         /// <summary>
  270.         /// Will read or write the value, depending on the stream's IsWriting value.
  271.         /// </summary>
  272.         public void Serialize(ref Vector3 obj)
  273.         {
  274.             if (this.IsWriting)
  275.             {
  276.                 this.writeData.Add(obj);
  277.             }
  278.             else
  279.             {
  280.                 if (this.readData.Length > this.currentItem)
  281.                 {
  282.                     obj = (Vector3) this.readData[this.currentItem];
  283.                     this.currentItem++;
  284.                 }
  285.             }
  286.         }
  287.  
  288.         /// <summary>
  289.         /// Will read or write the value, depending on the stream's IsWriting value.
  290.         /// </summary>
  291.         public void Serialize(ref Vector2 obj)
  292.         {
  293.             if (this.IsWriting)
  294.             {
  295.                 this.writeData.Add(obj);
  296.             }
  297.             else
  298.             {
  299.                 if (this.readData.Length > this.currentItem)
  300.                 {
  301.                     obj = (Vector2) this.readData[this.currentItem];
  302.                     this.currentItem++;
  303.                 }
  304.             }
  305.         }
  306.  
  307.         /// <summary>
  308.         /// Will read or write the value, depending on the stream's IsWriting value.
  309.         /// </summary>
  310.         public void Serialize(ref Quaternion obj)
  311.         {
  312.             if (this.IsWriting)
  313.             {
  314.                 this.writeData.Add(obj);
  315.             }
  316.             else
  317.             {
  318.                 if (this.readData.Length > this.currentItem)
  319.                 {
  320.                     obj = (Quaternion) this.readData[this.currentItem];
  321.                     this.currentItem++;
  322.                 }
  323.             }
  324.         }
  325.     }
  326.  
  327.  
  328.     public class SceneManagerHelper
  329.     {
  330.         public static string ActiveSceneName
  331.         {
  332.             get
  333.             {
  334.                 Scene s = SceneManager.GetActiveScene();
  335.                 return s.name;
  336.             }
  337.         }
  338.  
  339.         public static int ActiveSceneBuildIndex
  340.         {
  341.             get { return SceneManager.GetActiveScene().buildIndex; }
  342.         }
  343.  
  344.  
  345.         #if UNITY_EDITOR
  346.         /// <summary>In Editor, we can access the active scene's name.</summary>
  347.         public static string EditorActiveSceneName
  348.         {
  349.             get { return SceneManager.GetActiveScene().name; }
  350.         }
  351.         #endif
  352.     }
RAW Paste Data