public static void AddTracking(object obj)
{
bool flag = StateTracker.instance != null;
if (flag)
{
foreach (MemberInfo current in Utils.GetMembersInfo(obj.GetType()))
{
object[] customAttributes = current.GetCustomAttributes(true);
bool flag2 = customAttributes != null;
if (flag2)
{
object[] array = customAttributes;
for (int i = 0; i < array.Length; i++)
{
object obj2 = array[i];
bool flag3 = obj2 is AddTracking;
if (flag3)
{
StateTracker.AddTracking(obj, current.Name);
}
}
}
}
}
}
public static void AddTracking(object obj)
{
bool flag = StateTracker.instance != null;
if (flag)
{
List <MemberInfo> membersInfo = Utils.GetMembersInfo(obj.GetType());
int i = 0;
int count = membersInfo.Count;
while (i < count)
{
MemberInfo memberInfo = membersInfo[i];
object[] customAttributes = memberInfo.GetCustomAttributes(true);
bool flag2 = customAttributes != null;
if (flag2)
{
int j = 0;
int num = customAttributes.Length;
while (j < num)
{
bool flag3 = customAttributes[j] is AddTracking;
if (flag3)
{
StateTracker.AddTracking(obj, memberInfo.Name);
}
j++;
}
}
i++;
}
}
}
/**
* @brief Initializes internal properties based on whether there is a {@link TSCollider2D} attached.
**/
public void Initialize()
{
if (m_Initialized)
{
return;
}
m_TSCollider = GetComponent <TSCollider2D>();
if (transform.parent != null)
{
m_TSParent = transform.parent.GetComponent <TSTransform2D>();
}
if (!m_Serialized)
{
UpdateEditMode();
}
if (m_TSCollider != null)
{
if (m_TSCollider.isBodyInitialized)
{
m_TSCollider.body.TSPosition = m_Position + m_TSCollider.center;
m_TSCollider.body.TSOrientation = m_Rotation * FP.Deg2Rad;
}
}
else
{
StateTracker.AddTracking(this);
}
m_Initialized = true;
}
/**
* @brief Initializes internal properties based on whether there is a {@link TSCollider2D} attached.
**/
public void Initialize()
{
if (initialized)
{
return;
}
tsCollider = GetComponent <TSCollider2D>();
if (transform.parent != null)
{
tsParent = transform.parent.GetComponent <TSTransform2D>();
}
if (!_serialized)
{
UpdateEditMode();
}
if (tsCollider != null)
{
if (tsCollider.IsBodyInitialized)
{
tsCollider.Body.TSPosition = _position + scaledCenter;
tsCollider.Body.TSOrientation = _rotation * FP.Deg2Rad;
}
}
else
{
StateTracker.AddTracking(this);
}
initialized = true;
}
public static void AddTracking(object obj, string path)
{
bool flag = StateTracker.instance != null;
if (flag)
{
string item = string.Format("{0}_{1}_{2}", obj.GetType().FullName, obj.GetHashCode(), path);
bool flag2 = !StateTracker.instance.trackedInfosAdded.Contains(item);
if (flag2)
{
StateTracker.TrackedInfo trackedInfo = StateTracker.GetTrackedInfo(obj, path);
StateTracker.instance.trackedInfos.Add(trackedInfo);
StateTracker.instance.trackedInfosAdded.Add(item);
int i = 0;
int size = StateTracker.instance.states.size;
while (i < size)
{
StateTracker.State @new = StateTracker.resourcePool.GetNew();
@new.SetInfo(trackedInfo);
StateTracker.instance.states.Current().Add(@new);
StateTracker.instance.states.MoveNext();
i++;
}
}
}
}
public AbstractLockstep(FP deltaTime, ICommunicator communicator, IPhysicsManager physicsManager, int syncWindow, int panicWindow, int rollbackWindow, TrueSyncEventCallback OnGameStarted, TrueSyncEventCallback OnGamePaused, TrueSyncEventCallback OnGameUnPaused, TrueSyncEventCallback OnGameEnded, TrueSyncPlayerDisconnectionCallback OnPlayerDisconnection, TrueSyncUpdateCallback OnStepUpdate, TrueSyncInputCallback GetLocalData)
{
this.deltaTime = deltaTime;
this.syncWindow = syncWindow;
this.panicWindow = panicWindow;
this.rollbackWindow = rollbackWindow;
this.totalWindow = syncWindow + rollbackWindow;
this.StepUpdate = OnStepUpdate;
this.OnGameStarted = OnGameStarted;
this.OnGamePaused = OnGamePaused;
this.OnGameUnPaused = OnGameUnPaused;
this.OnGameEnded = OnGameEnded;
this.OnPlayerDisconnection = OnPlayerDisconnection;
this.GetLocalData = GetLocalData;
this.ticks = 0;
this.players = new SortedDictionary <byte, TSPlayer>();
this.communicator = communicator;
bool flag = communicator != null;
if (flag)
{
this.communicator.AddEventListener(new OnEventReceived(this.OnEventDataReceived));
}
this.physicsManager = physicsManager;
this.compoundStats = new CompoundStats();
this.bufferSyncedInfo = new GenericBufferWindow <SyncedInfo>(3);
this.checksumOk = true;
this.simulationState = AbstractLockstep.SimulationState.NOT_STARTED;
this.bodiesToDestroy = new Dictionary <int, List <IBody> >();
this.delegatesToExecute = new Dictionary <int, List <Delegate> >();
this.ReplayRecord = ReplayRecord.replayToLoad;
this.ReplayMode = ReplayRecord.replayMode;
this.time = FP.Zero;
StateTracker.AddTracking(this, "time");
}
public static TSRandom New(int seed)
{
TSRandom tSRandom = new TSRandom(seed);
StateTracker.AddTracking(tSRandom, "mt");
StateTracker.AddTracking(tSRandom, "mti");
return(tSRandom);
}
/**
* @brief Generates a new instance based on a given seed.
**/
public static TSRandom New(int seed)
{
TSRandom r = new TSRandom(seed);
StateTracker.AddTracking(r, "mt");
StateTracker.AddTracking(r, "mti");
return(r);
}
public static void AddTracking(object obj, string path)
{
bool flag = StateTracker.instance != null;
if (flag)
{
string item = string.Format("{0}_{1}_{2}", obj.GetType().FullName, obj.GetHashCode(), path);
bool flag2 = !StateTracker.instance.trackedInfosAdded.Contains(item);
if (flag2)
{
StateTracker.instance.trackedInfos.Add(StateTracker.GetTrackedInfo(obj, path));
StateTracker.instance.trackedInfosAdded.Add(item);
}
}
}
void Awake()
{
TrueSyncConfig currentConfig = ActiveConfig;
lockedTimeStep = currentConfig.lockedTimeStep;
StateTracker.Init();
if (currentConfig.physics2DEnabled || currentConfig.physics3DEnabled)
{
PhysicsManager.New(currentConfig);
PhysicsManager.instance.LockedTimeStep = lockedTimeStep;
PhysicsManager.instance.Init();
}
}
void OnDestroy()
{
ResourcePool.CleanUpAll();
// Release StateTracker.
StateTracker.CleanUp();
// Release physics world.
PhysicsManager.Cleanup();
// Release self-reference.
m_Instance = null;
}
void Awake()
{
TrueSyncConfig currentConfig = ActiveConfig;
lockedTimeStep = currentConfig.lockedTimeStep;
StateTracker.Init(currentConfig.rollbackWindow);
TSRandom.Init();
if (currentConfig.physics2DEnabled || currentConfig.physics3DEnabled) {
PhysicsManager.New(currentConfig);
PhysicsManager.instance.LockedTimeStep = lockedTimeStep;
PhysicsManager.instance.Init();
}
StateTracker.AddTracking(this, "time");
}
/**
* @brief Initializes internal properties based on whether there is a {@link TSCollider} attached.
**/
public void Initialize()
{
if (initialized)
{
return;
}
rb = GetComponent <TSRigidBody>();
transformCache = transform;
tsCollider = GetComponent <TSCollider>();
if (transformCache.parent != null)
{
tsParent = transformCache.parent.GetComponent <TSTransform>();
}
foreach (Transform child in transformCache)
{
TSTransform tsChild = child.GetComponent <TSTransform>();
if (tsChild != null)
{
tsChildren.Add(tsChild);
}
}
if (!_serialized)
{
UpdateEditMode();
}
if (tsCollider != null)
{
if (tsCollider.IsBodyInitialized)
{
tsCollider.Body.TSPosition = _position + scaledCenter;
tsCollider.Body.TSOrientation = TSMatrix.CreateFromQuaternion(_rotation);
}
}
else
{
StateTracker.AddTracking(this);
}
initialized = true;
}
/**
* @brief Initializes internal properties based on whether there is a {@link TSCollider} attached.
**/
public void Initialize()
{
if (initialized)
{
return;
}
tsCollider = GetComponent <TSCollider>();
if (transform.parent != null)
{
tsParent = transform.parent.GetComponent <TSTransform>();
}
foreach (Transform child in transform)
{
TSTransform tsChild = child.GetComponent <TSTransform>();
if (tsChild != null)
{
tsChildren.Add(tsChild);
}
}
if (!_serialized)
{
UpdateEditMode();
}
if (tsCollider != null)
{
if (tsCollider.IsBodyInitialized)
{
tsCollider.Body.TSPosition = _position + scaledCenter;
tsCollider.Body.TSOrientation = TSMatrix.CreateFromQuaternion(_rotation);
}
}
else
{
//配合 [AddTracking] Attribute 使用, StateTracker.AddTracking(object obj)通过反射获取obj的成员变量
StateTracker.AddTracking(this);
}
initialized = true;
}
/**
* @brief Initializes internal properties based on whether there is a {@link TSCollider} attached.
**/
public void Initialize()
{
if (initialized)
{
return;
}
tsCollider = GetComponent <TSCollider>();
if (transform.parent != null)
{
tsParent = transform.parent.GetComponent <TSTransform>();
}
foreach (Transform child in transform)
{
TSTransform tsChild = child.GetComponent <TSTransform>();
if (tsChild != null)
{
tsChildren.Add(tsChild);
}
}
if (!_serialized)
{
UpdateEditMode();
}
if (tsCollider != null)
{
if (tsCollider.IsBodyInitialized)
{
tsCollider.Body.TSPosition = transform.position.ToTSVector() + scaledCenter;
tsCollider.Body.TSOrientation = transform.rotation.ToTSMatrix();
localScale = transform.localScale.ToTSVector();
}
}
else
{
StateTracker.AddTracking(this);
}
initialized = true;
}
//=================================================================================================================
void Awake()
{
TrueSyncConfig currentConfig = ActiveConfig;
lockedTimeStep = currentConfig.lockedTimeStep;
// 初始化状态跟踪
StateTracker.Init(currentConfig.rollbackWindow);
// 初始化随机数
TSRandom.Init(randomseed);
// 初始化物理管理器
if (currentConfig.physics2DEnabled || currentConfig.physics3DEnabled)
{
PhysicsManager.New(currentConfig);
PhysicsManager.instance.LockedTimeStep = lockedTimeStep;
PhysicsManager.instance.Init();
}
// 跟踪 时间
StateTracker.AddTracking(this, "time");
}
/**
* @brief Clean up references to be collected by gc.
**/
public static void CleanUp()
{
ResourcePool.CleanUpAll();
StateTracker.CleanUp();
instance = null;
}
/// <summary>
///@brief Clean up references to be collected by gc.
///DV 清除GC所收集的引用
/// </summary>
public static void CleanUp()
{
ResourcePool.CleanUpAll(); // 清理对象池
StateTracker.CleanUp(); // 清理状态跟踪
instance = null; // 去除实例变量引用
}
public RollbackLockstep(FP deltaTime, ICommunicator communicator, IPhysicsManager physicsManager, int syncWindow, int panicTime, int rollbackWindow, TrueSyncEventCallback OnGameStarted, TrueSyncEventCallback OnGamePaused, TrueSyncEventCallback OnGameUnPaused, TrueSyncEventCallback OnGameEnded, TrueSyncPlayerDisconnectionCallback OnPlayerDisconnection, TrueSyncUpdateCallback OnStepUpdate, TrueSyncInputCallback GetLocalData) : base(deltaTime, communicator, physicsManager, syncWindow, panicTime, rollbackWindow, OnGameStarted, OnGamePaused, OnGameUnPaused, OnGameEnded, OnPlayerDisconnection, OnStepUpdate, GetLocalData)
{
this.bufferWorldClone = new GenericBufferWindow <IWorldClone>(rollbackWindow, new GenericBufferWindow <IWorldClone> .NewInstance(physicsManager.GetWorldClone));
this.rollbackIndex = rollbackWindow;
StateTracker.Init(rollbackWindow);
}
public TrueSyncManagedBehaviour(ITrueSyncBehaviour trueSyncBehavior)
{
StateTracker.AddTracking(this);
StateTracker.AddTracking(trueSyncBehavior);
this.trueSyncBehavior = trueSyncBehavior;
}
public static void CleanUp()
{
instance = null;
}
public static void Init(int rollbackWindow)
{
StateTracker.instance = new StateTracker();
StateTracker.instance.states = new GenericBufferWindow <List <StateTracker.State> >(rollbackWindow);
}
public static void Init()
{
StateTracker.instance = new StateTracker();
TSRandom.Init();
}
public static void CleanUp()
{
StateTracker.instance = null;
}
public void Initialize()
{
StateTracker.AddTracking(this);
InitTransformCache();
}
// LOGIC
public void Initialize(TrueSyncConfig i_Config = null)
{
TrueSyncConfig config = (i_Config != null) ? i_Config : (Resources.Load <TrueSyncConfig>(s_TrueSyncConfigResourcePath));
// Load config.
m_Config = config;
if (config == null)
{
return;
}
m_LockedTimeStep = config.lockedTimeStep;
// Init state tracker.
StateTracker.Init(config.rollbackWindow);
// Init time.
m_TimeScaler = new TSTimeScaler();
m_TimeScaler.Init();
// Create physics world.
IPhysicsManager worldManager = new Physics2DWorldManager();
worldManager.Gravity = new TSVector(config.gravity.x, config.gravity.y, 0);
worldManager.SpeculativeContacts = config.speculativeContacts;
worldManager.LockedTimeStep = config.lockedTimeStep;
worldManager.Init();
// Create communicator.
ICommunicator communicator = null;
if (isOnline)
{
communicator = new PhotonTrueSyncCommunicator(PhotonNetwork.networkingPeer);
}
else
{
Debug.Log("You are not connected to Photon. TrueSync will start in offline mode.");
}
// Create lockstep.
m_Lockstep = AbstractLockstep.NewInstance(m_LockedTimeStep, communicator, worldManager, m_Config.syncWindow, m_Config.panicWindow, m_Config.rollbackWindow, OnGameStarted, OnGamePaused, OnGameUnPaused, OnGameEnded, OnPlayerDisconnection, OnStepUpdate, GetLocalData);
Debug.Log("Lockstep initialized (Sync: " + m_Config.syncWindow + ", Rollback: " + m_Config.rollbackWindow + ")");
// Stats
if (m_Config.showStats)
{
TrueSyncStats statsComponent = gameObject.AddComponent <TrueSyncStats>();
statsComponent.Lockstep = m_Lockstep;
}
// Add player on lockestep.
if (isOnline)
{
List <PhotonPlayer> photonPlayers = new List <PhotonPlayer>(PhotonNetwork.playerList);
photonPlayers.Sort(UnityUtils.playerComparer);
for (int photonPlayerIndex = 0; photonPlayerIndex < photonPlayers.Count; ++photonPlayerIndex)
{
PhotonPlayer photonPlayer = photonPlayers[photonPlayerIndex];
m_Lockstep.AddPlayer((byte)photonPlayer.ID, photonPlayer.NickName, photonPlayer.IsLocal);
}
}
else
{
m_Lockstep.AddPlayer(0, "Local_Player", true);
}
// Fill behaviours per player dictionary.
foreach (TSPlayer player in m_Lockstep.Players.Values)
{
List <TrueSyncManagedBehaviour> behaviours = new List <TrueSyncManagedBehaviour>();
m_BehavioursPerPlayer.Add(player.ID, behaviours);
}
// Initialize Physics Manager.
PhysicsManager.Initialize(worldManager);
PhysicsManager.OnRemoveBody(OnRemovedRigidbody);
}
// LOGIC
public void Init()
{
StateTracker.AddTracking(this);
}
