ServerTimeInMilliSeconds
How do I use Server Time In Milli Seconds
Below are practical examples compiled from projects for learning and reference purposes
Featured Snippets
File name: NetworkingPeer.cs
Copy
2228 internal Hashtable SendInstantiate(string prefabName, Vector3 position, Quaternion rotation, int group, int[] viewIDs, object[] data, bool isGlobalObject)
2229 {
2230 // first viewID is now also the gameobject's instantiateId
2231 int instantiateId = viewIDs[0]; // LIMITS PHOTONVIEWS&PLAYERS
2232
2233 //TODO: reduce hashtable key usage by using a parameter array for the various values
2234 Hashtable instantiateEvent = new Hashtable(); // This players info is sent via ActorID
2235 instantiateEvent[(byte)0] = prefabName;
2236
2237 if (position != Vector3.zero)
2238 {
2239 instantiateEvent[(byte)1] = position;
2240 }
2241
2242 if (rotation != Quaternion.identity)
2243 {
2244 instantiateEvent[(byte)2] = rotation;
2245 }
2246
2247 if (group != 0)
2248 {
2249 instantiateEvent[(byte)3] = group;
2250 }
2251
2252 // send the list of viewIDs only if there are more than one. else the instantiateId is the viewID
2253 if (viewIDs.Length > 1)
2254 {
2255 instantiateEvent[(byte)4] = viewIDs; // LIMITS PHOTONVIEWS&PLAYERS
2256 }
2257
2258 if (data != null)
2259 {
2260 instantiateEvent[(byte)5] = data;
2261 }
2262
2263 if (this.currentLevelPrefix > 0)
2264 {
2265 instantiateEvent[(byte)8] = this.currentLevelPrefix; // photonview's / object's level prefix
2266 }
2267
2268 instantiateEvent[(byte)6] = this.ServerTimeInMilliSeconds;
2269 instantiateEvent[(byte)7] = instantiateId;
2270
2271
2272 RaiseEventOptions options = new RaiseEventOptions();
2273 options.CachingOption = (isGlobalObject) ? EventCaching.AddToRoomCacheGlobal : EventCaching.AddToRoomCache;
2274
2275 this.OpRaiseEvent(PunEvent.Instantiation, instantiateEvent, true, options);
2276 return instantiateEvent;
2277 }
File name: NetworkingPeer.cs
Copy
2835 internal void RPC(PhotonView view, string methodName, PhotonPlayer player, bool encrypt, params object[] parameters)
2836 {
2837 if (this.blockSendingGroups.Contains(view.group))
2838 {
2839 return; // Block sending on this group
2840 }
2841
2842 if (view.viewID < 1) //TODO: check why 0 should be illegal
2843 {
2844 Debug.LogError("Illegal view ID:" + view.viewID + " method: " + methodName + " GO:" + view.gameObject.name);
2845 }
2846
2847 if (PhotonNetwork.logLevel >= PhotonLogLevel.Full)
2848 {
2849 Debug.Log("Sending RPC \"" + methodName + "\" to player[" + player + "]");
2850 }
2851
2852
2853 //ts: changed RPCs to a one-level hashtable as described in internal.txt
2854 Hashtable rpcEvent = new Hashtable();
2855 rpcEvent[(byte)0] = (int)view.viewID; // LIMITS PHOTONVIEWS&PLAYERS
2856 if (view.prefix > 0)
2857 {
2858 rpcEvent[(byte)1] = (short)view.prefix;
2859 }
2860 rpcEvent[(byte)2] = this.ServerTimeInMilliSeconds;
2861
2862 // send name or shortcut (if available)
2863 int shortcut = 0;
2864 if (rpcShortcuts.TryGetValue(methodName, out shortcut))
2865 {
2866 rpcEvent[(byte)5] = (byte)shortcut; // LIMITS RPC COUNT
2867 }
2868 else
2869 {
2870 rpcEvent[(byte)3] = methodName;
2871 }
2872
2873 if (parameters != null && parameters.Length > 0)
2874 {
2875 rpcEvent[(byte) 4] = (object[]) parameters;
2876 }
2877
2878 if (this.mLocalActor == player)
2879 {
2880 this.ExecuteRPC(rpcEvent, player);
2881 }
2882 else
2883 {
2884 RaiseEventOptions options = new RaiseEventOptions() { TargetActors = new int[] { player.ID }, Encrypt = encrypt };
2885 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2886 }
2887 }
File name: NetworkingPeer.cs
Copy
2890 /// (byte)0 -> (int) ViewId (combined from actorNr and actor-unique-id)
2891 /// (byte)1 -> (short) prefix (level)
2895 /// (byte)5 -> (byte) method shortcut (alternative to name)
2899 internal void RPC(PhotonView view, string methodName, PhotonTargets target, bool encrypt, params object[] parameters)
2900 {
2901 if (this.blockSendingGroups.Contains(view.group))
2902 {
2903 return; // Block sending on this group
2904 }
2905
2906 if (view.viewID < 1)
2907 {
2908 Debug.LogError("Illegal view ID:" + view.viewID + " method: " + methodName + " GO:" + view.gameObject.name);
2909 }
2910
2911 if (PhotonNetwork.logLevel >= PhotonLogLevel.Full)
2912 Debug.Log("Sending RPC \"" + methodName + "\" to " + target);
2913
2914
2915 //ts: changed RPCs to a one-level hashtable as described in internal.txt
2916 Hashtable rpcEvent = new Hashtable();
2917 rpcEvent[(byte)0] = (int)view.viewID; // LIMITS NETWORKVIEWS&PLAYERS
2918 if (view.prefix > 0)
2919 {
2920 rpcEvent[(byte)1] = (short)view.prefix;
2921 }
2922 rpcEvent[(byte)2] = this.ServerTimeInMilliSeconds;
2923
2924
2925 // send name or shortcut (if available)
2926 int shortcut = 0;
2927 if (rpcShortcuts.TryGetValue(methodName, out shortcut))
2928 {
2929 rpcEvent[(byte)5] = (byte)shortcut; // LIMITS RPC COUNT
2930 }
2931 else
2932 {
2933 rpcEvent[(byte)3] = methodName;
2934 }
2935
2936 if (parameters != null && parameters.Length > 0)
2937 {
2938 rpcEvent[(byte)4] = (object[])parameters;
2939 }
2940
2941 // Check scoping
2942 if (target == PhotonTargets.All)
2943 {
2944 RaiseEventOptions options = new RaiseEventOptions() { InterestGroup = (byte)view.group, Encrypt = encrypt };
2945 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2946
2947 // Execute local
2948 this.ExecuteRPC(rpcEvent, this.mLocalActor);
2949 }
2950 else if (target == PhotonTargets.Others)
2951 {
2952 RaiseEventOptions options = new RaiseEventOptions() { InterestGroup = (byte)view.group, Encrypt = encrypt };
2953 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2954 }
2955 else if (target == PhotonTargets.AllBuffered)
2956 {
2957 RaiseEventOptions options = new RaiseEventOptions() { CachingOption = EventCaching.AddToRoomCache, Encrypt = encrypt };
2958 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2959
2960 // Execute local
2961 this.ExecuteRPC(rpcEvent, this.mLocalActor);
2962 }
2963 else if (target == PhotonTargets.OthersBuffered)
2964 {
2965 RaiseEventOptions options = new RaiseEventOptions() { CachingOption = EventCaching.AddToRoomCache, Encrypt = encrypt };
2966 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2967 }
2968 else if (target == PhotonTargets.MasterClient)
2969 {
2970 if (this.mMasterClient == this.mLocalActor)
2971 {
2972 this.ExecuteRPC(rpcEvent, this.mLocalActor);
2973 }
2974 else
2975 {
2976 RaiseEventOptions options = new RaiseEventOptions() { Receivers = ReceiverGroup.MasterClient, Encrypt = encrypt };
2977 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2978 }
2979 }
2980 else if (target == PhotonTargets.AllViaServer)
2981 {
2982 RaiseEventOptions options = new RaiseEventOptions() { InterestGroup = (byte)view.group, Receivers = ReceiverGroup.All, Encrypt = encrypt };
2983 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2984 if (PhotonNetwork.offlineMode)
2985 {
2986 this.ExecuteRPC(rpcEvent, this.mLocalActor);
2987 }
2988 }
2989 else if (target == PhotonTargets.AllBufferedViaServer)
2990 {
2991 RaiseEventOptions options = new RaiseEventOptions() { InterestGroup = (byte)view.group, Receivers = ReceiverGroup.All, CachingOption = EventCaching.AddToRoomCache, Encrypt = encrypt };
2992 this.OpRaiseEvent(PunEvent.RPC, rpcEvent, true, options);
2993 if (PhotonNetwork.offlineMode)
2994 {
2995 this.ExecuteRPC(rpcEvent, this.mLocalActor);
2996 }
2997 }
2998 else
2999 {
3000 Debug.LogError("Unsupported target enum: " + target);
3001 }
3002 }
File name: NetworkingPeer.cs
Copy
3147 public void RunViewUpdate()
3148 {
3149 if (!PhotonNetwork.connected || PhotonNetwork.offlineMode)
3150 {
3151 return;
3152 }
3153
3154 if (this.mActors == null ||
3155#if !PHOTON_DEVELOP
3156 this.mActors.Count <= 1
3157#endif
3158 )
3159 {
3160 return; // No need to send OnSerialize messages (these are never buffered anyway)
3161 }
3162
3163 dataPerGroupReliable.Clear();
3164 dataPerGroupUnreliable.Clear();
3165
3166 /* Format of the data hashtable:
3167 * Hasthable dataPergroup*
3168 * [(byte)0] = this.ServerTimeInMilliSeconds;
3169 * OPTIONAL: [(byte)1] = currentLevelPrefix;
3170 * + data
3171 */
3172
3173 foreach (KeyValuePair
3174 {
3175 PhotonView view = kvp.Value;
3176
3177 if (view.synchronization != ViewSynchronization.Off)
3178 {
3179 // Fetch all sending photonViews
3180 if (view.isMine)
3181 {
3182 #if UNITY_2_6_1 || UNITY_2_6 || UNITY_3_0 || UNITY_3_0_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5
3183 if (!view.gameObject.active)
3184 {
3185 continue; // Only on actives
3186 }
3187 #else
3188 if (!view.gameObject.activeInHierarchy)
3189 {
3190 continue; // Only on actives
3191 }
3192 #endif
3193
3194 if (this.blockSendingGroups.Contains(view.group))
3195 {
3196 continue; // Block sending on this group
3197 }
3198
3199 // Run it trough its OnSerialize
3200 Hashtable evData = this.OnSerializeWrite(view);
3201 if (evData == null)
3202 {
3203 continue;
3204 }
3205
3206 if (view.synchronization == ViewSynchronization.ReliableDeltaCompressed || view.mixedModeIsReliable)
3207 {
3208 if (!evData.ContainsKey((byte)1) && !evData.ContainsKey((byte)2))
3209 {
3210 // Everything has been removed by compression, nothing to send
3211 }
3212 else
3213 {
3214 if (!dataPerGroupReliable.ContainsKey(view.group))
3215 {
3216 dataPerGroupReliable[view.group] = new Hashtable();
3217 dataPerGroupReliable[view.group][(byte)0] = this.ServerTimeInMilliSeconds;
3218 if (currentLevelPrefix >= 0)
3219 {
3220 dataPerGroupReliable[view.group][(byte)1] = this.currentLevelPrefix;
3221 }
3222 }
3223 Hashtable groupHashtable = dataPerGroupReliable[view.group];
3224 groupHashtable.Add((short)groupHashtable.Count, evData);
3225 }
3226 }
3227 else
3228 {
3229 if (!dataPerGroupUnreliable.ContainsKey(view.group))
3230 {
3231 dataPerGroupUnreliable[view.group] = new Hashtable();
3232 dataPerGroupUnreliable[view.group][(byte)0] = this.ServerTimeInMilliSeconds;
3233 if (currentLevelPrefix >= 0)
3234 {
3235 dataPerGroupUnreliable[view.group][(byte)1] = this.currentLevelPrefix;
3236 }
3237 }
3238 Hashtable groupHashtable = dataPerGroupUnreliable[view.group];
3239 groupHashtable.Add((short)groupHashtable.Count, evData);
3240 }
3241 }
3242 else
3243 {
3244 // Debug.Log(" NO OBS on " + view.name + " " + view.owner);
3245 }
3246 }
3247 else
3248 {
3249 }
3250 }
3251
3252 //Send the messages: every group is send in it's own message and unreliable and reliable are split as well
3253 RaiseEventOptions options = new RaiseEventOptions();
3254
3255#if PHOTON_DEVELOP
3256 options.Receivers = ReceiverGroup.All;
3257#endif
3258
3259 foreach (KeyValuePair
3260 {
3261 options.InterestGroup = (byte)kvp.Key;
3262 this.OpRaiseEvent(PunEvent.SendSerializeReliable, kvp.Value, true, options);
3263 }
3264 foreach (KeyValuePair
3265 {
3266 options.InterestGroup = (byte)kvp.Key;
3267 this.OpRaiseEvent(PunEvent.SendSerialize, kvp.Value, false, options);
3268 }
3269 }
File name: NetworkingPeer.cs
Copy
3271 // calls OnPhotonSerializeView (through ExecuteOnSerialize)
3273 private Hashtable OnSerializeWrite(PhotonView view)
3274 {
3275 PhotonStream pStream = new PhotonStream( true, null );
3276 PhotonMessageInfo info = new PhotonMessageInfo( this.mLocalActor, this.ServerTimeInMilliSeconds, view );
3277
3278 // each view creates a list of values that should be sent
3279 view.SerializeView( pStream, info );
3280
3281 if( pStream.Count == 0 )
3282 {
3283 return null;
3284 }
3285
3286 object[] dataArray = pStream.data.ToArray();
3287
3288 if (view.synchronization == ViewSynchronization.UnreliableOnChange)
3289 {
3290 if (AlmostEquals(dataArray, view.lastOnSerializeDataSent))
3291 {
3292 if (view.mixedModeIsReliable)
3293 {
3294 return null;
3295 }
3296
3297 view.mixedModeIsReliable = true;
3298 view.lastOnSerializeDataSent = dataArray;
3299 }
3300 else
3301 {
3302 view.mixedModeIsReliable = false;
3303 view.lastOnSerializeDataSent = dataArray;
3304 }
3305 }
3306
3307 // EVDATA:
3308 // 0=View ID (an int, never compressed cause it's not in the data)
3309 // 1=data of observed type (different per type of observed object)
3310 // 2=compressed data (in this case, key 1 is empty)
3311 // 3=list of values that are actually null (if something was changed but actually IS null)
3312 Hashtable evData = new Hashtable();
3313 evData[(byte)0] = (int)view.viewID;
3314 evData[(byte)1] = dataArray; // this is the actual data (script or observed object)
3315
3316
3317 if (view.synchronization == ViewSynchronization.ReliableDeltaCompressed)
3318 {
3319 // compress content of data set (by comparing to view.lastOnSerializeDataSent)
3320 // the "original" dataArray is NOT modified by DeltaCompressionWrite
3321 // if something was compressed, the evData key 2 and 3 are used (see above)
3322 bool somethingLeftToSend = this.DeltaCompressionWrite(view, evData);
3323
3324 // buffer the full data set (for next compression)
3325 view.lastOnSerializeDataSent = dataArray;
3326
3327 if (!somethingLeftToSend)
3328 {
3329 return null;
3330 }
3331 }
3332
3333 return evData;
3334 }
File name: PhotonNetwork.cs
Copy
757 {
758 get
759 {
760 if (offlineMode)
761 {
762 return Time.time;
763 }
764 else
765 {
766 return ((double)(uint)networkingPeer.ServerTimeInMilliSeconds) / 1000.0f;
767 }
768 }
769 }
File name: ServerTime.cs
Copy
8 void OnGUI()
9 {
10 GUILayout.BeginArea(new Rect(Screen.width/2-100, 0, 200,30));
11 GUILayout.Label(string.Format("Time Offset: {0}", PhotonNetwork.networkingPeer.ServerTimeInMilliSeconds - Environment.TickCount));
12 if (GUILayout.Button("fetch"))
13 {
14 PhotonNetwork.FetchServerTimestamp();
15 }
16 GUILayout.EndArea();
17 }
ServerTimeInMilliSeconds 135 lượt xem
Gõ tìm kiếm nhanh...