Listener

29         private readonly Dictionary opParameters = new Dictionary(); // used in OpRaiseEvent() (avoids lots of new Dictionary() calls)
31         public LoadbalancingPeer(IPhotonPeerListener listener, ConnectionProtocol protocolType) : base(listener, protocolType)
32         {
33         }

48         public virtual bool OpJoinLobby(TypedLobby lobby)
49         {
50             if (this.DebugOut >= DebugLevel.INFO)
51             {
52                 this.Listener.DebugReturn(DebugLevel.INFO, "OpJoinLobby()");
53             }
54
55             Dictionary parameters = null;
56             if (lobby != null && !lobby.IsDefault)
57             {
58                 parameters = new Dictionary();
59                 parameters[(byte)ParameterCode.LobbyName] = lobby.Name;
60                 parameters[(byte)ParameterCode.LobbyType] = (byte)lobby.Type;
61             }
62
63             return this.OpCustom(OperationCode.JoinLobby, parameters, true);
64         }

71         public virtual bool OpLeaveLobby()
72         {
73             if (this.DebugOut >= DebugLevel.INFO)
74             {
75                 this.Listener.DebugReturn(DebugLevel.INFO, "OpLeaveLobby()");
76             }
77
78             return this.OpCustom(OperationCode.LeaveLobby, null, true);
79         }

86         public virtual bool OpCreateRoom(string roomName, RoomOptions roomOptions, TypedLobby lobby, Hashtable playerProperties, bool onGameServer)
87         {
88             if (this.DebugOut >= DebugLevel.INFO)
89             {
90                 this.Listener.DebugReturn(DebugLevel.INFO, "OpCreateRoom()");
91             }
92
93             Dictionary op = new Dictionary();
94
95             if (!string.IsNullOrEmpty(roomName))
96             {
97                 op[ParameterCode.RoomName] = roomName;
98             }
99             if (lobby != null)
100             {
101                 op[ParameterCode.LobbyName] = lobby.Name;
102                 op[ParameterCode.LobbyType] = (byte)lobby.Type;
103             }
104
105             if (onGameServer)
106             {
107                 if (playerProperties != null && playerProperties.Count > 0)
108                 {
109                     op[ParameterCode.PlayerProperties] = playerProperties;
110                     op[ParameterCode.Broadcast] = true; // TODO: check if this also makes sense when creating a room?! // broadcast actor properties
111                 }
112
113
114                 if (roomOptions == null)
115                 {
116                     roomOptions = new RoomOptions();
117                 }
118
119                 Hashtable gameProperties = new Hashtable();
120                 op[ParameterCode.GameProperties] = gameProperties;
121                 gameProperties.MergeStringKeys(roomOptions.customRoomProperties);
122
123                 gameProperties[GameProperties.IsOpen] = roomOptions.isOpen; // TODO: check default value. dont send this then
124                 gameProperties[GameProperties.IsVisible] = roomOptions.isVisible; // TODO: check default value. dont send this then
125                 gameProperties[GameProperties.PropsListedInLobby] = roomOptions.customRoomPropertiesForLobby;
126                 if (roomOptions.maxPlayers > 0)
127                 {
128                     gameProperties[GameProperties.MaxPlayers] = roomOptions.maxPlayers;
129                 }
130                 if (roomOptions.cleanupCacheOnLeave)
131                 {
132                     op[ParameterCode.CleanupCacheOnLeave] = true; // this is actually setting the room's config
133                     gameProperties[GameProperties.CleanupCacheOnLeave] = true; // this is only informational for the clients which join
134                 }
135             }
136
137             // UnityEngine.Debug.Log("CreateGame: " + SupportClass.DictionaryToString(op));
138             return this.OpCustom(OperationCode.CreateGame, op, true);
139         }

212         public virtual bool OpJoinRandomRoom(Hashtable expectedCustomRoomProperties, byte expectedMaxPlayers, Hashtable playerProperties, MatchmakingMode matchingType, TypedLobby typedLobby, string sqlLobbyFilter)
213         {
214             if (this.DebugOut >= DebugLevel.INFO)
215             {
216                 this.Listener.DebugReturn(DebugLevel.INFO, "OpJoinRandomRoom()");
217             }
218
219             Hashtable expectedRoomProperties = new Hashtable();
220             expectedRoomProperties.MergeStringKeys(expectedCustomRoomProperties);
221             if (expectedMaxPlayers > 0)
222             {
223                 expectedRoomProperties[GameProperties.MaxPlayers] = expectedMaxPlayers;
224             }
225
226             Dictionary opParameters = new Dictionary();
227             if (expectedRoomProperties.Count > 0)
228             {
229                 opParameters[ParameterCode.GameProperties] = expectedRoomProperties;
230             }
231
232             if (playerProperties != null && playerProperties.Count > 0)
233             {
234                 opParameters[ParameterCode.PlayerProperties] = playerProperties;
235             }
236
237             if (matchingType != MatchmakingMode.FillRoom)
238             {
239                 opParameters[ParameterCode.MatchMakingType] = (byte)matchingType;
240             }
241
242             if (typedLobby != null)
243             {
244                 opParameters[ParameterCode.LobbyName] = typedLobby.Name;
245                 opParameters[ParameterCode.LobbyType] = (byte)typedLobby.Type;
246             }
247
248             if (!string.IsNullOrEmpty(sqlLobbyFilter))
249             {
250                 opParameters[ParameterCode.Data] = sqlLobbyFilter;
251             }
252
253             // UnityEngine.Debug.LogWarning("OpJoinRandom: " + opParameters.ToStringFull());
254             return this.OpCustom(OperationCode.JoinRandomGame, opParameters, true);
255         }

287         protected bool OpSetPropertiesOfActor(int actorNr, Hashtable actorProperties, bool broadcast, byte channelId)
288         {
289             if (this.DebugOut >= DebugLevel.INFO)
290             {
291                 this.Listener.DebugReturn(DebugLevel.INFO, "OpSetPropertiesOfActor()");
292             }
293
294             if (actorNr <= 0 || actorProperties == null)
295             {
296                 if (this.DebugOut >= DebugLevel.INFO)
297                 {
298                     this.Listener.DebugReturn(DebugLevel.INFO, "OpSetPropertiesOfActor not sent. ActorNr must be > 0 and actorProperties != null.");
299                 }
300                 return false;
301             }
302
303             Dictionary opParameters = new Dictionary();
304             opParameters.Add(ParameterCode.Properties, actorProperties);
305             opParameters.Add(ParameterCode.ActorNr, actorNr);
306             if (broadcast)
307             {
308                 opParameters.Add(ParameterCode.Broadcast, broadcast);
309             }
310
311             return this.OpCustom((byte)OperationCode.SetProperties, opParameters, broadcast, channelId);
312         }

326         public bool OpSetPropertiesOfRoom(Hashtable gameProperties, bool broadcast, byte channelId)
327         {
328             if (this.DebugOut >= DebugLevel.INFO)
329             {
330                 this.Listener.DebugReturn(DebugLevel.INFO, "OpSetPropertiesOfRoom()");
331             }
332
333             Dictionary opParameters = new Dictionary();
334             opParameters.Add(ParameterCode.Properties, gameProperties);
335             if (broadcast)
336             {
337                 opParameters.Add(ParameterCode.Broadcast, true);
338             }
339
340             return this.OpCustom((byte)OperationCode.SetProperties, opParameters, broadcast, channelId);
341         }

358         public virtual bool OpAuthenticate(string appId, string appVersion, string userId, AuthenticationValues authValues, string regionCode)
359         {
360             if (this.DebugOut >= DebugLevel.INFO)
361             {
362                 this.Listener.DebugReturn(DebugLevel.INFO, "OpAuthenticate()");
363             }
364
365             Dictionary opParameters = new Dictionary();
366             if (authValues != null && authValues.Secret != null)
367             {
368                 opParameters[ParameterCode.Secret] = authValues.Secret;
369                 return this.OpCustom(OperationCode.Authenticate, opParameters, true, (byte)0, false);
370             }
371
372             opParameters[ParameterCode.AppVersion] = appVersion;
373             opParameters[ParameterCode.ApplicationId] = appId;
374
375             if (!string.IsNullOrEmpty(regionCode))
376             {
377                 opParameters[ParameterCode.Region] = regionCode;
378             }
379
380             if (!string.IsNullOrEmpty(userId))
381             {
382                 opParameters[ParameterCode.UserId] = userId;
383             }
384
385
386             if (authValues != null && authValues.AuthType != CustomAuthenticationType.None)
387             {
388                 if (!this.IsEncryptionAvailable)
389                 {
390                     this.Listener.DebugReturn(DebugLevel.ERROR, "OpAuthenticate() failed. When you want Custom Authentication encryption is mandatory.");
391                     return false;
392                 }
393
394                 opParameters[ParameterCode.ClientAuthenticationType] = (byte)authValues.AuthType;
395                 if (!string.IsNullOrEmpty(authValues.Secret))
396                 {
397                     opParameters[ParameterCode.Secret] = authValues.Secret;
398                 }
399                 //else
400                 //{
401                     if (!string.IsNullOrEmpty(authValues.AuthParameters))
402                     {
403                         opParameters[ParameterCode.ClientAuthenticationParams] = authValues.AuthParameters;
404                     }
405                     if (authValues.AuthPostData != null)
406                     {
407                         opParameters[ParameterCode.ClientAuthenticationData] = authValues.AuthPostData;
408                     }
409                 //}
410             }
411
412             bool sent = this.OpCustom(OperationCode.Authenticate, opParameters, true, (byte)0, this.IsEncryptionAvailable);
413             if (!sent)
414             {
415                 this.Listener.DebugReturn(DebugLevel.ERROR, "Error calling OpAuthenticate! Did not work. Check log output, CustomAuthenticationValues and if you're connected.");
416             }
417             return sent;
418         }

433         public virtual bool OpChangeGroups(byte[] groupsToRemove, byte[] groupsToAdd)
434         {
435             if (this.DebugOut >= DebugLevel.ALL)
436             {
437                 this.Listener.DebugReturn(DebugLevel.ALL, "OpChangeGroups()");
438             }
439
440             Dictionary opParameters = new Dictionary();
441             if (groupsToRemove != null)
442             {
443                 opParameters[(byte)LiteOpKey.Remove] = groupsToRemove;
444             }
445             if (groupsToAdd != null)
446             {
447                 opParameters[(byte)LiteOpKey.Add] = groupsToAdd;
448             }
449
450             return this.OpCustom((byte)LiteOpCode.ChangeGroups, opParameters, true, 0);
451         }

185     public NetworkingPeer(IPhotonPeerListener listener, string playername, ConnectionProtocol connectionProtocol) : base(listener, connectionProtocol)
186     {
187         #if !UNITY_EDITOR && (UNITY_WINRT)
188         // this automatically uses a separate assembly-file with Win8-style Socket usage (not possible in Editor)
189         Debug.LogWarning("Using PingWindowsStore");
190         PhotonHandler.PingImplementation = typeof(PingWindowsStore); // but for ping, we have to set the implementation explicitly to Win 8 Store/Phone
191         #endif
192
193         #pragma warning disable 0162 // the library variant defines if we should use PUN's SocketUdp variant (at all)
194         if (PhotonPeer.NoSocket)
195         {
196             #if !UNITY_EDITOR && (UNITY_PS3 || UNITY_ANDROID)
197             Debug.Log("Using class SocketUdpNativeDynamic");
198             this.SocketImplementation = typeof(SocketUdpNativeDynamic);
199             PhotonHandler.PingImplementation = typeof(PingNativeDynamic);
200             #elif !UNITY_EDITOR && UNITY_IPHONE
201             Debug.Log("Using class SocketUdpNativeStatic");
202             this.SocketImplementation = typeof(SocketUdpNativeStatic);
203             PhotonHandler.PingImplementation = typeof(PingNativeStatic);
204             #elif !UNITY_EDITOR && (UNITY_WINRT)
205             // this automatically uses a separate assembly-file with Win8-style Socket usage (not possible in Editor)
206             #else
207             this.SocketImplementation = typeof (SocketUdp);
208             PhotonHandler.PingImplementation = typeof(PingMonoEditor);
209             #endif
210
211             if (this.SocketImplementation == null)
212             {
213                 Debug.Log("No socket implementation set for 'NoSocket' assembly. Please contact Exit Games.");
214             }
215         }
216         #pragma warning restore 0162
217
218         if (PhotonHandler.PingImplementation == null)
219         {
220             PhotonHandler.PingImplementation = typeof(PingMono);
221         }
222
223         this.Listener = this;
224         this.lobby = TypedLobby.Default;
225         this.LimitOfUnreliableCommands = 40;
226
227         // don't set the field directly! the listener is passed on to other classes, which get updated by the property set method
228         this.externalListener = listener;
229         this.PlayerName = playername;
230         this.mLocalActor = new PhotonPlayer(true, -1, this.playername);
231         this.AddNewPlayer(this.mLocalActor.ID, this.mLocalActor);
232
233         // RPC shortcut lookup creation (from list of RPCs, which is updated by Editor scripts)
234         rpcShortcuts = new Dictionary(PhotonNetwork.PhotonServerSettings.RpcList.Count);
235         for (int index = 0; index < PhotonNetwork.PhotonServerSettings.RpcList.Count; index++)
236         {
237             var name = PhotonNetwork.PhotonServerSettings.RpcList[index];
238             rpcShortcuts[name] = index;
239         }
240
241         this.State = global::PeerState.PeerCreated;
242     }