public interface IGameLoop
{
    bool Init(string[] args);
    void Shutdown();

    void Update();
    void FixedUpdate();
    void LateUpdate();
}

voidCmdServe(string[] args){ RequestGameLoop(typeof(ServerGameLoop), args); Console.s_PendingCommandsWaitForFrames =1;}

IGameLoop gameLoop =(IGameLoop)System.Activator.CreateInstance(m_RequestedGameLoopTypes[i]);initSucceeded= gameLoop.Init(m_RequestedGameLoopArguments[i]);

publicboolInit(string[] args){ ... m_NetworkTransport =new SocketTransport(); m_NetworkClient =newNetworkClient(m_NetworkTransport);

publicclass NetworkClient{ ... publicbool isConnected { get; } public ConnectionState connectionState { get; } publicint clientId { get; } public NetworkClient(INetworkTransport transport) publicvoidShutdown()public void QueueCommand(int time, DataGenerator generator) public void QueueEvent(ushort typeId, bool reliable, NetworkEventGenerator generator) ClientConnection m_Connection;}

publicvoid Update(){ Profiler.BeginSample("ClientGameLoop.Update"); Profiler.BeginSample("-NetworkClientUpdate");m_NetworkClient.Update(this, m_clientWorld?.GetSnapshotConsumer()); //客户端接收数据 Profiler.EndSample(); Profiler.BeginSample("-StateMachine update"); m_StateMachine.Update(); Profiler.EndSample(); // TODO (petera) change if we have a lobby like setup one dayif (m_StateMachine.CurrentState() == ClientState.Playing && Game.game.clientFrontend != null) Game.game.clientFrontend.UpdateChat(m_ChatSystem); m_NetworkClient.SendData(); //客户端发送数据

publicvoid Update(INetworkClientCallbacks clientNetworkConsumer, ISnapshotConsumer snapshotConsumer)

publicvoid Update(INetworkClientCallbacks clientNetworkConsumer, ISnapshotConsumer snapshotConsumer){ ... TransportEvent e =newTransportEvent();while(m_Transport.NextEvent(ref e)) { switch (e.type) { case TransportEvent.Type.Connect: OnConnect(e.connectionId); break;case TransportEvent.Type.Disconnect: OnDisconnect(e.connectionId); break;caseTransportEvent.Type.Data:OnData(e.connectionId, e.data, e.dataSize, clientNetworkConsumer, snapshotConsumer); break; } }}

publicvoidSendPackage<TOutputStream>()where TOutputStream : struct, NetworkCompression.IOutputStream{ ...if (commandSequence > 0) { lastSentCommandSeq =commandSequence;WriteCommands(info,refoutput);}WriteEvents(info,ref output); int compressedSize = output.Flush(); rawOutputStream.SkipBytes(compressedSize); CompleteSendPackage(info, refrawOutputStream);}

publicboolInit(string[] args){ // Set up statemachine for ServerGame m_StateMachine = newStateMachine<ServerState>(); m_StateMachine.Add(ServerState.Idle, null, UpdateIdleState, null); m_StateMachine.Add(ServerState.Loading, null, UpdateLoadingState, null);m_StateMachine.Add(ServerState.Active, EnterActiveState, UpdateActiveState, LeaveActiveState);m_StateMachine.SwitchTo(ServerState.Idle);m_NetworkTransport= new SocketTransport(NetworkConfig.serverPort.IntValue, serverMaxClients.IntValue); m_NetworkServer = new NetworkServer(m_NetworkTransport);

publicvoidUpdate(){UpdateNetwork();//更新SQP查询服务器和调用NetWorkServer.Updatem_StateMachine.Update();m_NetworkServer.SendData();m_NetworkStatistics.Update();if (showGameLoopInfo.IntValue > 0) OnDebugDrawGameloopInfo();}

publicclass ServerGameWorld : ISnapshotGenerator, IClientCommandProcessor{ ... publicvoid ServerTickUpdate() { ... m_NetworkServer.HandleClientCommands(m_GameWorld.worldTime.tick, this); }

publicvoidHandleClientCommands(int tick, IClientCommandProcessor processor){ foreach(varcin m_Connections) c.Value.ProcessCommands(tick, processor);}

publicclass ServerGameWorld : ISnapshotGenerator, IClientCommandProcessor{
　　...publicvoidProcessCommand(intconnectionId,inttick,ref NetworkReader data) { 
　　　　...if (tick ==m_GameWorld.worldTime.tick)client.latestCommand.Deserialize(ref serializeContext, ref data);if (client.player.controlledEntity != Entity.Null) { var userCommand = m_GameWorld.GetEntityManager().GetComponentData<UserCommandComponentData>( client.player.controlledEntity); userCommand.command =client.latestCommand;m_GameWorld.GetEntityManager().SetComponentData<UserCommandComponentData>( client.player.controlledEntity,userCommand); } }

publicclass ServerGameWorld : ISnapshotGenerator, IClientCommandProcessor{ public ServerGameWorld(GameWorld world, NetworkServer networkServer, Dictionary<int, ServerGameLoop.ClientInfo> clients, ChatSystemServer m_ChatSystem, BundledResourceManager resourceSystem) { ... m_ReplicatedEntityModule =new ReplicatedEntityModuleServer(m_GameWorld, resourceSystem, m_NetworkServer); m_ReplicatedEntityModule.ReserveSceneEntities(networkServer); } publicvoid ServerTickUpdate() { ... m_ReplicatedEntityModule.HandleSpawning(); m_ReplicatedEntityModule.HandleDespawning(); } publicvoidGenerateEntitySnapshot(intentityId,ref NetworkWriter writer) { ... m_ReplicatedEntityModule.GenerateEntitySnapshot(entityId, ref writer); } publicstringGenerateEntityName(int entityId) { ... return m_ReplicatedEntityModule.GenerateName(entityId); }}

foreach(varidinupdates){var info = entities[id]; GameDebug.Assert(info.type !=null,"Processing update of id {0} but type is null", id); fixed(uint* data = info.lastUpdate) { var reader = new NetworkReader(data, info.type.schema); consumer.ProcessEntityUpdate(serverTime, id, ref reader); }}

publicclass ServerGameWorld : ISnapshotGenerator, IClientCommandProcessor{ void UpdateActiveState() { int tickCount = 0;while (Game.frameTime > m_nextTickTime) { tickCount++; m_serverGameWorld.ServerTickUpdate();　　　　　　 ... m_NetworkServer.GenerateSnapshot(m_serverGameWorld, m_LastSimTime);}

unsafepublicclassNetworkServer{unsafepublicvoid GenerateSnapshot(ISnapshotGenerator snapshotGenerator, float simTime) { ... // Run through all the registered network entities and serialize the snapshotfor(var id = 0; id < m_Entities.Count; id++) { var entity = m_Entities[id]; EntityTypeInfo typeInfo; bool generateSchema = false;if(!m_EntityTypes.TryGetValue(entity.typeId,out typeInfo)) { typeInfo =new EntityTypeInfo() { name = snapshotGenerator.GenerateEntityName(id), typeId = entity.typeId, createdSequence = m_ServerSequence, schema = new NetworkSchema(entity.typeId + NetworkConfig.firstEntitySchemaId) }; m_EntityTypes.Add(entity.typeId, typeInfo); generateSchema =true; } // Generate entity snapshotvar snapshotInfo = entity.snapshots.Acquire(m_ServerSequence); snapshotInfo.start = worldsnapshot.data +worldsnapshot.length;var writer = new NetworkWriter(snapshotInfo.start, NetworkConfig.maxWorldSnapshotDataSize / 4- worldsnapshot.length, typeInfo.schema, generateSchema); snapshotGenerator.GenerateEntitySnapshot(id, ref writer); writer.Flush(); snapshotInfo.length = writer.GetLength();

case TransportEvent.Type.Data: OnData(e.connectionId, e.data, e.dataSize, clientNetworkConsumer, snapshotConsumer);break;

publicvoidProcessEntityUpdate(intserverTick,intid,ref NetworkReader reader){ var data = m_replicatedData[id]; GameDebug.Assert(data.lastServerUpdate < serverTick, "Failed to apply snapshot. Wrong tick order. entityId:{0} snapshot tick:{1} last server tick:{2}", id, serverTick, data.lastServerUpdate); data.lastServerUpdate = serverTick; GameDebug.Assert(data.serializableArray !=null,"Failed to apply snapshot. Serializablearray is null");foreach(varentryin data.serializableArray) entry.Deserialize(ref reader, serverTick); foreach(varentryin data.predictedArray) entry.Deserialize(ref reader, serverTick); foreach(varentryin data.interpolatedArray) entry.Deserialize(ref reader, serverTick); m_replicatedData[id] =data;}

[InitializeOnLoad]publicclassEditorLevelManager{static EditorLevelManager() { EditorApplication.playModeStateChanged += OnPlayModeStateChanged; } ... staticvoid OnPlayModeStateChanged(PlayModeStateChange mode) { if (mode == PlayModeStateChange.EnteredPlayMode) { ... caseLevelInfo.LevelType.Gameplay: Game.game.RequestGameLoop( typeof(PreviewGameLoop), new string[0]); break; } }

publicclass PreviewGameMode : BaseComponentSystem {...protectedoverridevoidOnUpdate(){if (m_Player.controlledEntity == Entity.Null) { Spawn(false);return; }}

CharacterSpawnRequest.Create(PostUpdateCommands, charControl.characterType, m_SpawnPos, m_SpawnRot, playerEntity);

publicstaticvoid CreateHandleSpawnSystems(GameWorld world,SystemCollection systems, BundledResourceManager resourceManager, boolserver){systems.Add(world.GetECSWorld().CreateManager<HandleCharacterSpawn>(world, resourceManager, server)); // TODO (mogensh) needs to be done first as it creates presentationsystems.Add(world.GetECSWorld().CreateManager<HandleAnimStateCtrlSpawn>(world));}

publicclass CharacterMoveQuery : MonoBehaviour{ publicvoid Initialize(Settings settings, Entity hitCollOwner) { //GameDebug.Log("CharacterMoveQuery.Initialize");this.settings =settings;var go = newGameObject("MoveColl_" + name,typeof(CharacterController),typeof(HitCollision));charController= go.GetComponent<CharacterController>();

class Movement_Update : BaseComponentDataSystem<CharBehaviour, AbilityControl, Ability_Movement.Settings>{protectedoverridevoid Update(Entity abilityEntity, CharBehaviour charAbility, AbilityControl abilityCtrl, Ability_Movement.Settings settings ) { // Calculate movement and move charactervar deltaPos = Vector3.zero; CalculateMovement(ref time, ref predictedState, ref command, ref deltaPos); // Setup movement query moveQuery.collisionLayer = character.teamId == 0? m_charCollisionALayer : m_charCollisionBLayer; moveQuery.moveQueryStart = predictedState.position; moveQuery.moveQueryEnd = moveQuery.moveQueryStart +(float3)deltaPos; EntityManager.SetComponentData(charAbility.character,predictedState); }}

class HandleMovementQueries : BaseComponentSystem{ protectedoverridevoid OnUpdate() { ... var deltaPos = query.moveQueryEnd -currentControllerPos;charController.Move(deltaPos);query.moveQueryResult= charController.transform.position; query.isGrounded = charController.isGrounded; Profiler.EndSample(); }}