public GameEngineBase(ContentManager contentManager, IServiceRegistry services, GameSystemCollection gameSystems = null)
{
Logger = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
GameClockManager = new GameClockManager(PhysicsGameTime);
_targetTimeDriftAdjustmentThreshold = GameClockManager.SimulationDeltaTime.Ticks / 10; // 10% of a single sim step
Services = (ServiceRegistry)services;
Content = contentManager;
GameSystems = gameSystems ?? new GameSystemCollection(Services);
// Replacing existing IGameSystemCollection with our own
var existingGameSystems = Services.GetService <IGameSystemCollection>();
if (existingGameSystems != null)
{
Services.RemoveService <IGameSystemCollection>();
}
Services.AddOrOverwriteService <IGameSystemCollection>(GameSystems);
var networkAssetDatabase = new NetworkAssetDatabase(Content, assetFolderUrls: new[] { "Prefabs", "Scenes" });
Services.AddOrOverwriteService(networkAssetDatabase);
Services.AddOrOverwriteService(GameClockManager);
var gameSettingsService = services.GetSafeServiceAs <IGameSettingsService>();
Settings = gameSettingsService.Settings;
}
protected override void OnSystemAdd()
{
_sceneSystem = Services.GetSafeServiceAs <SceneSystem>();
_gameClockManager = Services.GetSafeServiceAs <GameClockManager>();
_gameEngineContext = Services.GetService <GameEngineContext>();
_networkService = Services.GetService <IGameNetworkService>();
}
protected override void OnSystemAdd()
{
var gameEngineContext = Services.GetService <GameEngineContext>();
Enabled = gameEngineContext.IsClient;
_gameClockManager = Services.GetService <GameClockManager>();
_networkService = Services.GetService <IGameNetworkService>();
}
internal void Initialize(IServiceRegistry services)
{
Services = services;
_exitGameService = Services.GetSafeServiceAs <IExitGameService>();
GameEngineContext = Services.GetSafeServiceAs <GameEngineContext>();
NetworkService = Services.GetSafeServiceAs <IGameNetworkService>();
GameClockManager = Services.GetSafeServiceAs <GameClockManager>();
}
protected override void OnSystemAdd()
{
_gameClockManager = Services.GetService <GameClockManager>();
_networkService = Services.GetSafeServiceAs <IGameNetworkService>();
_content = Services.GetSafeServiceAs <ContentManager>();
_networkAssetDatabase = Services.GetSafeServiceAs <NetworkAssetDatabase>();
var sceneSystem = Services.GetSafeServiceAs <SceneSystem>();
_lazyLoadedScene = new LazyLoadedSceneData(sceneSystem);
}
public override void Draw(RenderContext context)
{
var localFromSimTickNo = _gameClockManager.SimulationClock.SimulationTickNumber - 1;
var localToSimTickNo = localFromSimTickNo + 1;
var localSimTickElapsedRatio = (float)(_gameClockManager.SimulationClock.CurrentTickTimeElapsed.TotalMilliseconds / GameConfig.PhysicsFixedTimeStep.TotalMilliseconds);
var renderRemoteDelayTime = _gameClockManager.RemoteEntityRenderTimeDelay + GameConfig.PhysicsFixedTimeStep; // Always add one snapshot delay so we're at least interpolating from the previous snapshot to the current snaphot
var renderRemoteWorldTime = _gameClockManager.SimulationClock.TotalTime - renderRemoteDelayTime;
if (renderRemoteWorldTime < TimeSpan.Zero)
{
renderRemoteWorldTime = TimeSpan.Zero;
}
var remoteFromSimTickNo = GameClockManager.CalculateSimulationTickNumber(renderRemoteWorldTime);
var remoteToSimTickNo = remoteFromSimTickNo + 1;
var remoteSimTickElapsed = TimeSpan.FromTicks(renderRemoteWorldTime.Ticks - (GameConfig.PhysicsFixedTimeStep.Ticks * remoteFromSimTickNo));
var remoteSimTickElapsedRatio = (float)(remoteSimTickElapsed.TotalMilliseconds / GameConfig.PhysicsFixedTimeStep.TotalMilliseconds);
foreach (var kv in ComponentDatas)
{
var data = kv.Value;
var movementSnapshotsComp = data.MovementSnapshotsComponent;
var clientPredictionSnapshotsComp = data.ClientPredictionSnapshotsComponent;
var networkEntityComp = data.NetworkEntityComponent;
if (networkEntityComp.IsLocalEntity && clientPredictionSnapshotsComp != null && !_networkService.IsGameHost)
{
var predictedMovements = clientPredictionSnapshotsComp.PredictedMovements;
#if DEBUG
//DebugWriteLine(@$"RENDER -- SimTick {_gameClockManager.SimulationClock.SimulationTickNumber} - SimTotalTime {_gameClockManager.SimulationClock.TotalTime} - SimCurElapsed {_gameClockManager.SimulationClock.CurrentTickTimeElapsed} - Lerp {localSimTickElapsedRatio}");
#endif
if (predictedMovements.Count < 2)
{
// Not enough positions
continue;
}
// Always just use the last two data points
ref var fromMovementData = ref predictedMovements.Items[predictedMovements.Count - 2];
ref var toMovementData = ref predictedMovements.Items[predictedMovements.Count - 1];
var interpAmount = localSimTickElapsedRatio;
Vector3.Lerp(ref fromMovementData.LocalPosition, ref toMovementData.LocalPosition, interpAmount, out var renderPos);
Quaternion.Slerp(ref fromMovementData.LocalRotation, ref toMovementData.LocalRotation, interpAmount, out var renderRot);
data.TransformComponent.Position = renderPos;
data.ModelChildTransformComponent.Rotation = renderRot;
#if DEBUG
// DebugWriteLine(@$"Render PIDFrom {fromMovementData.PlayerInputSequenceNumberApplied} - PIDTo {toMovementData.PlayerInputSequenceNumberApplied} - RndPos {renderPos} - RndRot {renderRot} - FromRot {fromMovementData.LocalRotation} - ToRot {toMovementData.LocalRotation}
// OrigSimFrom {localFromSimTickNo} - OrigSimTo {localToSimTickNo} - Lerp {interpAmount} - TimeElapsed {_gameClockManager.SimulationClock.CurrentTickTimeElapsed}");
#endif
}
protected override void OnSystemAdd()
{
var gameEngineContext = Services.GetService <GameEngineContext>();
Enabled = gameEngineContext.IsClient;
_gameClockManager = Services.GetService <GameClockManager>();
var sceneSystem = Services.GetSafeServiceAs <SceneSystem>();
_lazyLoadedScene = new LazyLoadedSceneData(sceneSystem);
//EntityManager.EntityAdded += OnEntityAdded;
EntityManager.EntityRemoved += OnEntityRemoved;
}
protected override void OnSystemAdd()
{
_gameClockManager = Services.GetService <GameClockManager>();
_gameEngineContext = Services.GetService <GameEngineContext>();
}
private ClientPredictionSnapshotsComponent _clientPredictionSnapshotsComponent; // Optional component
public override void Start()
{
base.Start();
var parentEntity = Entity.GetParent();
Debug.Assert(parentEntity != null);
var networkEntityViewComp = parentEntity.Get <NetworkEntityViewComponent>();
var networkedEntity = networkEntityViewComp.NetworkedEntity;
_networkEntityComponent = networkedEntity.Get <NetworkEntityComponent>();
Debug.Assert(_networkEntityComponent != null);
_movementSnapshotsComponent = networkedEntity.Get <MovementSnapshotsComponent>();
Debug.Assert(_movementSnapshotsComponent != null);
_clientPredictionSnapshotsComponent = networkedEntity.Get <ClientPredictionSnapshotsComponent>();
_gameClockManager = Services.GetSafeServiceAs <GameClockManager>();
_networkService = Services.GetService <IGameNetworkService>();
if (AnimationComponent == null)
{
throw new InvalidOperationException("The animation component is not set");
}
if (AnimationIdle == null)
{
throw new InvalidOperationException("Idle animation is not set");
}
if (AnimationWalk == null)
{
throw new InvalidOperationException("Walking animation is not set");
}
if (AnimationRun == null)
{
throw new InvalidOperationException("Running animation is not set");
}
if (AnimationJumpStart == null)
{
throw new InvalidOperationException("Jumping animation is not set");
}
if (AnimationJumpMid == null)
{
throw new InvalidOperationException("Airborne animation is not set");
}
if (AnimationJumpEnd == null)
{
throw new InvalidOperationException("Landing animation is not set");
}
// By setting a custom blend tree builder we can override the default behavior of the animation system
// Instead, BuildBlendTree(FastList<AnimationOperation> blendStack) will be called each frame
AnimationComponent.BlendTreeBuilder = this;
animEvaluatorIdle = AnimationComponent.Blender.CreateEvaluator(AnimationIdle);
animEvaluatorWalk = AnimationComponent.Blender.CreateEvaluator(AnimationWalk);
animEvaluatorRun = AnimationComponent.Blender.CreateEvaluator(AnimationRun);
animEvaluatorJumpStart = AnimationComponent.Blender.CreateEvaluator(AnimationJumpStart);
animEvaluatorJumpMid = AnimationComponent.Blender.CreateEvaluator(AnimationJumpMid);
animEvaluatorJumpEnd = AnimationComponent.Blender.CreateEvaluator(AnimationJumpEnd);
// Initial walk lerp
walkLerpFactor = 0;
animEvaluatorWalkLerp1 = animEvaluatorIdle;
animEvaluatorWalkLerp2 = animEvaluatorWalk;
animationClipWalkLerp1 = AnimationIdle;
animationClipWalkLerp2 = AnimationWalk;
}
protected override void OnSystemAdd()
{
_gameClockManager = Services.GetService <GameClockManager>();
_networkService = Services.GetService <IGameNetworkService>();
}
public override void Initialize()
{
_sceneSystem = Services.GetSafeServiceAs <SceneSystem>();
_gameClockManager = Services.GetSafeServiceAs <GameClockManager>();
}
