You are on page 1of 33

* release_history.

* Release history for the DotNet Photon Client Library (DotNet / Unity3D / Windo
ws 8 RT / Windows Phone 8 / PlayStation Mobile)
(C) 2014 Exit Games GmbH,
Questions? Visit:
*** Version (14. January 2015 - rev2765)
Fixed: Serialization of custom types with nested Serialize-calls. In this ca
se, re-using a specific memory stream breaks it.
*** Version (12. January 2015 - rev2763)
Fixed: Serialization of arrays of custom-types.
Chat API
Internal: Changed code for UserID from 7 to 225. The latter is used in LoadB
alancing, too, so we want to re-use the code here.
*** Version (05. December 2014 - rev2758)
Added: ChatApi and LoadBalancingApi folders to Unity SDK. They are needed in
any Photon project with Unity. When updating, copy and paste the files over exi
sting ones and make sure to replace the assembly-files, too.
Changed: Protocol to save more memory or re-use it. The idea is to have less
Garbage Collection (primarily for Unity/PUN and custom types).
Added: New CustomType de/serialization methods which provide the MemoryStrea
m, instead of a byte[] COPY from the stream.
Changed: Now using one method to identify a Type. This was duplicated code b
Changed: De/Serialization of some types.
Note: The drawback is now, that there are more places with: lock(). This is
far from optimal but the alternative would be to make Protocol instances per thr
ead. As most is static at the moment, this would not be an easy task.
Added: position check for DeserializeStreamFunction() call. Stream position
must be "previous + customtype length". It gets corrected but at the moment no e
rror is thrown.
Changed: DispatchIncomingCommands() no longer instantiates the commandsToRem
ove each call. This is reused and thus saves memory.
Changed: net_fx build will now check IsConstructedGenericType to detect if s
omething is a dictionary
ADDED: LoadBalancingClient.OpJoinOrCreateRoom overload which has lobby as pa
rameter. If a room gets created, this defines in which lobby it belongs.
CHANGED: LoadBalancingPeer: Added new error code PluginMismatch, documentati
on for Plugins parameter code.
*** Version (23. September 2014 - rev2738)
Updated: AddFriends and RemoveFriends doc.
Changed: Logging level for two cases. Dropping a package due to failed C
RC-check is now logged for INFO. It's expected and certainly not an error. Dropp
ing a package when the incoming challenge does not match is also not an ERROR. I
t is expected when you switch servers and packages arrive late. This is now debu
g level ALL.
*** Version (19. September 2014 - rev2736)
Fixed: Fragmentation when CRC checks are enabled. This kept clients from sen
ding fragmented commands when the additional 4 bytes CRC were included later on.

Fixed: An issue in the ChatClient which was referring to a class from Photon
Unity networking. This caused compile issues in the Unity Chat Demo.
Updated: Reference doc generation.
*** Version (15. September 2014 - rev2731)
Updated: Doc generation settings and style.
Note: This version has no code changes to rev2728 described below. That vers
ion is already released in the Unity Asset Store in PUN.
*** Version (11. September 2014 - rev2728)
Fixed: A simple "order of things" issue when detecting a timeout (due to res
ends). We first have to set "Zombie" state so that any Disconnect() call created
a disconnect-command with reserved byte = 2 = "due to timeout".
Fixed: Chat to be compatible with native sockets of PUN+ (iOS and Android ex
ports from Unity).
Fixed: Access to native sockets (in classes SocketUdpNativeDynamic and Socke
tUdpNativeStatic) is now using a lock(). The native methods are not thread safe
but we need more than one socket for PUN+ and Chat (with native sockets, too).
Changed: Logging for the case "Ignoring received package due to wrong challe
nge". This got logged on log-level ERROR but maybe is better as WARNING only. No
w this should log less often.
Internal: Updated to a newer native-sockets interface.
Internal: Updated to a newer native-sockets interface (affects PUN+ only). C
leaned up precompile defines and #if usage.
*** Version (01. August 2014 - rev2715)
Added: PhotonPing class and subclasses per platform. Allows clients to use r
egular UDP messages to ping our servers and find the best region.
Added: Native and Win8 support for PhotonPing.
Known Issue: Native ping has to be done "one by one" and without any other c
onnection in Unity. It's not yet thread safe (but that is ok as we don't want to
ping most of the time but only rarely and out of game).
Added: PhotonPing class/file to Win8 platforms.
Changed: The extern static methods for the native libs are now internal (ins
tead of private). Pings are using them, too.
Changed: WebRpcResponse.ReturnCode comment to include fail code.
Changed: OpWebRpc doc is now much more complete and helpful.
Updated: Unity SDK Particle Demo (more) and LoadBalancing Demo (just a bit).
*** Version (17. June 2014 - rev2663)
Fixed: DotNet assembly no longer contains classes that try to include our Un
ity native socket libs. This was causing issues in some cases.
Added: PhotonPeer.CommandInfoCurrentDispatch. This property gives you the de
bug string of the currently dispatched command (events or responses). Only usefu
l for UDP.
Added: LoadBalancingClient.OpRaiseEvent(). Now that LoadBalancingClient USES
a loadBalancingPeer (and doesn't extend it), things are much easier by offering
this method, too!
Added: LoadBalancingClient.IsConnected and .IsConnectedAndReady to LB API. G
oing to be part of the API from now on.
Removed: Unused fields clientId and clientCount.
Changed: Field for internal use "lastJoinActorNumber" is now private as inte
Changed: LoadBalancingClient.Disconnect is now setting it's own state to Dis
connected if the connection got closed (as expected).
Changed: How the server responds to Subscribe and Unsubscribe. Events will n
ow contain success/failure of those. This allows us to send the answer after cal
ling a WebHook if needed and we can even send it to multiple clients (which auth

enticated with the same userID).

Changed: Handling of subscription responsed. This is done to allow web servi
ces to subscribe a client remotely and to be able to prevent joining some channe
l that a user should not join (the channel of some guild or another team, e.g.).
Changed: Debug loggging. In Unity we can't use Debug.Assert, etc. So we have
to log more cleanly. This works in Editor and several platforms (but not all).
Changed: Folder for Chat API. It now begins with "Photon" which provides som
e context no matter where you copy the files. Easier to find in Unity projects.
Changed: Operation FriendList and method SendFriendList renamed to AddFriend
Added: Operation RemoveFriends and corresponding method in ChatClient.cs
Added: Console Demo has new command 'fr' to remove friends
*** Version (23. May 2014 - rev2614)
Changed: This version contains a few features that are not compatible with t
he Photon Server SDK v3.x. Notable features that are not in the Server SDK are:
NameServer, WebHooks and Turnbased API features.
Changed: This SDK is the first that contains all current APIs for Realtime,
Turnbased and Chat.
Fixed: Release build of the Unity assembly now also excludes native-socket u
sing code, fixing a Unity Free export issue. We only use the debug assembly in o
ur demos though and suggest you do the same.
Changed: LoadBalancingClient.FriendList creation/update is delayed until the
server's response is available. This avoids cases where the friends are offline
for the moment between requesting the update and getting it. Initially, it is n
ull as before.
Added: some methods to Player to find next player, etc. Useful for turnbased
games to find an opponent.
Added: LoadBalancingClient.UserId, which is the ID of a user(account). This
is used in FindFriends and when you fetch account-related data (like save-games
for Turnbased games). Set it before Connect*(). As fallback when empty during co
nnect, the PlayerName is used instead.
Removed: LoadBalancingPeer.OpSetCustomPropertiesOfActor and OpSetPropertyOfR
oom which were too special to be so low level. Could be implemented to LBClient.
Fixed: OpJoinRandomRoom and OpCreateRoom which didn't reset the ActorNr to c
laim when entering the room. Depending on previous actions, some calls of those
methods did fail when the actorNumber wasn't available.
Changed: OperationCode.Rpc is now called OperationCode.WebRpc. It's simply m
uch cleaner (considering PUN has RPCs as well but in a different context).
Changed: WebRpcResponse reading to be able to handle additional data.
Added: Parameter webForward to: OpSetCustomPropertiesOfRoom and OpSetPropert
iesOfRoom. The "old" overloads of these methods are still there, too. If webForw
ard is true, the properties are sent to the WebHooks.
Added: SendPrivateMessage() overload that has option to encrypt private mess
ages. Public messages don't need encryption.
Removed: lastId and LastMessageIndex from channels. Those were impractical a
nd should be removed from the API.
Changed: UserStatus class to ChatUserStatus.
Changed: Most classes are defined in their own file now.
Removed: Folders "Shared" and their subfolders. This gives a much better ove
Added: Handling for event SubscribeResponse. This is not actually a response
but gives you info about channels that got subscribed (e.g. when you re-login q
uickly or when a user is logged in in multiple clients).
Added: HandleSubscriptionResults() method to handle the event and proper res

*** Version (13. May - rev2575)

Fixed: Windows Store and Windows Phone libraries now only send the bytes the
y should send. This means we have to copy the payload from the "complete package
buffer" in order to send it.
Fixed: SocketTcp now handles all exceptions during reading. Still, abort-byserver is treated as ServerDisconnect. Everything else as client side disconnect
. This fix is especially for iOS exports from Unity. The iOS Power-button will i
mmediately cut any connection. The Home-button allows us to keep the connection
if we return the app to focus within a few seconds.
Fixed: TPeer.StopConnection() now clears the incoming queue when it disconne
cts. This avoids getting any more (already received) commands.
Changed: TPeer.Disconnect() now uses StopConnection instead of implementing
the same code again.
*** Version (30. April - rev2566)
Added: TypedLobby class to replace lobby name/type pair.
Added: LoadbalancingClient.CurrentLobby property. CurrentLobbyName and Curre
ntLobbyType are obsolete.
Added: New overloads in LoadbalancingClient with TypedLobby parameter instea
d of separate lobby name and type: OpJoinLobby, OpJoinRandomRoom. Old methods ma
rked obsolete.
Added: New overloads in LoadbalancingClient for OpJoinOrCreateRoom, OpCreate
Room, CreateRoom with parameters packed in RoomOptions class. Old methods marked
Breaking: LoadbalancingClient.CreateRoom parameters changed to (string roomN
ame, RoomOptions opt).
Internal: Removed obsolete LoadBalancingPeer overloads of OpCreateRoom and O
Internal: Added 'onGameServer' parameter to LoadBalancingPeer OpCreateRoom,
OpJoinRoom; used to avoid sending extra data to master (player- and room-props)
Internal: Loadbalancing Room constructor(string roomName, RoomOptions opt).
Internal: Added use of the "JoinMode" parameter which is used in context of
Turnbased games.
Fixed: Bug in OpLeaveLobby which joined the default lobby instead of leaving
any lobby.
Fixed: Server ports were read as short, which was wrong. We now use the corr
ect unsigned short to convert from the address string).
Fixed: A minor issue in the SupportClass ToString conversion which used a Ha
shtable's key type instead of the value's type in one place.
*** Version (21. March 2014 - rev2519)
Internal: For Unity, the classes that handle native sockets can now be compi
led in a variant that does not actually reference the native-socket-libs. The dl
l for PUN+ uses native sockets and need the native libs. Any regular dll will ha
ve the (not used and empty) classes for build-compatibility reasons.
Added: Values to enum EventCaching: SliceIncreaseIndex, SliceSetIndex, Slice
PurgeIndex and SlicePurgeUpToIndex. They are in Lite but used in LoadBalancing.
This is likely to be cleaned up in the next major release.
Changed: EventCaching MergeCache, ReplaceCache and RemoveCache as they belon
g to an outdated form of caching. The "RoomCache" is the better option in any ca
Added: RaiseEventOptions class. It's used for OpRaiseEvent to avoid further
parameter- and overload-clutter for this operation. While it's still not optimal
for all cases, the fields in the RaiseEventOptions class are hopefully more cle
ar how to use. Maybe some constructors will be added soon.
Changed: All OpRaiseEvent variants, except the one with RaiseEventOptions is
now obsolete.

Added: Event Cache Slicing. Cached events can now be organized into "slices"
which allows you to handle them in chunks. You can purge events in specific sli
ces (e.g. get rid of the previous game-rounds events).
Added: RaiseEventOptions.ForwardToWebhook which allows you to forward an eve
nt to a webhook (to be defined in Dashboard). Use this rarely, as it has an impa
ct on (server) performance!
*** Version (18. February 2013 - rev2493)
Added: const PhotonPeer.NoSocket, so programs using our assemblies can detec
t if they must provide an external SocketImplementation. Some builds avoid using
the Socket class (cause Unity Free doesn't support it on all platforms).
Added: PhotonPeer.SendMessage method in order to send any serializable objec
t to server.
Added: IPhotonPeerListener.OnMessage in order to be notified about getting m
essage from server.
Added: new 'Connect' method, which accepts as third parameter any serializab
le object. You may use this object on server before creating peer.
Added: OnMessage callback to samples
Changed: TCP and UDP both set the socket to null explicitly in Disconnect().
Hopefully this fixes a misbehaviour in Unity Editor which locked up often.
Changed: SocketTCP now has a syncer object and locks in Disconnect(), so on
ly one Disconnect call can be made anytime.
Fixed: Nullreference when calling DispatchIncomingCommands() before Connect(
). This was due to a (new) use of the socket wrapper. Commented this out until n
Fixed: Nullreference when calling SendAcksOnly() before Connect() with a new
non-null check.
Fixed: breaking issue in Hashtable replacement class. Enumerators used in 2
"foreach" loops were breaking with a nullreference. Fix: No caching of enumerato
Changed: AutoJoinLobby now uses this.CurrentLobbyName and this.CurrentLobbyT
ype to join a specified lobby.
Changed: EnetPeer.StopConnection will always reset the state to be able to r
Changed: Disconnect() in SocketTcp and SocketUdp sets this.socket = null, ev
en if socket.Close() caused an exception. This is what was expected.
Added: SocketUdpNativeDynamic and SocketUdpNativeStatic to "regular" Unity L
ib, to improve compatibility in Unity for different export platforms (with and w
ithout native sockets).
*** Version (17. October 2013 - rev2335)
Note: This lib contains a lot of breaking changes and socket handling has be
en refactored. By now, this is well tested and confirmed working.
Changed: The way sockets are handled and added native-socket-lib support. Th
ere is a new IPhotonSocket interface which even allows to use external classes a
s socket wrapper.
Added: SocketImplementation property to set a class as socket implementation
(Unity. sets native implementation or c# socket at compile time)
Changed: Win 8 RT and Phone now use fewer separate classes and files. Instea
d, more files from the (regular) DotNet client are used. RT and Phone are now pa
rt of the trunk folder in our SVN.
Added: TrafficStats.TimestampOfLastAck and .TimestampOfLastReliableCommand
Changed: Handling of server-side shutdown (a form of TCP disconnect) is now
handled specifically as server-side-disconnect (was: generic receive exception)
Added: If a UDP connection times out in a client, it sends a special flag in
it's disconnect command (to the server). This enables us to detect which side i
s triggering timeouts more often (and we can improve things).
LoadBalancing API
Fixed: issue where we called a virtual member from a constructor (http://con
Changed: LocalPlayer is now a property which checks null and returns a new P
layer (via virtual CreatePlayer) on demand.
Added: OpJoinRoom now optionally creates a room if parameter "createIfNotExi
sts" is set to true and the room didn't exist. Room properties can't be set "on
create" this way. LocalPlayer.IsMasterClient will be true.
Added: When OpJoinRoom can create a room, it also won't define which propert
ies go into the lobby. You can use the new Room.SetPropertiesListedInLobby().
Added: You can pass a actorNumber to OpJoinRoom when you re-enter a room and
want to reclaim a specific actorNumber in that room. In best case, the client c
an re-join after a disconnect/crash and seamlessly go on playing.
*** Version (15. August 2013 - rev2272)
Changed: The library for Unity now contains a ExitGames.Client.Photon.Hashta
ble to be compatible with Win 8 exports. This must be used from now on!
Note: In Unity, the compiler will complain about ambiguous Hashtable def
initions. To solve this, add this to the "using" part of your code: using Hashta
ble = ExitGames.Client.Photon.Hashtable;
Removed: Builds for Silverlight and Windows Phone 7.1 (this is not affecting
Windows 8 RT and Windows 8 Phone SDKs which are of course supported)
Fixed: A null-reference check for a TCP connection's SendAcksOnly().
*** Version (06.08.2013 - rev2242)
Added: Steam and Facebook entries to CustomAuthenticationType enum.
Fixed: Potential nullreference exception in TCP SendAcksOnly() code. If call
ed before Connect(), this always failed.
Updated: Replacement classes for datatypes not supported on some platforms (
Hashtable mostly).
Added: Hashtable got a new GetEnumerator that returns a IDictionary just l
ike the standard Hashtable does.
Changed: Constructor with int InitialSize now calls the matching base cons
Removed: Synchronized() method which didn't do much and is not used.
Changed: ToString is now an override instead a "new" method.
Changed: DataTypes.cs: the Stopwatch is only implemented for Silverlight (
non Windows Phone 8)
Updated: Description.
Changed: Protocol to expect Hashtable always providing a DictionaryEntry. Re
lated to change in DataTypes.cs.
Changed: Protocol now has conditional "Dictionary" detection. In WP8 the API
is different for that. Uses #if WINDOWS_PHONE. same file now works in W8 and WP
Changed: Removed PRPCAttribute from SupportClass.cs. This is used only in PU
N and needs conditional per-platform compilation anyways, so it gets implemented
Removed: surplus debug output in ReceiveIncomingCommands().
Fixed: Debug output in FetchServerTimestamp() depended on the Thread calling
the method. Correct: The output is enqueued and dispatched later on.
Fixed: FetchServerTimestamp no longer fails with a SendError when the state
is not "Connected".
Internal: Metro-Alike project now uses DataTypes.cs of Silverlight (like eve
ryone else). Removed surplus copy.
Internal: DataTypes.cs and Protocol.cs files can now be used in DotNet 3.5,
Windows Store and Windows 8 Phone.
Internal: outdated compiler-definitions "Photon" and "METROALIKE".
*** Version (10.07.2013 - rev2209)
Added: "Typed Lobby" API. Photon Cloud and Loadbalancing now support multipl
e lobbies per app/title. Also, different types of lobbies are now possible, each
can have different options and different rules for matchmaking.

Added: enum LobbyType with "Default" and "SqlLobby". The SqlLobby is a new t
ype of lobby that uses up to 10 room properties with sql-like filters. The filte
r being written like the "where" part of a sql query.
Changed: FetchServerTimestamp now enqueues callbacks (can be called by socke
t-receive-thread). also no longer causes a disconnect callback if offline
Changed: RemoveSentReliableCommand now enqueues callbacks (can be called by
Internal: SendAcksOnly override in TCP's TPeer class. This now sends pings b
ut nothing else. That resets the server's timeout for this peer
LoadBalancing API
Updated: LoadBalancing API in the Unity demos (now gets copied over at build
time, making sure it's identical to the DotNet "original")
Fixed: LoadBalancingClient now handles SecurityException and InternalReceive
Exceptions and disconnects correctly. Before, especially Unity web clients would
get stuck in "Disconnecting" state.
Fixed: LoadBalancingClient state on disconnect (no matter what caused the di
*** Version (19.06.2013 - rev2170)
Fixed: surplus conversion of incoming data to string, which was used in debu
*** Version (17.06.2013 - rev2160)
Fixed: custom auth will send custom auth parameters if any authentication pa
rams are set
*** Version (10.06.2013 - rev2148)
Added: new POST value for Custom Authentication. POST can carry more data th
an GET (usually used). AuthenticationValues has a setter for this.
LoadBalancing API
Changed: LoadBalancingClient.AuthValues is renamed to CustomAuthenticationVa
lues property (sets the custom authentication values).
Changed: Player class now compares by ActorNumer (assigned by server) instea
d of comparing the instance.
Internal: SupportClass.GetMethods() now returns type.GetRuntimeMethods(), fi
ltered by attribute (if at all needed). This is used by Photon Unity Networking
(PUN) internally. It also returns inherited methods now, not only Declared.
*** Version (24.05.2013 - rev2112)
Added: Feature "Custom Authentication" which lets you authorize players/user
s in the Photon Cloud with an external account/user service. More on that online
Added: LoadBalancing API Feature "Friend Finding" which enables a client to
find friends in rooms by userId. If an external service provides a userID per pl
ayer and a friend list, this can be used to find a friend's room (game) and join
it (unless closed or full).
Added: CustomAuthenticationType enum to enable differnt types of custom auth
later on (only one actually useful value so far).
Added: Class AuthenticationValues as container for authentication values.
Added: LoadBalancingClient.Connect overload which takes a AuthenticationValu
es parameter.
Added: LoadBalancingPeer.AuthValues property to set the custom authenticatio
n values.
Added: Parameter authValues to OpAuthenticate. This is used to provide the a
uthentication parameters and or the secret/ticket provided by Photon.
Added: ErrorCode.CustomAuthenticationFailed to be used in switches for Opera
tionResponse.ErrorCode (for OpAuthenticate).
Changed: LoadBalancingClient.PlayerName can be set before connecting to get
a UserId which is "findable" by OpFindFriends(). Find friends does NOT use any v
alues set for custom authentication!

Added: Class FriendInfo to contain a friend's name, online state and room na
me (if available and after using OpFindFriends()).
Added: OpFindFriends() to actually find the friends. Use on the Master Serve
r only, not on a room.
Added: LoadBalancingClient.FriendList, a List of FriendInfo entries. Filled
by using OpFindFriends (don't modify this list directly!).
Added: LoadBalancingClient.FriendListAge, to let you know how old the Friend
List is. Only get updates when the list gets "old".
Fixed: OpRaiseEvent will no longer send "group" if it's 0 (which is the defa
Added: OpRaiseEvent overload to send object instead of Hashtable. This overl
oad uses another parameter order to not mix up with the older implementation. Yo
u can send any serializable datatype now but must be aware if the event is Hasht
able or something else.
Changed: Several variants of OpAuthenticate(), Connect() and ConnectToMaster
() are now obsolete or removed. Use the alternative implementations (which shoul
d be cleaner).
Internal: Added several (operation) parameters to enum ParameterCode: Client
AuthenticationType, ClientAuthenticationParams, FindFriendsRequestList, FindFrie
ndsResponseOnlineList, FindFriendsResponseRoomIdList.
Added: PhotonPeer.ResentReliableCommands to get count of re-sent commands (m
ight be higher than out command count (as that counts created commands only)
Internal: Address (string) handling now uses string.Split instead of IndexOf
to separate port from address and short.TryParse instead of short.Parse
Added: TrafficStatsGameLevel.ResetMaximumCounters() to reset those values th
at could max-out easily. Allows to get "longest delta between SendOutgoingComman
ds()-calls since last query".
*** Version (21.02.2013 - rev2066)
Fixed: Potential lock-up during sending. This could cause infinite blocking
and thus a crash in some apps. (Win8 / Win Store api only)
*** Version (15.02.2013 - rev2060)
Fixed: Issue with delayed sending of operations in udp. The data could becom
e overwritten before being sent. The bug was leading to high disconnect rates fo
r clients using Windows Phone 7 and 8 and Silverlight or any client that used Ne
twork Simulation.
*** Version (13.02.2013 - rev2053)
Note: This release only changed the version, matching the new Server SDK v3.
Updated: readme.txt
Fixed: Reference for Windows 8 RT and Windows Phone 8 SDKs.
Added: Particle Demo to Unity Client SDK.
*** Version (11.02.2013 - rev1998)
Added: Optional per package CRC checksums to filter out compromised packages
(avoiding more issues, compared to reading bad values).
Added: PhotonPeer .CrcEnabled and .PacketLossByCrc to handle CRC and get the
count of affected (incoming) packages.
Note: Checking packages with CRC will take some computation time. Consider t
his an option to detect if/why someone's connection is bad. It's likely not good
to be enabled by default.
Windows 8 RT & Windows 8 Phone:
Fixed: Serialization of foat and double values. These caused exceptions when
used in object-arrays.
*** Version (19.12.2012 - rev1946)
Added: New Platform: Mono 4 Android. Please check the Readme.txt for hints h
ow to build the demo in Mono 4 Android.

Changed: The referenced DotNet assemblies used by our libraries, which makes
ours compatible with Mono 4 Android and others.
Changed: The Particle Demo Logic to also handle events sent by JavaScript cl
ients. In case these are used, the types used in event differ from what DotNet o
r other clients send.
Changed: PhotonPeer.LocalTimeInMilliSeconds property now uses SupportClass.G
etTickCount(). That method is using Environment.TickCount (which can be replaced
if needed).
Changed: Any place that directly used Environment.TickCount (as the way Supp
ortClass.GetTickCount() gets the value can be replaced).
Renamed: GetLocalMsTimestampDelegate is now: SupportClass.IntegerMillisecond
sDelegate (rarely used if at all).
*** Version (29.11.2012 - rev1923)
Internal: A client timeout now internally sets connectionState to Zombie and
then calls Disconnect() instead of stopping the connection right away.
Changed: Disconnect() sends a disconnect-command in any case (except not con
nected or disconnecting). If the connection is not in state connected anymore, s
aid command is unsequenced (unreliable) and the disconnect is locally executed i
mmediately as call to StopThread(). As before, disconnecting and disconnected cl
ients won't send this.
Changed: Ping creation is now more strict and checks also if any reliable co
mmands are outgoing AreReliableCommandsInTransit(). this avoids a few pings.
Fixed: NullReference exception in StopConnection() if it's called before bei
ng connected for the first time (late object creation made this fail).
Changed: PhotonPeer.LocalTimeInMilliSeconds property now uses SupportClass.G
etTickCount(). That method is using Environment.TickCount (which can be replaced
if needed).
Changed: Any place that directly used Environment.TickCount (as the way Supp
ortClass.GetTickCount() gets the value can be replaced).
Renamed: GetLocalMsTimestampDelegate is now: SupportClass.IntegerMillisecond
sDelegate (rarely used if at all).
*** Version (27.11.2012 - rev1917)
Note: Silverlight SDK release only!
Updated: Silverlight projects with proper references (hopefully). In case yo
u wonder: Some projects are included even though only their (source) files are l
inked in Silverlight. We can't reference DotNet projects directly, so we use the
(shared) files instead.
Updated: Silverlight Particle Demo now has a basic gui and hopefully helps w
ith your first steps.
*** Version (16.11.2012 - rev1891)
Added: Interest Groups! In rooms, you might send events to an interest group
, identified by a byte (255 groups are currently allowed). OpChangeGroups lets y
ou add or remove groups you're interested in.
Added: New platform! Welcome Windows 8 RT and Windows Phone 8. Both are "pre
view" releases but based on the stable DotNet basis we have.
Note: The Windows Phone 8 SDK does not yet have a LoadBalancing demo but the
API is available (Windows Phone 8 is separate from the still existing Windows P
hone 7.1 SDK).
Added: Another new platform: Playstation Mobile! This is Sony's SDK for mobi
le platforms. Find out more about it:
Added: Silverlight 4 SDK is back. Now with LoadBalancing API (the demo imple
mentation is not finished but the basic "logic" is running).
Fixed: Windows Phone 7 and Silverlight TCP error handling while connecting t
o the server. This should fix issues with failing connects due to missing policy
Internal: Windows Phone 7 and Silverlight TCP connections now set their stat

e a bit differently (this doesn't affect the workflow though).

Internal: Http implementation now checks if a Proxy was set deliberately. Ch
eck is: (WebRequest.DefaultWebProxy as WebProxy != null).
Internal: DispatchIncomingCommands() now avoids copying lists when checking
for commands that need a repeat.
Internal: SendOutgoingCommands() now re-uses a buffer to create UDP packages
in before sending. This should save a lot of memory allocation.
LoadBalancing API:
Added: New demo "Particle". You will notice it's similar to the "Realtime De
mo" but LoadBalancing- and Cloud-compatible and it makes better use of the defau
lt features. Check out Particle "Logic".
Added: LoadBalancingClient.DisconnectedCause to track certain disconnect cau
ses (no matter if the connection or an operation caused the disconnect).
Added: DisconnectCause enum to enumerate those disconnection causes.
Changed: LoadBalancing OnOperationResponse() and OnStatusChanged() to track
most disconnect reasons (in DisconnectedCause).
Removed: LoadBalancing Connect() variants that essentially were duplicates o
f others.
Changed: LoadBalancingClient debug output now goes to: Debug.WriteLine (whic
h is available in debugger, while Console is not always).
Changed: CacheProperties method is now virtual for Room and Player. This all
ows you to override it and use this as callback to update props.
Added: Player.Tag to store arbitrary (game) data with the Player. Put in (e.
g.) a player's representation/avatar or similar.
Added: ErrorCode constants MaxCcuReached and InvalidRegion. These are import
ant for the Photon Cloud.
Added: Handling for DisconnectedByUserLimit. This is a status of OnStatusCha
nged when a Photon Server License's CCU limit is reached. This no longer will tr
y to connect to a Game Server (where it gets rejected, too).
Changed: Debug output of loadBalancingClient now goes to Debug.WriteLine (wh
ich is available in debugger).
Changed: API now uses a factory method to create Room instances (this makes
it possible to extend the Room class and instantiate the new class instead).
Changed: The Player constructor now has an "actorProperties" parameter and w
ill cache the provided properties. This makes sure actor-props are available loc
Windows Phone 8:
Added: Demo for Cloud / LoadBalancing. The Particle Demo only has a special
WP8 GUI and links it's logic from a separate project (read: folder).
Windows 8 RT:
Added: Demo "Phong", which is a simplified, basic multiplayer game. It's foc
us is to show how to sync data, not to make it super smooth and error free. Let
us know any issues but bear with us as it isn't fully featured.
*** Version (26.09.2012 - rev1731)
Fixed: Internals of method DispatchIncomingCommands() for UDP. In some cases
this removed commands from a dictionary inside a foreach loop (which causes an
Exception due to changing the dictionary)
Added: Support for Dictionary<,>[]. This is not a very lean way to send data
(especially when using <object,object>) but if needed, it now works
Changed: Replaced several foreach loops with for loops (it doesn't change us
age but in Unity exports to iOS, foreach uses more memory than for)
Added: Doc for public methods in Protocol class (they are useful to quickly
write values into an existing byte-array)
Fixed: Unity UDP send code: iOS 5 devices will kill a socket when the power
button is pressed (screen locked). This case was not detectable by checking sock
Added: Unity UDP send code: Now tries to open another socket to refresh/keep
the connection. This is affected by timeouts still, of course (as are all conne

Internal: locked usage of UDP / enet channels

*** Version (26.07.2012 - rev1683)
Changed: The DotNet client libraries are now Thread safe! You could start a
background Thread to keep calling SendOutgoingCommands in intervals and still ca
ll it from a game loop, too
Changed: Due to the thread safety, the demos no longer use excessive locks.
This is now solved by the lib, more streamlined and hidden. One Thread is used i
nstead of Timers (which could fire concurrently if execution was longer then the
ir interval)
Changed: Moved the enable/disable property fro NetworkSimulationSettings to
PhotonPeer.IsSimulationEnabled (this should now be thread safe)
Changed: NetworkSimulation will create and keep one thread when you first en
able it in a (debug) client. Disabling it, will execute any delayed action immed
iately (in IsSimulationEnabled!) and pause the simulation thread
Changed: All demos are updated. We assigned new event codes (starting at 0,
like any developer's code should) and extended the comments. Check them out
Changed: All Loadbalancing demos are now using the same DemoBasisCode linked
in, so it can be changed in one position. Where needed an extension is made
Updated: comments / documentation for LoadBalancing API, Lite API and basic
Photon API (basically anything public)
Changed: SupportClass.NumberToByteArray is now obsolete. It can be replaced
with Protocol.Serialize() easily and that is performing better
Fixed: Windows Phone UDP socket was sending a full package of zeros on conne
ct. It didn't break anything but is not needed, of course.
Fixed: SupportClass.StripKeysWithNullValues method was prone to throw an exc
LoadBalancing API:
Changed: LoadBalancingClient.OpLeaveRoom() skips execution when the room is
null or the server is not GameServer or the client is disconnecting from GS alre
Note: LoadBalancingClient.OpLeaveRoom() returns false in those cases and won
't change the state, so check return of this method
Fixed: workflow for authentication (which should be called only once per con
nection, instead of "any time we establish encryption)
*** Version (05.06.2012 - rev1569)
Fixed: Udp issue with channels and unreliable commands. Unreliable commands
of one channel were discarded, when another channel had unreliable commands, too
*** Version (04.06.2012 - rev1561)
Fixed: TCP connection issues for DotNet and Unity (Silverlight and WindowsPh
one are different)
Fixed: DotNet+Unity TCP send calls with 0 bytes to send (this was ignored by
the socket but useless anyways)
Moved: DNS resolution and socket.Connect() are now handled in the connection
thread (TCP in DotNet and Unity)
Fixed: Issue with (TCP) socket connections being closed directly while conne
cting. in this case, socket.Receive() might receive 0 bytes instead of blocking
until more bytes are available. without sending anything, the socket never updat
es its .Connected state and never throws a Exception. now we send a ping and thu
s trigger a exception
Fixed: Some documentation errors (due to changed API, etc)
Loadbalancing API:
Changed: LoadBalancingClient.OnEvent() now uses a join-event's actornumber-l
ist to create Player instances for anyone who wasn't created as Player before
Fixed: LoadBalancingClient.OnEvent() handling for join-event does not expect
any actor/player properties anymore (which fixes a potential null-reference exc
eption when not even a name is set)

*** Version (10.05.2012 - rev1512)

Fixed: Reference to project in Windows Phone SDK
*** Version (09.05.2012 - rev1508)
Fixed: The OpJoinRandom of the LoadBalancingAPI failed to filter rooms for t
heir custom room properties. Instead, any room matched. This is fixed now.
Added: New Demo for Windows Phone: Cloud Basics
Changed: The loadbalancing / cloud-based demos are refactored to share a sim
ilar codebase
*** Version (07.05.2012 - rev1489)
Note: This is a "stable" release, containing only a few updates. The bulk of
changes are in the "odd" numbered releases. Read those updates carefully.
*** Version
Changed: adopted the even/odd version numbering system. versions ending on a
odd number = intermediate/in-development version, even number = released (that
makes a intermediate)
Fixed: When NetworkSimulation is disabled, all remaining packages are sent/r
eceived immediately (ignoring the former delays)
Note: NetworkSimulation should be working nicely now. Be aware that sudden,
additional lag might (!) lead to a disconnect. Play with the settings to find ou
t which ones work for you
Changed: Protocol class now has a few methods to (effectively) serialize som
e datatypes to arrays (and into existing arrays)
Removed: Surplus public methods from Protocol that were "type-named" like Se
rializeFloat. The functionality is in still with overloaded methods
Added: count of packages (requests) outgoing if TrafficStatsEnabled
Demo Realtime:
Changed: The commandline arguments are now server:port, protocol (udp,tcp,ht
tp), reliable sending, interval dispatch, interval send, interval move. Example:
localhost:5055 Udp false 15 25 15
Changed: Demo Realtime: If the commandline sets an unknown protocol, the cli
ent shows a message and closes gracefully
Changed: Demo Realtime: The demo now starts in the grid view (showing someth
ing). Local player and player list are created with the Game instance. Player st
artpoint is randomized.
Loadbalancing API:
Renamed: LoadBalancingClient.lbPeer to .loadBalancingPeer
Fixed: LocalPlayer.SetCustomProperties() usage
Added: Service() method, which calls the LoadBalancingClient's Service simpl
Changed: LoadBalancingClient is no longer extending LoadBalancingPeer but in
stead using one
Changed: the many overloads of Operations are gone in LoadBalancingPeer to s
treamline the api
Changed: ActorProperties are no longer set via JoinRoom, JoinRandomRoom or C
reateRoom. instead, set the properties in the LocalPlayer and let the LoadBalanc
ingClient send and sync them where necessary
Fixed: MasterClientId is now 0 when there are no more players in the room (i
t was set to int.max before)
Changed: all DispatchIncomingCommands now use a while loop to dispatch the A
ctionQueue (in the hope this is the fastest way to do it)
Changed: DispatchIncomingCommands now looks for the received unreliable comm
and with lowest unreliable seqNr to dispatch this
Changed: DispatchIncomingCommands discards commands if the reliable OR unrel
iable sequence is beyond the command's sequences
Changed: DispatchIncomingCommands now truncates the incoming unreliable comm
ands to limitOfUnreliableCommands (if that's > 0)

Changed: the next reliable command to dispatch is now fetched with Dictionar
y.TryGetValue() (for being faster)
Changed: no longer using BinaryReader streams anywhere (this should improve
speed and reduce mem usage)
Changed: PeerBase accordingly
Changed: Unit test MyType de/serialization now supports null-references (as
1 byte being 0)
Changed: Protocol.SerializeOperationRequest is now used in the same way, no
matter if request is "top level" or inside some other datatype
Changed: the peer bases accordingly to use only one SerializeMemStream and l
ock it
Changed: how encryption fits in to the new serialization (it is a special ca
se, as only the operation bytes get encrypted)
Added: Protocol.SerializeParameterTable() as requests, events and responses
all use the same way to write their parameters
Changed: SerializeOperationToMessage parameter order
Changed: Order of Protocol methods to make more sense (from byte to more com
plex types for serialization)
New: PhotonDotNet library prototype for windows 8 metro
*** Version (13.04.2012 - rev1430)
Known issues: The Network Simulation is currently not guaranteed to work pro
perly. Please bear with us.
Note: the following change might be a breaking one:
Changed: When dispatching a server's disconnect-command, the state is change
d to ConnectionStateValue.Disconnecting BEFORE any callback due to state change
is called. This should disallow game-code from calling any operations immediatel
Changed: Many internals. This should result in better performance
Changed: Service() now calls SendOutgoingCommands() until send-queues are em
pty. This might take more time but gets important commands out. If you need more
control, Service() can be replaced with DispatchIncomingCommands and SendOutgoi
Added: null check to GetEndpoint() to avoid issues when the host address is
Fixed: queueIncomingCommand() debug out message when a command is being rece
ived AND in in-queue (the list it accesses is now a dict)
Added: new "vital" stats to TrafficStats
Added: LongestOpResponseCallback and LongestOpResponseCallbackOpCode (opcode
and time of longest callback)
Added: LongestEventCallback and LongestEventCallbackCode (event code and tim
e of longest callback)
Added: LongestDeltaBetweenDispatching and LongestDeltaBetweenSending to dete
ct "gaps" between subsequent calls of those
Added: DispatchCalls and SendOutgoingCommandsCalls to measure average call-r
Fixed: PeerBase.TrafficStatsEnabledTime now checks if a stopwatch is set, el
se it returns 0
Fixed: TrafficStatsReset() now works as intended (starting a new stopwatch,
Changed: name of variable timeLastReceive. is now: timeLastAckReceive (bette
r fit with what it does)
Internal: queueOutgoingReliableCommand() to use a lock on the channel it acc
Internal: SerializeOperationRequest() now locks the MemoryStream while using
it (avoids threading-issues with calling OPs)
Internal: SendUdpPackage() now checks if socket is obsolete (and disconnecte
d for a reason) or not. only if not, a error is logged
Internal: EnetChannel now uses Dictionary and Queue for commands (should be

faster to access)
Internal: simplified access methods in EnetChannel according to changes
Internal: outgoingAcknowledgementsList is now a Queue
Internal: receiveIncomingCommands() no longer has a local variable sentTime.
instead using this.serverSentTime directly
Internal: UDP sending is now done with a synchronous socket call (profiling
told us: this is cheaper)
Internal: re-using the socket arguments for receiving packages (saves some b
uffer allocation)
Internal: socket to non-blocking (maybe not possible on all devices)
Removed: initial-HTTP-protocol support (HTTP support not public yet)
Added: support for encryption with HTTP protocol
*** Version
- Added: Rooms now have a "well known" property to list the custom properties th
at should be available in the lobby. This can be set per room (but most likely m
akes sense per title/application).
- Added: LoadBalancingClient.OpCreateRoom() has a new parameter "propsListedInLo
bby" and Room.PropsListedInLobby is available to check this list (if needed at a
- Added: GameProperties.PropsListedInLobby as "well known property" key
- Changed: LoadBalancingPeer.OpCreateRoom now sets ParameterCode.CleanupCacheOnL
eave to true by default. This makes the server clean a player's event cache on l
- Added: SupportClass.DictionaryToString() will now print values of string[] and
optionally leaves out type information.
- Note: didn't get it's own SDK, so read that version's changes, too
*** Version
- Added: PhotonPeer.TrafficStatsElapsedMs, which gives you the milliseconds that
the traffic stats are enabled. This internally uses a stopwatch (for now) which
might not be available on all platforms. Please report if this new SDK causes i
- Added: PhotonPeer.TrafficStatsReset() to reset the traffic stats and the timer
. This could be useful to get stats of "in game" versus "out of game". Note: Loa
dbalancing includes frequent server-switching and each disconnect/reconnect caus
es a reset.
- Changed: In LoadBalancingPeer EventCode.SetProperties is obsolete and replaced
with EventCode.PropertiesChanged. Please switch to new constant.
- Added: Support in LoadBalancingAPI for Player.IsMasterClient. For this, the Pl
ayers now get a RoomReference set (when added). The active player with the lowes
t ID is the master (per room).
- Added: Room.MasterClientId, which is updated when new players are added or the
current master is removed.
- Added: SupportClass.DictionaryToString() has an overload which doesn't "print"
the Type per key/value.
- Added: Loadbalancing API overload for OpJoinRandomRoom(...) taking additional
parameter 'playerProperties'
- Added: Loadbalancing API CacheProperties() and Room.GetPlayer() are public now
- Added: LoadBalancingClient will now handle ExceptionOnConnect and keep clients
from re-connecting if establishing a connection fails
- Note: The following changes affect only HTTP, which is an upcoming option for
connections. So far, the public server SDKs don't support this. Feel free to con
tact us about it.
- Added: setter for PhotonPeer.ServerAddress to allow setting a http url (even w
hile connected)
- Added: PhotonPeer.HttpUrlParameters setting parameters to be added to end of u
rl (must begin with '&')
- Added: HttpUrlParameters to PeerBase
- Added: HttpUrlParameters is now attached to the end of a URL in http usecase

- Added: "Http2" support to Unity library

- Internal: method HttpBase.ConnectAsync is no longer needed and Request() is no
w directly passed to thread
*** Version
- Added: Loadbalancing (Cloud) Features
- Added: Project with the Loadbalancing sourcecode for DotNet, WindowsPhone and
Unity3d (usable without PUN)
- Added: Initial, simple Loadbalancing demos for each platform (will update and
extend those)
- Note: The API of the client libraries didn't change. The new features were add
ed on top of the known API
- Added: VS2010 solutions for DotNet and Windows Phone SDKs containing the demos
and APIs in the package
- Added: readme.txt with initial help to setup the Cloud/Loadbalancing demos
- Added: default appId for Loadblanacing demos: "<insert your appid here>"
*** Version
- Added: When UDP StartConnection (internal method) fails, callbacks to OnStatus
Changed(StatusCode.Disconnect) are now done additionally to the SecurityExceptio
nOnConnect and ExceptionOnConnect calls. This happens direcly inside PhotonPeer.
- Changed: When Unity UDP implementation fails to connect due to missing DNS res
olution, it now also calls OnStatusChanged(StatusCode.ExceptionOnConnect)
- Removed: StatusCode.Exception_Connect value (obsolete, replaced by ExceptionOn
Connect, same value)
- Fixed: Http connections (DotNet & Unity) now skip results while in disconnecte
d state
- Fixed: Http connections (DotNet & Unity) now ignore results after a disconnect
and reconnect was done (this applies only to HttpBase, not HttpBase2)
- Fixed: misleading debug out (pointing to WindowsPhone while the class is now i
n general use)
- Changed: DotNet UDP connection now only logs socket errors if the connection i
sn't obsolete (disconnected) already
*** Version
- Fixed: issue with HTTP connections and EstablishEncryption()
- Changed: ActionQueue is now a Queue<MyAction>, allowing Dequeue in a while loo
p instead of foreach(i in list) and clear()
- Changed: Unity HttpBase DispatchIncomingCommands() to make use of the queue
- Fixed: init byte[] length (internal. did not have consequences)
- Fixed: LitePeer OpRaiseEvent() was sending encrypted
- Internal: ContainsUnreliableSequenceNumber() check if reliable list needed sor
- Fixed: Unity/Silverlight bug with encryption. Their implementation of BigInteg
er.GetBytes() failed when the 2nd, 3rd or 4th of the first 4 bytes was 0 but the
previous wasnt. This led to incompatible secrets.
- Changed: TCP socket sending debug output now checks debuglevel (when send is s
kipped, cause the sender is obsolete already)
- Added: caching option RemoveFromRoomCacheForActorsLeft = 7
- Internal: Added another http-based communication protocol. Please note: The fi
tting server's are not yet publicly released. This does not affect UDP or TCP pr
*** Version
- Fixed: Udp fragment reassembly in case fragments are received out of order and
incoming queue was not yet sorted
- Fixed: Handling of incoming reliable commands (udp) which were skipped in some
cases, if not received in order
- Fixed: Network simulation issue which caused lost incoming commands

- Fixed: Demo Realtime. protocol is now again Udp, fitting the default server ad
dress "localhost:5055" (make sure to build the demo with your server's address i
f Photon is not on the same machine)
*** Version
- Changed: Udp socket usage for Unity 3d lib. Both threads (send (in game loop)
and receive (separate)) now have minimal locks while using the socket
- Fixed: SendOutgoingCommands now returns true if anything didn't make it into t
he outgoing UDP package
- Internal: TCP connections also skip network simulation when it's turned off
*** Version
- Fixed: SendOutgoingCommands now returns true if commands are remaining in outg
oing queues (UDP only sends one package per call, TCP will send anything outgoin
- Added: New "RoomCache" for Events. The EventCaching enum allows you to use it.
Events in this cache will keep the order in which they arrived in the server. A
filter makes deleting them very flexible.
- Internal: Ability to make lib send only ACKs and nothing else. This is probabl
y a temp solution as it might be better to make sending and calling ops complete
ly thread safe.
- Internal: PhotonPeer.IsSendingOnlyAcks, which is locked with the sending (not
changing while sending). This makes SendOutgoingCommands() thread safe, which is
good if you need a separate thread to keep connection. You could call operation
s while sending.
- Internal: Unity3d's connection now also syncs socket usage
*** Version
- Fixed: ObjectDisposedException in DotNet UDP workflow. This was caused by disc
onnecting while incoming data was processed (and before the next datagram was ac
- Added: PhotonPeer.LimitOfUnreliableCommands property. This helps you skip pote
ntially "outdated" unreliable commands (events), which helps if you couldn't dis
patch for a while
- Internal: Minor performance improvements. Example: The check if network simula
tion is turned on is done earlier in the workflow, which avoids a bit of overhea
*** Version
- Fixed: Tcp connections have been throwing ArgumentNullException in DispatchInc
omgingCommands() if they were not connected yet
- Internal: Adjusted Http client to server rev2360
*** Version RC2
- Internal: Communication with HTTP server is WIP (Work In Progress - not a publ
icly available feature)
*** Version
- Fixed: OpRaiseEvent overload with EventCaching and ReceiverGroup parameters wa
s not sending the customEventContent as expected. This was always null.
- Fixed: Time fetching case where no time was accepted. Servertime is now accept
ed, if the fetch-time-command was less or equal as the current roundtrip time. A
voids issues if rtt is exceptionally low immediately.
- Internal: When using multiple channels, dispatching incoming commands now will
continue with the next channel, if one doesn't yet have the next reliable comma
nd (reliable sequence of one channel does not affect others)
- Internal: Changed protocol for TCP and message headers. This will support bigg
er message sizes. Also changed debug out related to unknown headers.
- Internal: Changed handling of TCP receive-callbacks for unfinished messages in
Silverlight and WP. This should fix handling of very big data that's received i

n multiple "chunks"
- Internal: Http messages are now deserialized the same way that content in tcp
or udp is handled
*** Version RC1
- Fixed: Packaging of SDK now includes all files in demo folders, except a list
of ignored file-endings (xaml and jpg files were missing in previous Silverlight
and WindowsPhone SDKs)
*** Version RC1
- Changed: Filenames! Now include a '3' for Photon v3. Update your references! A
lso, Silverlight libraries now use "Silverlight" in the filename (was: SL)
- Changed: Versioning. A dll's version has now 4 digits. The first 2 match Major
and Minor number of the Server SDK. The latter 2 are Release and Build respecti
- Changed: Silverlight DataTypes (like Hashtable) are now in namespace ExitGames
.Client.Photon. This is easier to include (as that namespace is in "using" in mo
st cases)
*** Version 6.4.5
- Changed: Parameters for OpCustom are now of type Dictionary<byte, object>, mak
ing sure that only byte-codes are used for parameters
- Changed: Most IPhotonPeer names (to match those in server code): EventAction > OnEvent, OperationResult -> OnOperationResponse, PeerStatusCallback -> OnStatu
- Added: SupportClass.DictionaryToString(), which converts the content to string
(includes support for Hashtables)
- Moved: Definitions of Lite and Lite Lobby specific codes for Parameters, opera
tions and events are now in LitePeer. Will be available as source and could be r
- Changed: Usage of codes in Lite and Lite Lobby. Now pre-defined codes are star
ting at 255 and go down. Your events, operations and operation-parameters can no
w start at 0 and go up without clashing with pre-defined ones
- Changed: Constants that are non-exclusive (like event codes and OpKeys, which
can be extended) are no longer "defined" as enums but as class of const byte val
ues. Less casting but also less convenient "name" representation in debug output
- Added: LiteEventKey.CustomContent as key to access the content you sent via Op
RaiseEvent ("Data" seems a bit misleading but is also available)
- Changed: Namespace of LitePeer to ExitGames.Client.Photon.Lite (the Lite-speci
fic class is still compiled into the library for convenience but can be ignored
quite easily this way)
- Added: Property MaximumTransferUnit. The default is 1200 bytes. Usually this i
s ok. In few cases, it might make sense to lower this value to ~520, which is co
mmonly assumed the minimum MTU. Don't change this, if you don't know why.
- Added: New classes to wrap up op-requests (OperationRequest), op-results (Oper
ationResponse) and events (EventData). Those new classes are now used in callbac
k methods OnEvent and OnOperationResponse
- Changed: by using the new classes (note above), the client is a bit more like
the server in its naming. We didn't want to change every last bit though.
- Internal: Changed protocol (to 1.6) so that it does not require any parameter
codes internally. Any application can now define any operation, parameter and ev
ent codes it wants to.
- Changed: Encryption is now triggered by you and resolved by the library. You d
on't have to look out for the result of EstablishEncryption and use it. Instead:
wait for OnPeerStateChanged call with either EncryptionEstablished or Encryptio
- Removed: InvocationId. This concept was very rarely used but confusing. It's e
asy to implement, if needed. If you don't know what this means: Nevermind.
- Changed: Operation calls now return bool: if they could be enqueued or not. If
enqueued (cause you are connected and the data was serializable), then SendOutg

oingCommands will send those operations (as before).

- Added: Support to de/serialize Dictionary<T1,T2>. If the types are more specif
ic than object, the serialization writes the type-code only once (lean byte usag
e in protocol)
- Added: Support to de/serialize null. Enables you to send a null value, e.g. in
a Hashtable
- Added: ReceiverGroup enum to select a range of players that get an event via O
peration Raise Event
- Added: Event Caching. Any event sent via RaiseEvent can now be buffered on the
server side and is "repeated" when a new player is joining a room. This is simi
lar to Properties but lets you categorize your info better and works just like r
egular events, too.
- Added: EventCaching enum to select if an event is to be cached and how it's ca
ched: either "not at all" (default), replacing anything cached so far (fast) or
"merge" (which will add new and replace old keys with new values). Optionally, a
event can be raise with option "remove".
- Added: new overload of OpRaiseEvent() with the two new parameters noted above
- Added: Support for custom de/serializer methods. By writing 2 methods to conve
rt a object into a byte-array (and back from that), Photon now supports any cust
om object type (standard datatypes are still supported out of the box)
- Added: PhotonPeer.RegisterType() to register serializer and deserialize method
s for a certain type. Per object, a length and one byte 'type code' are added to
the serialized data
- Added: Support for non-strict object[]. Unlike strictly-typed array, here each
element will carry its own type.
- Note: If you want to use the new Custom Types or the object[], you have to upd
ate your server! Older Servers don't support the new features. As long as you do
n't use these features, the library is compatible with previous servers.
- Added: ByteCountCurrentDispatch and ByteCountLastOperation properties to Photo
nPeer (the ancestor of LiteGame, etc). A game can now access the size of operati
on-results and events as well as operation-call size.
- Added: Traffic statistic set: PhotonPeer.TrafficStatsGameLevel as "high level"
game-related traffic statistic. Counts bytes used by operations, their results
and events. This includes overhead for these types of messages, but excludes con
nection-related overhead
- Added: Traffic statistic set: PhotonPeer.TrafficStatsIncoming and PhotonPeer.T
rafficStatsOutgoing as low level statistics of the traffic
- Added: PhotonPeer.TrafficStatsEnabled which enables two sets of traffic statis
tics. By default, statistics are turned off.
- Added: Classes TrafficStats and TrafficStatsGameLevel for the two statistic ca
ses metioned above
- Changed: NetworkSimulation now starts a Thread when it becomes enabled and the
thread ends on simulation disable. Disable the NetworkSimulation to stop the th
read, as Disconnect does not change the simulation settings!
- Internal: Cleanup and renaming of several properties
- Internal: Each new peer increases the PeerCount but it is no longer reduced on
disconnect (it is existing still, after all)
- Internal: Udp commands will be buffered when serialized. This saves some work
when re-sending a reliable command
- Added: TCP Routing code (not in Silverlight). To be used when running Photon o
n Azure (can be ignored in regular use)
- Added: to StatusCode: TcpRouterResponseOk = 1044, TcpRouterResponseNodeIdUnkno
wn = 1045, TcpRouterResponseEndpointUnknown = 1046 and TcpRouterResponseNodeNotR
eady = 1047,
- Added: override for PhotonPeer.Connect() with node
- Internal: DotNet now reads the 2 bytes routing response, if a routing request
was made (also, not in Silverlight)
- Internal: If TConnect sent a routing request, nothing else will be sent until
2 bytes response are read.
- Internal: If the routing-response does not start with ProxyResponseMarkerByte

= 0xF1, a debug message is enqueued and TCP will disconnect

- Internal: Init request for TCP is now always enqueued instead sent directly. T
his way, it can be delayed if a routing node is selected
- Internal: TPeer EnqueueInit() and SendProxyInit() now create init and routing
request respectively
- Internal: TConnect.sendTcp() checks isRunning before it tries to send (the soc
ket might close before the NetSim does). This won't be an issue anytime, still I
NFO-level callback to DebugReturn is done.
- Removed: debug out for "send package" situation (even on ALL-level, this is mo
re or less spam)
- Internal: updated version numbers of init to 6.4.5
- Changed: SupportClass HashtableToString() returns "null" if parameter is null
- Internal: Removed SortedCommandList and CommandList classes. Replaced by List<
NCommand> and a Sort() where necessary
- Internal: EnetPeer.channels is now a Dictionary<byte, Channel> instead of a So
- Internal: the channels are initialized with channel 0xff first - this makes 0x
ff high prio in all foreach usaged
- Internal: NCommand class is now IComparable<NCommand> for usage in Sort()
*** Version 6.4.4
- Added: PhotonPeer.TimestampOfLastSocketReceive now provides the time when some
thing was received. Can be used warn players of bad communication-timing even be
fore the disconnect timeout will be happening
- Fixed: OpGetPropertiesOfActor did use the actorNrList correctly, which always
got you all properties of all players
*** Version 6.4.3
- Changed: A udp connection timeout in Unity will now end the socket-handling th
read correctly
- Changed: The thread for Network simulation is now stopped when the client disc
onnects and started on connection (instead of keeping it per peer)
- Fixed: Exceptions in network simulation, when Disconnect() was called soon aft
er Connect() but before the connection was established.
*** Version 6.4.2
- Fixed: It was possible to send PhotonPeer.FetchServerTimestamp() before being
connected properly. Now the method triggers debug output (INFO level) and the ca
llback PeerStatusCallback(StatusCode.SendError)
- Internal: Added a lock in the UDP version of SendOutgoingCommands(). It's stil
l illegal to access a peer from multiple threads but the follow-up issues this l
ock avoids are very difficult to track.
- Internal: to stay compatible with all exports of Unity, the use of System.Thre
ading.Interlocked.Exchange was replaced by simply replacing the list's reference
*** Version 6.4.1
- Changed: The Unity library now uses the WWW class for Http based requests. Res
ults are checked within DispatchIncomingCommands(). Important: Unity allows hand
ling WWW requests only on the MainThread, so dispatch must be called from this c
- Note: Photon does not support Http requests out of the box. Customers get acce
ss to a fitting server on demand
- Changed: outgoing list is now replaced on send, instead of calling remove(0) r
epeatedly (which takes longer). Internal: this uses System.Threading.Interlocked
.Exchange to switch to a new outgoing list in one step
*** Version 6.4.0
- Fixed: TCP handling of incoming data. This avoids loss of data (operation-resu

lts or events) when a lot of data is incoming.

- Changed: PeerStatusCallback() is less often called for queue-length warnings (
e.g.: StatusCode.QueueIncomingReliableWarning). Only if a queue has a multiple o
f PhotonPeer.WarningSize items.
- Changed: WarningSize is now 100 by default
- Changed: Description of PhotonPeer.WarningSize and PhotonPeer.CommandBufferSiz
e, which really is just the initial size of any buffer. The warnings are there t
o avoid situations where all heap is used up.
- Changed: Naming: StatusCode.Exception_Connect is now Obsolete and replaced wit
h StatusCode.ExceptionOnConnect
- Added: Missing summary for StatusCode.SecurityExceptionOnConnect
- Added: NetworkSimulationSet.ToString override to provide a better overview
- Added: Support for arrays of Hashtables
*** Version 6.3.1
- Fixed: Network simulation now delays incoming packages by IncomingLag and Inco
mingJitter as expected (it was using the outgoing values, too)
*** Version 6.3.0
- Added: Network simulation (lag, jitter and drop rate) to debug builds
- Added: class NetworkSimulationSet with properties to control network simulatio
- Added: NetworkSimulationSettings.NetworkSimulationSettings property to get cur
rent simulation settings
- Changed: only the first peerId of a VerifyConnect is accepted in client (avoid
s surplus peerID changes)
- Internal: added PeerBase.SendNetworkSimulated() and PeerBase.ReceiveNetworkSim
ulated() and a Thread to run delay simulation
- Updated: to Silverlight v4.0
- Added: Encryption to Silverlight library
- Internal: updated internal BigInteger class for Silverlight
- Internal: DiffieHellmanCryptoProvider in Silverlight, so it uses AesManaged in
stead of Rijndael (which is not part of Silverlight 3)
- Added: Stopwatch class to DataTypes.cs (for Silverlight only)
*** Version 6.2.0
- Added: "Demo LiteLobby Chatroom" to Unity SDK
- Updated: Demo Realtime in Unity client SDK. It's still compatible with the dem
o on other platforms but cleaned up and much better commented
- Updated: Documentation is now clearer on where the Lite logic is used (it runs
on Photon but is not the only application logic)
- Updated: Documentation for the enumerations in IPhotonListener. The Lite appli
cation based ones are better described and it's now clear which ones are essenti
al to the Photon client (not only in Lite)
- Updated: Documentation in several other places
- Added: StatusCode.SecurityExceptionOnConnect which is thrown if a security exc
eption keeps a socket from connecting (happens in Unity when it's missing a poli
cy file)
- Added: PhotonEventKey and PhotonOpParameterKey which contain the fixed byte ke
ys that cannot be re-assigned by applications at will (as these keys are used in
the clients and server in their respective context)
- Change: PhotonPeer.PeerState is no longer a byte but of type PhotonPeer.PeerSt
ateValue, which makes checking the state simpler. The PeerStateCallback() for st
ate changes is still called as before.
- Changed: Property PhotonPeer.PeerState. It now converts the low level Connecti
onStateValue to a PeerStateValue, which now includes a state InitializingApplica
tion. See reference for PeerStateValue.
- Changed: PeerStateValue enum is now part of the ExitGames.Client.Photon namesp
ace, making it more accessible

- Internal: NConnect in DotNet and Unity to catch security exceptions

- Internal: from using var to explicit type usage in DiffieHellmanCryptoProvider
.cs (Mono Develop friendly)
- Internal: PeerBase "PeerStateValue peerState" is now: "ConnectionStateValue pe
erConnectionState" (holding the low level connection state, nothing more)
- Internal: added PeerBase.ApplicationIsInitialized, which stores if the init co
mmand was answered by Photon (reset on connect/disconnect)
- Removed: PhotonDemoServerUrlPort and PhotonDemoServerIpPort of PhotonPeer. All
demos now use "localhost:5055" and you should run your own server.
- Added: enum ConnectionProtocol to get rid of the "useTcp" parameter in the Pho
tonPeer constructor (which was less clear than the explicit enum now in use)
- Added: overload of PhotonPeer constructor, which is still compatible with the
"useTcp" bool parameter (to avoid a breaking change for the time being)
- Added: PhotonPeer.UsedProtocol property to find out this peer's protcol
- Added: LitePeer.OpLeave() overload without the gameName parameter. That name i
s not checked in the Lite application (on the server), so it's not really needed
*** Version 6.1.0
- Added: Encryption for Unity and DotNet. Operations (and their responses) can b
e encrypted after exchanging the public keys with the server
- Added: OpExchangeKeysForEncryption(), DeriveSharedKey() and IsEncryptionAvaila
ble to PhotonPeer (and LitePeer inherits these)
- Added: OpCustom() will throw an ArgumentException if the operation should be e
ncrypted but keys are not yet exchanged (exchange keys first)
- Added: LiteOpCode.ExchangeKeysForEncryption = (byte)95
- Added: Overloaded PhotonPeer.OpCustom() with new "encrypt" parameter
- Added: property PhotonPeer.IsEncryptionAvailable is true if public-keys are ex
changed and the secret is compiled from them
- Added: Encryption demo to Realtime Demo. Press E to exchange keys and R to tog
gle encrypted sending for the move data (even though events are never encrypted)
- Changed: PeerBase methods: sendOperation()->EnqueueOperation(...,encrypt), upd
- Updated: the Unity client is now a Unity v3.1 project. Make sure to change the
server address before you build for iPhone (localhost:5055 won't work on the mo
- Removed: the outdated, separate iPhone demo (was: Unity v1.7 for iPhone)
- Updated: PhotonPeer documentation for Service(), DispatchIncomingCommands() an
d SendOutgoingCommands()
- Added: OpRaiseEvent() overload with parameter TargetActors. Sends optional lis
t of actors that will receive the event (if null, all *other* actors will receiv
e the event, as default)
- Internal: Added source BigInteger.cs, DiffieHellmanCryptoProvider.cs and Oakle
- Internal: PeerBase.CryptoProvider, PeerBase.ExchangeKeysForEncryption() and Pe
- Internal: EnetPeer.initPhotonPeer() and TPeer.initPhotonPeer() are setting Pee
rBase.isEncryptionAvailable = false
- Internal: De/Serialization methods (and some variables for it) are moved from
NConnect to PeerBase and renamed to: SerializeOperationToMessage() and Deseriali
- Internal: switched project to allow "unsafe" functions (used by BigInteger)
- Internal: renamed PhotonPeer.sendOperation()->EnqueueOperation
- Internal: changed assembly version to 6.1.0 and "client version" in init-byteblock to 6,1,0
- Internal: moved protocol handling to EnetPeer and TPeer classes (where encrypt
ion is added)
- Internal: moved InitBlock to (shared) PeerBase (same for UDP/TCP)
- Internal: serialization is now done by Protocol.SerializeOpParameters(), which

excludes the message header. this makes encryption simpler

*** Version 6.0.0
- Changed: This library requires Photon v2.2.0 and up! (in other words: the libr
aries are not compatible with older Photon servers, due to servertime changes)
- Added: Support for arrays in arrays. Any serializable datatype can now be used
in nested arrays. Even arrays of Hashtables are possible.
- Added: Realtime Demo optional command line arguments for game config. set all
or none: serverAddress, useTcp (true/false), useReliable (true/false), int inter
valDispatch, intervalSend (ms), intervalMove (ms)
- Note: Realtime Demo commandline might look like this: start demo-realtime.exe
localhost:5055 false true 5 25 100
- Changed: renamed GetLocalMsTimestamp property to LocalMsTimestampDelegate (it
does not have a getter, despite the old name's implication)
- Added: PhotonPeer.LocalTimeInMilliSeconds property to use the timestamp delega
te to get the current client milliseconds (by default this is Environment.TickCo
- Changed: UDP: The default value for PhotonPeer.RoundTripTime (300ms, used befo
re connecting) is now replaced with the turnaround time of connect. This should
lead to accurate RTT values much sooner
- Changed: PhotonPeer.ServerTimeInMilliSeconds is no longer updated all the time
. Instead it's fetched soon after connect (when initialization won't affect roun
trips anymore) and extrapolated. It should be better to be off by a constant val
ue than by a changing value
- Changed: PhotonPeer.ServerTimeInMilliSeconds now returns 0 until the server's
timestamp is fetched. Updated the documentation with some internals for this.
- Added: PhotonPeer.FetchServerTimestamp() to send the time fetch command (this
is done automatically as well. this method is here for completeness)
- Fixed: roundtrip time calculation is no longer affected by long intervals betw
een Service() or DispatchIncomingCommands() calls (bug of v5.9.0, caused by inte
rnal action queues)
- Added: internally for UDP, we use a new command to fetch the timestamp which m
inimizes the latency for that roundtrip. this one is excluded in roundtrip time
- Changed: internal: ACKs by the server are again directly executed (other comma
nds which are put into the action queue and dispatched)
- Fixed: Peers with TCP as protocol will no longer try to disconnect while not b
eing connected (does not do anything of disconnected or disconnecting)
- Changed: Peers with TCP as protocol will clear the outgoing queue when disconn
ect() is called (while connected. see fix above)
- Updated: Silverlight Realtime Demo slightly
- Added: PhotonPeer.Listener property to give subclasses access to the IPhotonPe
erListener (set in constructor). Can be useful to call Listener.DebugReturn()
- Added: LitePeer-Source.cs to demo-realtime. This is the source of a LitePeer a
nd could be used as sample to create custom operations on the client side
*** Version 5.9.0
- Release: of changes in 5.7.6 and 5.7.5
*** Version 5.7.6
- Fixed: a debug output line for TCP connections which did not heed the debug-le
- Changed: PhotonPeer uses less locking internally and will handle incoming data
in the game thread (inside DispatchIncomingCommands() or Service()).
- Changed: Internally, all commands are put into a (locked) queue which is proce
ssed within DispatchIncomingCommands(). Your dispatch interval affects local lag
but not the PhotonPeer.RoundTripTime value.
- Note: Don't use a peer from multiple threads! It's not thread safe. All callba
cks to IPhotonPeerListener methods are happening in your game thread (again: ins
ide DispatchIncomingCommands()).

- Changed: removed locks inside the callbacks (according to above change).

- Changed: DNS resolution is now done in Connect() unless you provide a valid IP
address (if IPAddress.Parse(address) is successful, the IP is used directly).
- Fixed: PhotonPeer.Connect() should fail if the IP is unknown or unavailable. E
xception: using a localhost might succeed but fail when we try to receive anythi
- Updated: Game.cs now initialized the timing intervals. This avoids issues if t
he client system is having a negative TickCount.
- Added: ServerAddress property to PhotonPeer, which might help while developing
with several servers and peers.
- Changed: This version includes GetLocalMsTimestampDelegate and the PhotonPeer
property GetLocalMsTimestamp to set the delegate for local timestamp.
*** Version 5.7.5
- Changed: All precompiled demos now connect to localhost! From now on, you need
to run Photon before trying any of the demos (as we don't guarantee that udp.ex is online anyways)
- Changed: OpCustom() now accepts null as parameter Hashtable, which is a shortc
ut to "no parameters" for simple operations (an empty hashtable is sent though,
it does not reduce bandwidth)
- Added: new feature: UDP timeout definition by setting PhotonPeer.DisconnectTim
eout (individual per command, set in milliseconds, checked when a command is rep
- Renamed: enum ReturnCode to StatusCode. The StatusCode values are only used fo
r status callbacks (not as operation results)
- Changed: parameter type of PeerStatusCallback() from int to StatusCode (to dif
ferentiate them from operation ReturnCodes, which are customizable)
- Removed: StatusCode.Ok (as it was actually an Operation ReturnCode)
- Added: new StatusCallback value: StatusCode.SendError. Used for sending error
cases: "not connected" and "channel not available"
- Changed: sendOperation() (Udp and Tcp) does not throw an exception while disco
nnected or for wrong channel (using StatusCode.SendError instead)
- Changed: callback DebugReturn() now has the additional parameter (DebugLevel)l
evel, analog to logging
- Changed: UDP connection is disconnected when a read exception happens (before
we tried to read despite this until a timeout ended it)
- Changed: EnetPeer.Disconnect() now ignores calls when peer is disconnected or
disconnecting already
- Fixed: TCP code tried to detect socket issues by checking for IOExceptions but
now checks SocketException instead
- Changed: internal threading: Callbacks due to incoming packages and commands a
re now queued and triggered by dispatch (in game loop)
- Changed: dispatch of action-queue as added to DispatchIncomingCommands (in Ene
tPeer and TPeer)
- Changed: internally, there is no locking for outgoing reliable and unreliable
command lists anymore
- Changed: Realtime Demo timer usage to avoid nullref on form-close
- Changed: Realtime Demo propety isReliable is now in the Player class
- Changed: Game.cs and Player.cs for all realtime demos. There is now something
like a gameloop (Update()) which must be called regularly and makes (pretty) sur
e just one thread accesses the peer
- Changed: all realtime demos to use the new Update() method and use more simila
r Game and Player classes (cleanup for less differences)
- Fixed: RoundtripTimeVariance is now also reset on connect / init, so the resen
d-timing of reliable udp does not suffer when a peer connects after a disconnect
- Fixed: typo in ExitGames.Client.Photon.StatusCode.QueueIncomingUnreliableWarni
ng (was QueueIncomingUneliableWarning)
*** Version 5.7.4 RC3
- Changed: Unity3D lib again has it's own UDP handling (the DotNet one causes br

owser crashes on web-player exit)

*** Version 5.7.3 RC3
- Changed: Unity3D lib is now identical to DotNet lib (Unity iPhone is compatibl
e with DotNet 2.0 now and this got tested)
- Fixed: DNS resolution (did not work for "localhost", which gave two results
(IPv4 and IPv6), mixing up things
*** Version 5.7.2 RC3
- Changed: Unity3D lib: the receive thread will now receive until no data is ava
ilable, then sleep 5ms and check again
- Changed: serverTime is now a signed int (as on server) and adds averaged rount
ripTime/2 when it gets an update
- Changed: ServerTimeInMilliSeconds doc (more concrete, explains how server time
- Added: support for serverTime, RountripTime and RoundtripTimeVariance when usi
ng TCP (Silverlight does not allow UDP)
- Added: Silverlight supports either URL:Port and IP:Port as server url string
*** Version 5.7.1 RC2
- Added: DotNet "Lobby Demo" which uses the "LiteLobby" application of the serve
r SDK to show running games and their player-count
- Changed: the realtime demos to use the more similar Game and Player classes
*** Version 5.7.0 RC1
- Added: documentation: project for Silverlight Hashtable and ArrayList substitu
- Changed: RealtimeDemo uses same classes Game and Player for Unity3 + Silverlig
- Changed: Silverlight: Hashtable and ArrayList are now a separate project / lib
- Internal: Silverlight: listener interfaces (Photon and Neutron) now conditiona
lly use ExitGames.Client datatypes from lib
- Changed: Photon: connect callback is now deferred to on-init-response (instead
of enet-connect) which ensures "no ops before init"
- Changed: Unity Realtime demo: using game and player classes merged over from s
ilverlight and re-wrote sample code to display players
- Internal: photon projects now have a pre-compile setting "Photon"
- Changed: SupportClass Namespace is now compiling into either ExitGames.Client
.Photon or .Neutron (to avoid ambiguation)
- Added: LitePeer as Lite Application specific peer (with OpJoin and the rest)
- Changed: demos accordingly
- Changed: case of PhotonPeer methods to first-letter-is-uppercase (as usual in
- Removed: nNet-prefix (Connect and Disconnect are self-explanatory)
- Renamed: PropertyTypes are now LitePropertyTypes (as they belong to the Lite a
- Changed: Peer state constants with PS_* converted into enum "PeerStateValue"
- Added: PhotonDemoServerUrlPort and PhotonDemoServerIpPort
- Renamed: NPeer to PhotonPeer
- Renamed: PhotonPeerListener to IPhotonListener (class and file)
- Changed: namespace from Com.ExitGames to ExitGames and ExitGames.Client, ExitG
ames.Client.Photon and ExitGames.Client.Neutron
- Removed: QueueOutgoingUnreliableError, QueueOutgoingAcksError, QueueIncomingRe
liableError, QueueIncomingUneliableError, QueueSentError (no errors, only warnin
- Removed: error "report" when TCP incoming queue getts fuller
- Internal: updates Neutron part to run with Protocol.cs de/serialization (added
a serializeParametersNeutron() as there are multiple differences to UDP part)
- Changed: projects and scripts to build documentation xml in debug builds

- Renamed: demo-photon-SL to demo-realtime-SL (according to other demo realtime

- Changed: many classes and properties are now internal. e.g. Protocol, EnetChan
nel, EnetPeer (and inner classes), TPeer, SuppportClass.ReadInput()
- Updated: AssemblyInfo.cs for photon dotnet and silverlight
- Internal: projects to have precompile-flags also in release builds
- Updated: build scripts for SDK building
- Removed: Compact Framework support
*** Version 5.6.1
- Fixed: 0 element arrays caused bugs
- Fixed: double type was cast incorrectly after being read
*** Version 5.6.0
- Added: more supported datatypes: float, double and arrays of all basic datatyp
es (no arrays of hashtable or arrays)
- Internal: changed Photon protocol internally to 1.5. (needs a server update to
Photon Server SDK 1.6.1+)!
- Changed: Channels for Photon UDP are now priorized (from low to high) getting
the lower channels out first
- Internal: switched de/serialization at several places from manual shifting to
a support function, which should provide endian-correctness (Photon Unity PPC co
- Added: Unity info about "Application.runInBackground = true;" to Unity Appendi
x in doc
- Changed: Photon return values are put into a NEW hashtable on receive. not jus
t a cleared one which was not reference-safe (no more need to deep-copy the data
of events)
- Added: Photon support for "disconnect-reason" which is sent by server in the e
net "reserved" byte
- Added: Photon ReturnCode.DisconnectByServerUserLimit and .DisconnectByServerLo
- Removed: NPeer.IncomingReliableCommands (was more or less useless)
- Added: QueuedIncomingCommands and QueuedOutgoingCommands as metric for how eff
ective send and dispatch is done
- Changed: now throwing exceptions when trying to set init-values at runtime (to
be fixed at development-time)
- Added: doc for sequencing and updated channel doc, (too) short chapter on cust
om operations, topic "opCodes: byte versus short", doc for property-related func
- Added: overloaded functions for opGetProperties*() for byte-keys
- Fixed: Realtime Demo keypress in input-fields have been used as in-game action
s, too
- Changed: Realtime Demo game-name is now that of the native samples ("play" wit
h other platform SDKs)
- Changed: Silverlight SDK has a different port in the constants NPeer.URL_RT_SE
RVER* and .IP_RT_SERVER* (as Silverlight uses TCP port 4350)
*** Version 5.4.1
- Added: missing documentation in Unity3d SDK
*** Version 5.4.0
- Change: The timespan until a sent and unacknowledged reliable command is consi
dered lost, is now calculated by
current roundTripTime + 4 * roundTripTimeVariance
The result of this calculation is doubled with every following resend.
The maximum number of retries can still be defined by calling SetSentCountAllow
- Change: Removed TimeAllowanceInt
- Change: removed surplus debug out, adjusted levels for other, output of comman

d sent-time from hex to decimal

- Added: fragmentation support: bigger data is now placed into multiple packages
and reassembled
- Internal: command-buffers are replaced with CommandList and SortedCommandList
(major change, but fully internal)
- Fixed: possibility of command buffer overflow. now everything is stored and wa
rnings are used as hint for temporary problems
- Added: property NPeer.IncomingReliableCommands, which returns the count of rel
iable commands currently queued
- Added: callback on NCommand.CT_DISCONNECT to inform the NPeerListener about a
disconnect from server (see above)
- Added: disconnect command will be sent by server in case of timeout, connectio
n-limitations or other issues
- Added: NPeer ReturnCode.DisconnectByServer is called on server-side disconnect
(see description)
- Added: call to StopConnection() on disconnect (by server)
- Added: NPeer.PeerID property to get ENet's peerID (useful while debugging)
- Internal: SupportClass.WriteIntToByteArray() to ease writing ints to byte[]
- Internal: added several values to NCommand to store fragments
- Added: support for channels. read more about this in the documentation
- Added: NPeer.ChannelCount which sets the number of channels while not connecte
d (default: 2)
- Changed: opRaiseEvent() and opCustom() now optionally have a channel parameter
- Added: Photon properties functions to NPeer (available with Photon Server SDK
v1.5.0) and doc
- Added: LiteEventKey.SetProperties = 92 for broadcasted property set
- Added: LiteOpKey.Broadcast = 13 and .Properties = 12
- Added: LiteEventKey.TargetActorNr = 10 (actorNr the properties are attached to
) and .Properties = 12 (changed properties)
*** Version 5.3.11
- Change: all bytes sent to and from server are treated as unsigned bytes (stand
ard for c#). same for byte-arrays
- Change: updated realtime demo to use int for posx,posy but still sending just
a byte-value (the field is 16x16, after all)
*** Version 5.3.10
- Change: switched from sbyte-array to byte-array in de/serialization! important
: bytes (ev-keys etc) are sbyte. arrays of bytes are unsigned (on client and ser
- Change: NeutronListener functions getShadowReturn() and HasbadwordsReturn() no
w have byte-array return values. please adjust, even if you don't use those
- Internal: changed SupportClass for Compact Framework
- Internal: getting ticks sitched from expensive "System.DateTime.Now.Ticks / 10
000" to cheap "Environment.TickCount"
- Change: Unity lib will now give more debug out if serialisation fails
*** Version 5.3.9
- Fixed: result-queue, timeouts and customOps work also fine for Unity build aga
in (were broken due to Neutron Unity webplayer compatibility changes in 5.3.8 fo
r Unity)
- Fixed: if the browser is closed and the unity webplayer immediatly can't use h
ttp anymore, Neutron now informs the application via NetworkStatusReturn()
*** Version 5.3.8
- Fixed: Neutron Unity now also works fine in webplayer -> Neutron and Photon no
w both support all platforms of Unity und Unity iPhone
- Fixed: default value for parameter encrypt of NeutronGame::RaiseEvent() now is
false like for all other RaiseEvent methods and like on all other platforms, in

stead of true, as it was before

*** Version 5.3.7
- Fixed: .Net UDP issue, where standard MTU settings caused dropped UDP packages
- Internal: refactored ACK queue to arraylist
*** Version 5.3.6
- Fixed: NPeer issue with ACKs for repeated commands. this enhances handling of
lost packages
- Changed: NPeer.opJoin() no longer needs the SID
*** Version 5.3.5
- Known issues: to use Photon on iPhone device, you do need Unity iPhone 1.0.2b1
or higher (current official release is 1.0.1, so please ask for a prerelease or
wait until next official release), but of course you can use Photon with Unity
iPhone 1.0.1 IDE
- Merged: renamed .NET 1.1 NeutronUnity3DiPhone into NeutronUnity3D to replace t
he old .NET 2.0 lib of that name, which means, that you can use the same .NET 1.
1 based lib for Unity and for Unity iPhone now, since 1.1 cpmpatibility fixes ar
e all done now
- Fixed: photon is fully compatible to .NET 1.1 now
- Internal: optimized UDP package size in Unity3D library (was sending surplus b
ytes, which were ignored)
- Fixed: NPeer.opCustom() now sends the operation given by parameter
- Changed: IP_RT_SERVER points to new server IP of
- Changed: a new NeutronSession now clears the NetworkLoss state and the sendQue
- Changed: timeout of a HTTP request to 10 seconds. it triggers
*** Version 5.3.4
- Added: prealpha Unity3DiPhone version of Neutron .NET: core lib already functi
onal, but realtime part not usable on device yet
- Internal: there are 4 different versions of Neutron.NET now:
- Full .NET: .NET 2.0 based, with asnyc realtime part
- Compact Framework: .NET 2.0 based, with threaded realtime part
- Unity3D: .NET 2.0 based, with Unity www-class based http part and threaded
realtime part
- Unity3DiPhone: .NET 1.1 based, with Unity www-class based http part and th
readed realtime part
*** Version 5.3.3
- New: ReturnCode.RC_RT_EXCEPTION_CONNECT, which covers the cases where a server
is not running
- New: NPeer can now be created with UDP or TCP (by new bool parameter)
- Change: renamed most of the constants for NPeer (in INPeerListener structs)
- Note: TCP does not offer ServerTime or RoundTripTime jet
*** Version 5.3.2
- Internal: reverted to threaded model in NConnect (as async UDP is not supporte
d by Unity3D)
*** Version 5.3.1
- New: login(), register(), customOperation() and raiseEvent() (all variants) ca
n be encrypted with additional parameter "encrypt" (overloaded function)
- New: encryption uses HTTPs as transfer, by changing the "http:" url to a "http
s:" url
- New: returnCode for failure of encrypted HTTPs requests: RC_SSL_AUTHENTICATION
_FAILED (if certificate is not found, valid or expired)
- Fixed: Realtime Demo using the older Realtime Server

*** Version 5.3.0

- New: separated libraries into "Compact Framework" (CF) and "Regular Framework"
(no name postfix)
- Change: libraries are now in "libs" folder as debug/release and in libs/Compac
tFramework debug/release
- Change: libs default URL set to EU/Test. use setServerURL() with Neutron.URL_N
EUTRON_* for other Neutron instances
- Internal: lib now uses async UDP communication now with "regular" framework
- Added: properties serverTimeInMilliSeconds, serverTimeAsTimeSpan and serverTim
eAsDateTime for getting the current server time
- Removed: serverTimeOffset is now internal only and removed from the API (was o
nly needed to calculate the servertime by yourself, before neutron could do this
for you)
- Change: debug out for realtime classes is now layered
- Change: debug level NPeer.DebugOut is now a NPeer.DebugLevel enum and will inc
lude all lower levels in output, default: DebugLevel.ERROR
- Fixed: size of realtime demo board
- Change: NPeer constructor now always throws an exception if listener is null
- Change: EventAction() parameter eventCode is now of type sbyte (was int), whic
h corresponds to type of RaiseEvent (and server-side used type)
- Internal: NPeer.opRaiseEvent() now treats eventCode as parameter of operation
RaiseEvent (as changed in latest RT server)
- Change: NPeer has its own listener (INPeerListener) and several (better named)
structs for the constants used with NPeer / realtime
- Added: LiteOpKey and LiteOpKey.ActorNumber to have a constant for the only OP
key of interest
- Change: EventAction() always returns the complete event, which contains a code
, the ActorNumber (if any given) and data from raiseEvent (see below)
- Change: in custom events, the data from opRaiseEvent() is in placed as value o
f key: LiteEventKey.EV_RT_KEY_DATA. to get the data use: Hashtable data = (Hasht
*** Version 5.2.0
- changed library filename to neutron-lib_<server>_<billing>.dll with server "te
st" and "run" (no debug out) and billing "dummy" and "none"
- removed US build of library. please use NeutronSession.SetServerUrl() and the
constants: Neutron.URL_NEUTRON_SERVER_*.
*** Version 5.1.0
- added realtime classes to DotNet library: ported NPeer (and internal: NCommand
and NConnect) classes
- added nPeerReturn() to NeutronListener interface
- added constants for realtime returnCodes (RC_RT_*): RC_RT_CONNECT, RC_RT_DISCO
- added constants for realtime eventCodes (EV_RT_*)
- added constants for Neutron servers to Neutron class: URL_NEUTRON_*
- added Reamtime Demo
- updated samples
- added test for UDP to NUnit
*** Version 5.0.1
- New: operation Spectate (including new SpectateReturn) to get events from any
game (as admin)
- New: SetServerUrl and SetCustomServerUrl now return the URL to debugReturn
- Internal: constant "DEBUG_- InternalS" to be used for intern debugging output
*** Version 5.0.0
- New: hasBadwords() as OP and return. Server side check of strings for badwords
*** Version 5.0.0 RC3

- Internal: changed constant values: EV_KEY_PROPERTIES = "Data", EV_KEY_REVISION

= "Rev"
- New: EV_KEY_CHANNELTYPE for channel-type in property-change events
- New: constants for default channels, CHANNEL_APPLICATION_LONGLIFE, CHANNEL_ACT
- Change: operations that fail due to missing moderation-rights now return RC_MO
- Change: actor-properties can no longer be broadcasted in any way - removed "br
oadcast" parameter from setActorProperties()
- Change: properties now have a revision which is increased on each change. this
way outdated updates might be skipped
- Change: parameters of GetPropertiesReturn(). property-type is replaced by chan
nel. added revision
- Change: EV_PROPERTIES_CHANGE now has a key EV_KEY_OWNERNR if it's a "player pr
operty" (the key is missing if it's a game-property)
- Internal: changed setProperties and getProperties to new operation-codes using
different parameters (with similar results)
- New: parameter "textMessage" for NeutronGame.invite() adds personal message to
invited players (in EV_INV and gameListInvitations())
- New: key EV_KEY_INFO will be added to EV_INV if "textMessage" was used in Neut
ronGame.invite() (it's not there otherwise)
- New: gameListInvitations() has new value parameter {t} to get "textMessage" fr
om NeutronGame.invite()
- New: RC_APPINSTANCE_NOT_OPEN is now used for "singleton namebased pools" where
a game is full (not able to join / instanciate)
- New: gameCreate() with invitations will fail if the chosen game-name is alread
y taken in a "singleton namebased pool"
- New: RC_APPINSTANCE_ALREADY_EXISTS for the case above
*** Version 5.0.0 RC2
- Change: gameCreateReturn() now returns RC_APPINSTANCE_NOT_OPEN (instead of RC_
AI_TOO_MANY_ACTORSESSIONS) for full games in "singleton" pools
- Change: obsolete events EV_TURN, EV_TXTMSG and EV_DATA which could be sent by
raiseEvent*() and still handled
- Change: switched Neutron URLs to "[..].neutron5.[..]" for test/run libs
- Fix: Polling (getEvents operation) again calls sendGameDataReturn() for all er
rors (as intended for v4.9.2 already)
- New: constant NeutronListener.EV_KEY_TYPE as part of event EV_BUDDNOTICE
*** Version 5.0.0 RC1
- New: RaiseEvent (all functions of this name) now has a "filter" parameter. If
filter is true, all String-typed values in an event are badword filtered
- Change: signature of NeutronGame.raiseEvent(), NeutronGame.raiseEventInChannel
(), NeutronSession.raiseEventInChannel(), NeutronSession.raiseEventForActor() st
art with: byte eventCode, Hashtable event, boolean filter
- Change: signature of NeutronSession.raiseEventForActor() is changed to "byte e
ventCode, Hashtable eventData, boolean filter, String userID, int minutesValid,
byte maxTypeCount, byte channel"
- Change: NeutronGame.doModerate() is now isModerator()
- Change: moved GpOperation.SerializeData() and GpOperation.DeserializeData() to
Neutron.SerializeData() and Neutron.DeserializeData().
- New: errorCode RC_INVALID_TARGET and RC_PARAMETER_NOT_SUPPLIED added as consta
*** Version 4.9.3
- New: Errors constants in NeutronListener: RC_FATAL_LOGIC, RC_MATCHMAKING_NOT_C
- New: for game-creation you can now reserve "spots", which are not filled up by
Neutron matchmaking. players can be invited to fill the spots, or they can be d
eblocked later on

- New: Parameter reservedSpots in NeutronSession.gameCreate()

- New: NeutronGame.setReservedSpots() to modify the number of reserved slots (to
make them available to matchmaking again, or block/reserve them)
- New: event EV_RESERVED_SPOTS will update the NeutronGame.reservedSpots value a
fter a call to NeutronGame.setReservedSpots()
- New: NeutronSession.listBannedPlayers() gives you the list of banned players f
or a known game - only usable by "admin" users
- New: NeutronSession.unbanPlayer() is a modified "kick" operation which allows
the respective user to join a certain game again - only usable by "admin" users
- New: the event invitation includes now the game's name (in the new key EV_KEY_
- New: NeutronSession.gameListPerPool() has now three options to sort the result
s: by game-name, player-count or "persistent games first"
- Removed: NeutronGame: handoverTurn(), sendData(), sendTextMsg(), getEventHisto
ry() and getEventHistoryReturn(). Obsolete events: EV_TURN, EV_TXTMSG, EV_DATA.
Session: getScorePosition()+getScorePositionReturn()
- Update: release_history.txt was updated from v4.0. All changes up to v4.0.4 ar
e added to v4.9.3
*** Version 4.9.2
- New: Players can be admins (by list of logins on server) or moderator (by bein
g the first active player of a game)
- New: Players may request and become moderator for game: NeutronSession.gameCan
Moderate(boolean), NeutronSession.canModerate, NeutronGame.doModerate() and Neut
- Change: the new value NeutronSession.canModerate will be sent with gameCreate(
) operations (if set to true)
- New: Event key NeutronListener.EV_KEY_MODERATOR to get moderator's actorNr fro
m events
- Change: EV_QUIT and EV_KICKED now carry the new key EV_KEY_MODERATOR which tel
ls all players who is the current moderator (by actorNr); this is stored into Ne
- New: Players in NeutronGame can have new state PLAYER_KICKED (player-data is u
pdated with EV_KICKED)
- New: NeutronGame.kickPlayer() (for moderators) and NeutronSession.kickPlayer()
(for admin's who are not active in the game to shutdown)
- New: NeutronSession.shutdownGame() can be used by admin-players (for others, t
his operation will fail)
- New: Namebased pools can now be defined as "singleton": only one instance per
pool and name will be created; if such a game is full players get an error inste
ad of a new game
- New: Errors constants in NeutronListener: RC_ACTORSESSION_KICKED, RC_ACTORSESS
- Change: NeutronGame.raiseEvent() accepts a "targetActorNr" which defines a sin
gle player to get the raised event; leave 0 to target "all players in game" (as
- New: NeutronGame.quitLocally() to release a NeutronGame instance locally (with
out having to quit()); used after a player was kicked or game shutdown
- Update: NeutronGame.playerGetCount() is updated to simply count all active or
inactive players (excluding quit and kicked ones)
- Internal: NeutronGame constructor reads new parameter: P_MODERATOR
- Change: Polling (getEvents operation) now calls sendGameDataReturn() for all e
re of kicked/banned errors
- Fix: Fatal server errors cause a returnCode of NeutronListener.RC_OP_SERVER ag
ain; debug test-server libs print out debug text! (during development fatal erro
rs could happen in case of not matching client/server setups)
- Change: removed (already deprecated) NeutronListener.gameListPerPoolReturn()
- Change / Internal: canModerate is sent as Byte (not bool) as in definition; Co
de: if ( canModerate ) op.addParameter(Neutron.P_MODERATOR , new Byte((byte)1));

- Add: NeutronGame.PLAYER_KICKED is now listed in JavaDoc for NeutronGame.player

- Update: JavaDoc package.html, gameCreateReturn(), gamesListReturn(), EV_DEACTI
- Added: Event EV_STATUS (50) includes a key EV_KEY_ISADMIN if the current playe
r has administrator rights; the value is (byte)1 in that case. The key does not
exist in any other case (normal users)
- Update: JavaDoc gameCreateReturn;
- New: Added constant RC_APPINSTANCE_NOT_FOUND = 137 for shutdownGameReturn()
- Fix: serializable datatypes are now completely listed in NeutronSession JavaDo
- New: Constant for property-change events: EV_PROPERTIES_CHANGE including new k
- Update: JavaDoc for properties in NeutronSession
*** Version 4.1.1
- Fix: gameListPerPool() defaults to 10 games and no offset if the values are le
ss than 1
- Fix: gamesListReturn() JavaDoc description for "listType" is now: 0 = open gam
es; 1 = invitations; 2 = pool's open games list
- Update: gameListPerPool() sends "{gn}" as values-parameter if it's null
- Update: getPropertiesReturn() gets new parameters: actorNr, userID. These are
optional and are available in certain situations only. See JavaDoc
- Update: gameListPerPoolReturn() is now deprecated and merged into gamesListRet
urn() which in turn got a "type" to identify the list-type
- New: getListBuddyIgnore() got one more value: 't'. This requests the type of r
elation to users. useful when getting lists of type "both". this is buddies and
- Change: renamed returned parameters to: count and countOnline. These values ar
e referring to the number in the returned list
- Internal: parameter P_USERID = 85; used in getProperties
- New: made methods nullpointer resistant: getListBuddyIgnore, buddySet, get/set
PlayerProperties, get/set ActorProperties, get/set GameProperties; some methods
throw exceptions in debug version
*** Version 4.1.0
- New: Properties. NeutronSession: setActorProperties(), getActorProperties(). N
eutronGame: setLocalPlayerProperties(), getPlayerProperties(), getGameProperties
(), setGameProperties()
- New: Buddylist and Ignorelist in NeutronSession: listBuddies(), listIgnored(),
getListBuddyIgnore(), buddySet()
- New: Listing of games per pool in NeutronSession: NeutronSession gameListPerPo
- New: Games with password (only usable for named games)
- Internal: Changed parameter in buddySet from P_STATUS to P_TYPE
*** Version 4.0.4
- Change: NeutronGame.handoverTurn() and NeutronGame.sendData() are now getting
a Hashtable parameter instead of Object
- New: RC_ACTORSESSION_BUSY (121) constant to help identify common development e
rror! check in gameCreateReturn()
*** Version 4.0.3
- New: RC_INVALID_CONNECTIONSTRING (74) constant to help identify a common error
! check in loginReturn()
- Update: list of serializable datatypes in NeutronSession JavaDoc
- Fix: Fatal server errors cause a returnCode of NeutronListener.RC_OP_SERVER ag
ain; debug test-server libs print out debug text! (during development fatal erro
rs could happen in case of not matching client/server setups)

*** Version 4.0.2

- Internal: Neutron.deserializeData() now returns either the P_DATA part of the
deserialized data (if available / serialized by serializeData()) or the resultin
g hashtable itself
*** Version 4.0.1
- New: NConnectSE connects to server defined by parameter: ipPort (before: fixed
- New: SE version is now completely independent from Java ME classes (were not u
sed, but had to be present)
- Fix: Changed versioning for "ClientLibVersion" in Login/CC
*** Version
- Removed methods:
- NeutronSession.BuggyGetList - replaced by new GetListBuddyIgnore method;
- NeutronSession.ReSubscribe;
- NeutrinSession.ConfirmBilling;
- NeutronListener.ResubscribeReturn;
- Added methods:
- NeutronSession.GameCreateNamed with password parameter;
- NeutronSession.GameListPerPool;
- NeutronSession.GetActorProperties;
- NeutronSession.SetActorProperties;
- NeutronSession.GetListBuddyIgnore - replaces removed BuggyGetList;
- NeutronSession.ListBuddies;
- NeutronSession.ListIgnore;
- NeutronSession.BillingInitPayment;
- NeutronSession.BillingProcessPayment;
- NeutronGame.Invite;
- NeutronGame.GetGameProperties;
- NeutronGame.SetGameProperties;
- NeutronGame.GetPlayerProperties;
- NeutronGame.SetLocatPlayerProperties;
- NeutronListener.GameInviteReturn;
- NeutronListener.GetPropertiesReturn;
- NeutronListener.SetPropertiesReturn;
- Changed argument list:
- NeutronSession.GameCreate - added password parameter;
- NeutronListener.GamesListReturn added listType parameter;
- NeutronListener.BuddyGetListReturn all buddy related info now in passing i
n one strings array parrameter;
- NeutronListener.BuddySetReturn added type parameter;
- NeutronListener.BillingInitPaymentReturn;
- added constants:

RCB_PRICE_- Changed

*** Version

- CLS-specifications largely corrected
*** Version
- changes in neutron-java-lib integrated
- Removed: NeutronGame: playerNames, playerIDs, playerLobbies, playerStats
- Change: removed GpOperation.roundtripTime, now using public Neutron.roundtripT
to be sent in operation headers (GpOperation.serializeParameters(), internal)
- Change: channelRaiseEvent() is now raiseEventInChannel() and gets the eventCod
as seperate parameter value - analog to raiseEventForActor()
- Fix: renamed EV_KEY_M_MIPLAYERS to EV_KEY_M_MINPLAYERS (number of min players
of game, before start)
- Fix: values for EV_KEY_M_MINPLAYERS and EV_KEY_M_MAXPLAYERS corrected (wrong c
ase so far)
- Changed: Neutron.millisecondsToWait (current value of polling-interval) is now
set in Neutron.receiveResponse() for login, register and alike