HashSet

909     public static void UpdateRpcList()
910     {
911         List additionalRpcs = new List();
912         HashSet currentRpcs = new HashSet();
913
914         var types = GetAllSubTypesInScripts(typeof(MonoBehaviour));
915
916         foreach (var mono in types)
917         {
918             MethodInfo[] methods = mono.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
919
920             foreach (MethodInfo method in methods)
921             {
922                 if (method.IsDefined(typeof(UnityEngine.RPC), false))
923                 {
924                     currentRpcs.Add(method.Name);
925
926                     if (!additionalRpcs.Contains(method.Name) && !PhotonEditor.Current.RpcList.Contains(method.Name))
927                     {
928                         additionalRpcs.Add(method.Name);
929                     }
930                 }
931             }
932         }
933
934         if (additionalRpcs.Count > 0)
935         {
936             // LIMITS RPC COUNT
937             if (additionalRpcs.Count + PhotonEditor.Current.RpcList.Count >= byte.MaxValue)
938             {
939                 if (currentRpcs.Count <= byte.MaxValue)
940                 {
941                     bool clearList = EditorUtility.DisplayDialog(CurrentLang.IncorrectRPCListTitle, CurrentLang.IncorrectRPCListLabel, CurrentLang.RemoveOutdatedRPCsLabel, CurrentLang.CancelButton);
942                     if (clearList)
943                     {
944                         PhotonEditor.Current.RpcList.Clear();
945                         PhotonEditor.Current.RpcList.AddRange(currentRpcs);
946                     }
947                     else
948                     {
949                         return;
950                     }
951                 }
952                 else
953                 {
954                     EditorUtility.DisplayDialog(CurrentLang.FullRPCListTitle, CurrentLang.FullRPCListLabel, CurrentLang.SkipRPCListUpdateLabel);
955                     return;
956                 }
957             }
958
959             additionalRpcs.Sort();
960             PhotonEditor.Current.RpcList.AddRange(additionalRpcs);
961             EditorUtility.SetDirty(PhotonEditor.Current);
962         }
963     }

25     internal static void HierarchyChange()
26     {
27         if (Application.isPlaying)
28         {
29             //Debug.Log("HierarchyChange ignored, while running.");
30             CheckSceneForStuckHandlers = true; // done once AFTER play mode.
31             return;
32         }
33
34         if (CheckSceneForStuckHandlers)
35         {
36             CheckSceneForStuckHandlers = false;
37             PhotonNetwork.InternalCleanPhotonMonoFromSceneIfStuck();
38         }
39
40         HashSet pvInstances = new HashSet();
41         HashSet usedInstanceViewNumbers = new HashSet();
42         bool fixedSomeId = false;
43
44         //// the following code would be an option if we only checked scene objects (but we can check all PVs)
45         //PhotonView[] pvObjects = GameObject.FindSceneObjectsOfType(typeof(PhotonView)) as PhotonView[];
46         //Debug.Log("HierarchyChange. PV Count: " + pvObjects.Length);
47
48         string levelName = Application.loadedLevelName;
49         #if UNITY_EDITOR
50         levelName = System.IO.Path.GetFileNameWithoutExtension(EditorApplication.currentScene);
51         #endif
52         int minViewIdInThisScene = PunSceneSettings.MinViewIdForScene(levelName);
53         //Debug.Log("Level '" + Application.loadedLevelName + "' has a minimum ViewId of: " + minViewIdInThisScene);
54
55         PhotonView[] pvObjects = Resources.FindObjectsOfTypeAll(typeof(PhotonView)) as PhotonView[];
56
57         foreach (PhotonView view in pvObjects)
58         {
59             // first pass: fix prefabs to viewID 0 if they got a view number assigned (cause they should not have one!)
60             if (EditorUtility.IsPersistent(view.gameObject))
61             {
62                 if (view.viewID != 0 || view.prefixBackup != -1 || view.instantiationId != -1)
63                 {
64                     Debug.LogWarning("PhotonView on persistent object being fixed (id and prefix must be 0). Was: " + view);
65                     view.viewID = 0;
66                     view.prefixBackup = -1;
67                     view.instantiationId = -1;
68                     EditorUtility.SetDirty(view);
69                     fixedSomeId = true;
70                 }
71             }
72             else
73             {
74                 // keep all scene-instanced PVs for later re-check
75                 pvInstances.Add(view);
76             }
77         }
78
79         Dictionary idPerObject = new Dictionary();
80
81         // second pass: check all used-in-scene viewIDs for duplicate viewIDs (only checking anything non-prefab)
82         // scene-PVs must have user == 0 (scene/room) and a subId != 0
83         foreach (PhotonView view in pvInstances)
84         {
85             if (view.ownerId > 0)
86             {
87                 Debug.Log("Re-Setting Owner ID of: " + view);
88             }
89             view.ownerId = 0; // simply make sure no owner is set (cause room always uses 0)
90             view.prefix = -1; // TODO: prefix could be settable via inspector per scene?!
91
92             if (view.viewID != 0)
93             {
94                 if (view.viewID < minViewIdInThisScene || usedInstanceViewNumbers.Contains(view.viewID))
95                 {
96                     view.viewID = 0; // avoid duplicates and negative values by assigning 0 as (temporary) number to be fixed in next pass
97                 }
98                 else
99                 {
100                     usedInstanceViewNumbers.Add(view.viewID); // builds a list of currently used viewIDs
101
102                     int instId = 0;
103                     if (idPerObject.TryGetValue(view.gameObject, out instId))
104                     {
105                         view.instantiationId = instId;
106                     }
107                     else
108                     {
109                         view.instantiationId = view.viewID;
110                         idPerObject[view.gameObject] = view.instantiationId;
111                     }
112                 }
113             }
114
115         }
116
117         // third pass: anything that's now 0 must get a new (not yet used) ID (starting at 0)
118         int lastUsedId = (minViewIdInThisScene > 0) ? minViewIdInThisScene - 1 : 0;
119
120         foreach (PhotonView view in pvInstances)
121         {
122             if (view.viewID == 0)
123             {
124                 // Debug.LogWarning("setting scene ID: " + view.gameObject.name + " ID: " + view.subId.ID + " scene ID: " + view.GetSceneID() + " IsPersistent: " + EditorUtility.IsPersistent(view.gameObject) + " IsSceneViewIDFree: " + IsSceneViewIDFree(view.subId.ID, view));
125                 int nextViewId = PhotonViewHandler.GetID(lastUsedId, usedInstanceViewNumbers);
126
127                 view.viewID = nextViewId;
128
129                 int instId = 0;
130                 if (idPerObject.TryGetValue(view.gameObject, out instId))
131                 {
132                     Debug.Log("Set inst ID");
133                     view.instantiationId = instId;
134                 }
135                 else
136                 {
137                     view.instantiationId = view.viewID;
138                     idPerObject[view.gameObject] = nextViewId;
139                 }
140
141                 //// when using the Editor's serialization (view.subId in this case), this is not needed, it seems
142                 //PrefabUtility.RecordPrefabInstancePropertyModifications(view);
143
144                 lastUsedId = nextViewId;
145                 EditorUtility.SetDirty(view);
146                 fixedSomeId = true;
147             }
148         }
149
150
151         if (fixedSomeId)
152         {
153             //Debug.LogWarning("Some subId was adjusted."); // this log is only interesting for Exit Games
154         }
155     }

159     public static int GetID(int idOffset, HashSet usedInstanceViewNumbers)
160     {
161         while (idOffset < PhotonNetwork.MAX_VIEW_IDS)
162         {
163             idOffset++;
164             if (!usedInstanceViewNumbers.Contains(idOffset))
165             {
166                 break;
167             }
168         }
169
170         return idOffset;
171     }

459     private void LeftRoomCleanup()
460     {
461         bool wasInRoom = mRoomToGetInto != null;
462         // when leaving a room, we clean up depending on that room's settings.
463         bool autoCleanupSettingOfRoom = (this.mRoomToGetInto != null) ? this.mRoomToGetInto.autoCleanUp : PhotonNetwork.autoCleanUpPlayerObjects;
464
465         this.hasSwitchedMC = false;
466         this.mRoomToGetInto = null;
467         this.mActors = new Dictionary();
468         this.mPlayerListCopy = new PhotonPlayer[0];
469         this.mOtherPlayerListCopy = new PhotonPlayer[0];
470         this.mMasterClient = null;
471         this.allowedReceivingGroups = new HashSet();
472         this.blockSendingGroups = new HashSet();
473         this.mGameList = new Dictionary();
474         this.mGameListCopy = new RoomInfo[0];
475         this.isFetchingFriends = false;
476
477         this.ChangeLocalID(-1);
478
479         // Cleanup all network objects (all spawned PhotonViews, local and remote)
480         if (autoCleanupSettingOfRoom)
481         {
482             this.LocalCleanupAnythingInstantiated(true);
483             PhotonNetwork.manuallyAllocatedViewIds = new List(); // filled and easier to replace completely
484         }
485
486         if (wasInRoom)
487         {
488             SendMonoMessage(PhotonNetworkingMessage.OnLeftRoom);
489         }
490     }

495     protected internal void LocalCleanupAnythingInstantiated(bool destroyInstantiatedGameObjects)
496     {
497         if (tempInstantiationData.Count > 0)
498         {
499             Debug.LogWarning("It seems some instantiation is not completed, as instantiation data is used. You should make sure instantiations are paused when calling this method. Cleaning now, despite this.");
500         }
501
502         // Destroy GO's (if we should)
503         if (destroyInstantiatedGameObjects)
504         {
505             // Fill list with Instantiated objects
506             HashSet instantiatedGos = new HashSet();
507             foreach (PhotonView view in this.photonViewList.Values)
508             {
509                 if (view.isRuntimeInstantiated)
510                 {
511                     instantiatedGos.Add(view.gameObject); // HashSet keeps each object only once
512                 }
513             }
514
515             foreach (GameObject go in instantiatedGos)
516             {
517                 this.RemoveInstantiatedGO(go, true);
518             }
519         }
520
521         // photonViewList is cleared of anything instantiated (so scene items are left inside)
522         // any other lists can be
523         this.tempInstantiationData.Clear(); // should be empty but to be safe we clear (no new list needed)
524         PhotonNetwork.lastUsedViewSubId = 0;
525         PhotonNetwork.lastUsedViewSubIdStatic = 0;
526     }

1937     public static void SendMonoMessage(PhotonNetworkingMessage methodString, params object[] parameters)
1938     {
1939         HashSet objectsToCall;
1940         if (PhotonNetwork.SendMonoMessageTargets != null)
1941         {
1942             objectsToCall = PhotonNetwork.SendMonoMessageTargets;
1943         }
1944         else
1945         {
1946             objectsToCall = PhotonNetwork.FindGameObjectsWithComponent(PhotonNetwork.SendMonoMessageTargetType);
1947         }
1948
1949         string methodName = methodString.ToString();
1950         object callParameter = (parameters != null && parameters.Length == 1) ? parameters[0] : parameters;
1951         foreach (GameObject gameObject in objectsToCall)
1952         {
1953             gameObject.SendMessage(methodName, callParameter, SendMessageOptions.DontRequireReceiver);
1954         }
1955     }

2430     public void DestroyPlayerObjects(int playerId, bool localOnly)
2431     {
2432         if (playerId <= 0)
2433         {
2434             Debug.LogError("Failed to Destroy objects of playerId: " + playerId);
2435             return;
2436         }
2437
2438         if (!localOnly)
2439         {
2440             // clean server's Instantiate and RPC buffers
2441             this.OpRemoveFromServerInstantiationsOfPlayer(playerId);
2442             this.OpCleanRpcBuffer(playerId);
2443
2444             // send Destroy(player) to anyone else
2445             this.SendDestroyOfPlayer(playerId);
2446         }
2447
2448         // locally cleaning up that player's objects
2449         HashSet playersGameObjects = new HashSet();
2450         foreach (PhotonView view in this.photonViewList.Values)
2451         {
2452             if (view.CreatorActorNr == playerId)
2453             {
2454                 playersGameObjects.Add(view.gameObject);
2455             }
2456         }
2457
2458         // any non-local work is already done, so with the list of that player's objects, we can clean up (locally only)
2459         foreach (GameObject gameObject in playersGameObjects)
2460         {
2461             this.RemoveInstantiatedGO(gameObject, true);
2462         }
2463
2464         // with ownership transfer, some objects might lose their owner.
2465         // in that case, the creator becomes the owner again. every client can apply this. done below.
2466         foreach (PhotonView view in this.photonViewList.Values)
2467         {
2468             if (view.ownerId == playerId)
2469             {
2470                 view.ownerId = view.CreatorActorNr;
2471                 //Debug.Log("Creator is: " + view.ownerId);
2472             }
2473         }
2474     }

3083     public void SetSendingEnabled(int group, bool enabled)
3084     {
3085         if (!enabled)
3086         {
3087             this.blockSendingGroups.Add(group); // can be added to HashSet no matter if already in it
3088         }
3089         else
3090         {
3091             this.blockSendingGroups.Remove(group);
3092         }
3093     }

479     public static HashSet FindGameObjectsWithComponent(Type type)
480     {
481         HashSet objectsWithComponent = new HashSet();
482
483         Component[] targetComponents = (Component[]) GameObject.FindObjectsOfType(type);
484         for (int index = 0; index < targetComponents.Length; index++)
485         {
486             objectsWithComponent.Add(targetComponents[index].gameObject);
487         }
488
489         return objectsWithComponent;
490     }

201         private HashSet SetGameObjectForKey(GameObject root, AnimationClip animClip, MainlineKey mainlineKey, float time = -1)
202         {
203             HashSet paths = new HashSet();
204             //Could do this recursively - this is easier
205             Stack toProcess = new Stack(mainlineKey.GetChildren(null));
206
207             while (toProcess.Count > 0)
208             {
209                 var next = toProcess.Pop();
210
211                 paths.Add(next.RelativePath);
212                 SetGameObjectForRef(root, next, time);
213                 SetSpriteEvent(animClip, time, next);
214
215                 var children = mainlineKey.GetChildren(next);
216                 foreach (var child in children) toProcess.Push(child);
217             }
218
219             return paths;
220         }