void EnterActiveState()
{
m_GameWorld.RegisterSceneEntities();
m_resourceSystem = new BundledResourceManager(m_GameWorld, "BundledResources/Client");
// Create serializers so we get errors in preview build
var dataComponentSerializers = new DataComponentSerializers();
m_CharacterModule = new CharacterModulePreview(m_GameWorld, m_resourceSystem);
m_PlayerModuleClient = new PlayerModuleClient(m_GameWorld);
m_PlayerModuleServer = new PlayerModuleServer(m_GameWorld, m_resourceSystem);
m_UpdateReplicatedOwnerFlag = m_GameWorld.GetECSWorld().CreateSystem <UpdateReplicatedOwnerFlag>(m_GameWorld);
m_PlayerModuleClient.RegisterLocalPlayer(0, null);
// Spawn PlayerState, Character and link up LocalPlayer
m_Player = m_PlayerModuleServer.CreatePlayer(m_GameWorld, 0, "LocalMech", true);
var playerEntity = m_Player.gameObject.GetComponent <GameObjectEntity>().Entity;
//var charControl = m_Player.gameObject.GetComponent<PlayerCharacterControl>();
var charControl = m_GameWorld.GetEntityManager().GetComponentObject <PlayerCharacterControl>(playerEntity);
charControl.RequestedMechSettings = new MechSettings();
m_Player.teamIndex = 0;
m_previewGameMode = m_GameWorld.GetECSWorld().CreateSystem <PreviewGameMode>(m_GameWorld, m_Player);
Game.SetMousePointerLock(true);
}
public CharacterModulePreview(GameWorld world, BundledResourceManager resourceSystem) : base(world)
{
// Handle spawn requests
m_HandleCharacterSpawnRequests = m_world.GetECSWorld().CreateSystem <HandleCharacterSpawnRequests>(m_world, resourceSystem, false);
m_HandleCharacterDepawnRequests = m_world.GetECSWorld().CreateSystem <HandleCharacterDespawnRequests>(m_world);
// Handle spawning
CharacterBehaviours.CreateHandleSpawnSystems(m_world, m_HandleSpawnSystems, resourceSystem, false);
// Handle despawn
CharacterBehaviours.CreateHandleDespawnSystems(m_world, m_HandleDespawnSystems);
// Behaviors
CharacterBehaviours.CreateAbilityRequestSystems(m_world, m_AbilityRequestUpdateSystems);
//m_MovementStartSystems.Add(m_world.GetECSWorld().CreateManager<UpdateTeleportation>(m_world));
CharacterBehaviours.CreateMovementStartSystems(m_world, m_MovementStartSystems);
CharacterBehaviours.CreateMovementResolveSystems(m_world, m_MovementResolveSystems);
CharacterBehaviours.CreateAbilityStartSystems(m_world, m_AbilityStartSystems);
//CharacterBehaviours.CreateAbilityResolveSystems(m_world, m_AbilityResolveSystems);
m_UpdateCharPresentationState = m_world.GetECSWorld().CreateSystem <UpdateCharPresentationState>(m_world);
m_ApplyPresentationState = m_world.GetECSWorld().CreateSystem <ApplyPresentationState>(m_world);
m_characterCameraSystem = m_world.GetECSWorld().CreateSystem <UpdateCharacterCamera>(m_world);
m_UpdatePresentationRootTransform = m_world.GetECSWorld().CreateSystem <UpdatePresentationRootTransform>(m_world);
Console.AddCommand("thirdperson", CmdToggleThirdperson, "Toggle third person mode", this.GetHashCode());
}
public CharacterModuleServer(GameWorld world, BundledResourceManager resourceSystem) : base(world)
{
// Handle spawn requests
m_HandleCharacterSpawnRequests = m_world.GetECSWorld().CreateSystem <HandleCharacterSpawnRequests>(m_world, resourceSystem, true);
m_HandleCharacterDespawnRequests = m_world.GetECSWorld().CreateSystem <HandleCharacterDespawnRequests>(m_world);
// Handle spawn
CharacterBehaviours.CreateHandleSpawnSystems(m_world, m_HandleSpawnSystems, resourceSystem, true);
// Handle despawn
CharacterBehaviours.CreateHandleDespawnSystems(m_world, m_HandleDespawnSystems);
// Behavior
CharacterBehaviours.CreateAbilityRequestSystems(m_world, m_AbilityRequestUpdateSystems);
//m_MovementStartSystems.Add(m_world.GetECSWorld().CreateManager<UpdateTeleportation>(m_world));
CharacterBehaviours.CreateMovementStartSystems(m_world, m_MovementStartSystems);
CharacterBehaviours.CreateMovementResolveSystems(m_world, m_MovementResolveSystems);
CharacterBehaviours.CreateAbilityStartSystems(m_world, m_AbilityStartSystems);
//CharacterBehaviours.CreateAbilityResolveSystems(m_world, m_AbilityResolveSystems);
m_UpdateCharPresentationState = m_world.GetECSWorld().CreateSystem <UpdateCharPresentationState>(m_world);
m_ApplyPresentationState = m_world.GetECSWorld().CreateSystem <ApplyPresentationState>(m_world);
m_UpdatePresentationRootTransform = m_world.GetECSWorld().CreateSystem <UpdatePresentationRootTransform>(m_world);
}
public ReplicatedEntityModuleServer(GameWorld world, BundledResourceManager resourceSystem, NetworkServer network)
{
m_world = world;
m_assetRegistry = resourceSystem.GetResourceRegistry <ReplicatedEntityRegistry>();
m_entityCollection = new ReplicatedEntityCollection(m_world);
if (world.SceneRoot != null)
{
m_SystemRoot = new GameObject("ReplicatedEntitySystem");
m_SystemRoot.transform.SetParent(world.SceneRoot.transform);
}
m_handleSpawn = m_world.GetECSWorld().CreateManager <HandleReplicatedEntitySpawn>(m_world, m_SystemRoot, network,
m_assetRegistry, m_entityCollection);
m_handleDataSpawn = m_world.GetECSWorld().CreateManager <HandleReplicatedEntityDataSpawn>(m_world, network,
m_assetRegistry, m_entityCollection);
m_handleDespawn = m_world.GetECSWorld().CreateManager <HandleReplicatedEntityDespawn>(m_world, network,
m_entityCollection);
m_handleDataDespawn = m_world.GetECSWorld().CreateManager <HandleReplicatedEntityDataDespawn>(m_world, network,
m_entityCollection);
// Make sure all replicated entities are streamed in
for (var i = 0; i < m_assetRegistry.entries.Length; i++)
{
if (m_assetRegistry.entries[i].factory != null)
{
continue;
}
resourceSystem.LoadSingleAssetResource(m_assetRegistry.entries[i].prefab.guid);
}
}
public void LoadAllResources(BundledResourceManager resourceManager)
{
for (var i = 0; i < entries.Count; i++)
{
resourceManager.GetSingleAssetResource(entries[i].guid);
}
}
public MovableSystemServer(GameWorld world, BundledResourceManager bundledResourceManager)
{
m_GameWorld = world;
m_BundledResourceManager = bundledResourceManager;
Console.AddCommand("spawnbox", CmdSpawnBox, "Spawn <n> boxes", GetHashCode());
Console.AddCommand("despawnboxes", CmdDespawnBoxes, "Despawn all boxes", GetHashCode());
}
public ReplicatedEntityModuleClient(GameWorld world, BundledResourceManager resourceSystem)
{
m_world = world;
m_resourceSystem = resourceSystem;
m_assetRegistry = resourceSystem.GetResourceRegistry <ReplicatedEntityRegistry>();
m_entityCollection = new ReplicatedEntityCollection(m_world);
// Load all replicated entity resources
for (var i = 0; i < m_assetRegistry.entries.Length; i++)
{
if (m_assetRegistry.entries[i].factory != null)
{
continue;
}
var prefabGuid = m_assetRegistry.entries[i].prefab.guid;
m_resourceSystem.LoadSingleAssetResource(prefabGuid);
}
if (world.SceneRoot != null)
{
m_SystemRoot = new GameObject("ReplicatedEntitySystem");
m_SystemRoot.transform.SetParent(world.SceneRoot.transform);
}
}
public ReplicatedEntityModuleServer(GameWorld world, BundledResourceManager resourceSystem, NetworkServer network)
{
m_world = world;
m_assetRegistry = resourceSystem.GetResourceRegistry <ReplicatedEntityRegistry>();
m_entityCollection = new ReplicatedEntityCollection(m_world);
if (world.SceneRoot != null)
{
m_SystemRoot = new GameObject("ReplicatedEntitySystem");
m_SystemRoot.transform.SetParent(world.SceneRoot.transform);
}
m_handleDataSpawn = m_world.GetECSWorld().CreateManager <HandleReplicatedEntityDataSpawn>(m_world, network,
m_assetRegistry, m_entityCollection);
m_handleDataDespawn = m_world.GetECSWorld().CreateManager <HandleReplicatedEntityDataDespawn>(m_world, network,
m_entityCollection);
m_UpdateReplicatedOwnerFlag = m_world.GetECSWorld().CreateManager <UpdateReplicatedOwnerFlag>(m_world);
m_UpdateReplicatedOwnerFlag.SetLocalPlayerId(-1);
// Load all replicated entity resources
m_assetRegistry.LoadAllResources(resourceSystem);
}
/// <summary>
/// Active state, level loaded
/// </summary>
void EnterActiveState()
{
GameDebug.Assert(m_serverGameWorld == null);
m_GameWorld.RegisterSceneEntities();
m_ServerQueryProtocolServer.ServerInfoData.Map = Game.game.levelManager.currentLevel.name;
m_resourceSystem = new BundledResourceManager("BundledResources/Server");
m_NetworkServer.InitializeMap((ref NetworkWriter data) =>
{
data.WriteString("name", Game.game.levelManager.currentLevel.name);
});
m_serverGameWorld = new ServerGameWorld(m_GameWorld, m_NetworkServer, m_Clients, m_ChatSystem, m_resourceSystem);
foreach (var pair in m_Clients)
{
m_serverGameWorld.HandleClientConnect(pair.Value);
}
#if USE_UNET
//m_ServerBroadcast.gameInfo.levelname = Game.game.levelManager.currentLevel.name;
//m_ServerBroadcast.gameInfo.gamemode = "Deathmatch";
//m_ServerBroadcast.UpdateGameInfo();
#endif
}
public PlayerModuleServer(GameWorld gameWorld, BundledResourceManager resourceSystem)
{
m_settings = Resources.Load <PlayerModuleSettings>("PlayerModuleSettings");
m_resourceSystem = resourceSystem;
m_world = gameWorld;
}
public CharacterModuleServer(GameWorld world, BundledResourceManager resourceSystem) : base(world)
{
// Handle spawn requests
m_HandleCharacterSpawnRequests = m_world.GetECSWorld().CreateManager <HandleCharacterSpawnRequests>(m_world, resourceSystem, true);
m_HandleCharacterDespawnRequests = m_world.GetECSWorld().CreateManager <HandleCharacterDespawnRequests>(m_world);
// Handle controlled entity changed
CharacterBehaviours.CreateControlledEntityChangedSystems(m_world, m_ControlledEntityChangedSystems);
m_ControlledEntityChangedSystems.Add(m_world.GetECSWorld().CreateManager <PlayerCharacterControlSystem>(m_world));
// Handle spawn
CharacterBehaviours.CreateHandleSpawnSystems(m_world, m_HandleSpawnSystems, resourceSystem);
// Handle despawn
CharacterBehaviours.CreateHandleDespawnSystems(m_world, m_HandleSpawnSystems);
// Movement
m_MovementStartSystems.Add(m_world.GetECSWorld().CreateManager <UpdateTeleportation>(m_world));
CharacterBehaviours.CreateMovementStartSystems(m_world, m_MovementStartSystems);
CharacterBehaviours.CreateMovementResolveSystems(m_world, m_MovementResolveSystems);
// Ability
CharacterBehaviours.CreateAbilityStartSystems(m_world, m_AbilityStartSystems);
CharacterBehaviours.CreateAbilityResolveSystems(m_world, m_AbilityResolveSystems);
m_UpdateCharPresentationState = m_world.GetECSWorld().CreateManager <UpdateCharPresentationState>(m_world);
m_ApplyPresentationStateToCharacters = m_world.GetECSWorld().CreateManager <ApplyPresentationStateToCharacters>(m_world);
m_ApplyPresentationStateToItems = m_world.GetECSWorld().CreateManager <ApplyPresentationStateToItems>(m_world);
m_HandleDamage = m_world.GetECSWorld().CreateManager <HandleDamage>(m_world);
m_characterItemLateUpdate = m_world.GetECSWorld().CreateManager <CharacterItemLateUpdate>(m_world);
}
public HandleHitscanEffectRequests(GameWorld world, GameObject systemRoot, BundledResourceManager resourceSystem) : base(world)
{
var effectBundle = resourceSystem.GetResourceRegistry <HitscanEffectRegistry>();
GameDebug.Assert(effectBundle != null, "No HitscanEffectRegistry defined in registry");
m_Pools = new Pool[effectBundle.entries.Count];
for (var i = 0; i < effectBundle.entries.Count; i++)
{
var entry = effectBundle.entries[i];
var resource = resourceSystem.LoadSingleAssetResource(entry.prefab.guid);
GameDebug.Assert(resource != null);
var prefab = resource as GameObject;
GameDebug.Assert(prefab != null);
var pool = new Pool();
pool.instances = new HitscanEffect[entry.poolSize];
for (var j = 0; j < pool.instances.Length; j++)
{
var go = GameObject.Instantiate(prefab);
if (systemRoot != null)
{
go.transform.SetParent(systemRoot.transform, false);
}
pool.instances[j] = go.GetComponent <HitscanEffect>();
GameDebug.Assert(pool.instances[j], "Effect prefab does not have HitscanEffect component");
}
m_Pools[i] = pool;
}
}
public HandleClientProjectileRequests(GameWorld world, BundledResourceManager resourceSystem, GameObject systemRoot,
ClientProjectileFactory clientProjectileFactory) : base(world)
{
m_resourceSystem = resourceSystem;
m_SystemRoot = systemRoot;
m_settings = Resources.Load <ProjectileModuleSettings>("ProjectileModuleSettings");
m_clientProjectileFactory = clientProjectileFactory;
}
public CharacterModulePreview(GameWorld world, BundledResourceManager resourceSystem) : base(world)
{
// Handle spawn requests
m_HandleCharacterSpawnRequests = m_world.GetECSWorld().CreateManager <HandleCharacterSpawnRequests>(m_world, resourceSystem, false);
m_HandleCharacterDepawnRequests = m_world.GetECSWorld().CreateManager <HandleCharacterDespawnRequests>(m_world);
// Handle control change
m_ControlledEntityChangedSystems.Add(m_world.GetECSWorld().CreateManager <PlayerCharacterControlSystem>(m_world));
m_ControlledEntityChangedSystems.Add(m_world.GetECSWorld().CreateManager <UpdateCharacter1PSpawn>(m_world, resourceSystem));
// Handle spawning
CharacterBehaviours.CreateHandleSpawnSystems(m_world, m_HandleSpawnSystems, resourceSystem, false);
// Handle despawn
CharacterBehaviours.CreateHandleDespawnSystems(m_world, m_HandleDespawnSystems);
// Movement
m_MovementStartSystems.Add(m_world.GetECSWorld().CreateManager <UpdateTeleportation>(m_world));
CharacterBehaviours.CreateMovementStartSystems(m_world, m_MovementStartSystems);
CharacterBehaviours.CreateMovementResolveSystems(m_world, m_MovementResolveSystems);
// Ability
CharacterBehaviours.CreateAbilityStartSystems(m_world, m_AbilityStartSystems);
CharacterBehaviours.CreateAbilityResolveSystems(m_world, m_AbilityResolveSystems);
m_UpdateCharPresentationState = m_world.GetECSWorld().CreateManager <UpdateCharPresentationState>(m_world);
m_ApplyPresentationState = m_world.GetECSWorld().CreateManager <ApplyPresentationState>(m_world);
m_CharacterLateUpdate = m_world.GetECSWorld().CreateManager <CharacterLateUpdate>(m_world);
m_HandleDamage = m_world.GetECSWorld().CreateManager <HandleDamage>(m_world);
m_updateCharacterUI = m_world.GetECSWorld().CreateManager <UpdateCharacterUI>(m_world);
m_characterCameraSystem = m_world.GetECSWorld().CreateManager <UpdateCharacterCamera>(m_world);
m_UpdatePresentationRootTransform = m_world.GetECSWorld().CreateManager <UpdatePresentationRootTransform>(m_world);
m_UpdatePresentationAttachmentTransform = m_world.GetECSWorld().CreateManager <UpdatePresentationAttachmentTransform>(m_world);
m_HandleCharacterEvents = m_world.GetECSWorld().CreateManager <HandleCharacterEvents>();
// Preload all character resources (until we have better streaming solution)
var charRegistry = resourceSystem.GetResourceRegistry <CharacterTypeRegistry>();
for (var i = 0; i < charRegistry.entries.Count; i++)
{
resourceSystem.LoadSingleAssetResource(charRegistry.entries[i].prefab1P.guid);
resourceSystem.LoadSingleAssetResource(charRegistry.entries[i].prefabClient.guid);
}
var itemRegistry = resourceSystem.GetResourceRegistry <ItemRegistry>();
for (var i = 0; i < itemRegistry.entries.Count; i++)
{
resourceSystem.LoadSingleAssetResource(itemRegistry.entries[i].prefab1P.guid);
resourceSystem.LoadSingleAssetResource(itemRegistry.entries[i].prefabClient.guid);
}
Console.AddCommand("thirdperson", CmdToggleThirdperson, "Toggle third person mode", this.GetHashCode());
}
public void LoadSettings(BundledResourceManager resourceSystem)
{
var projectileRegistry = resourceSystem.GetResourceRegistry <ProjectileRegistry>();
var index = projectileRegistry.GetIndexByRegistryId(projectileTypeRegistryId);
settings = projectileRegistry.entries[index].definition.properties;
maxAge = Vector3.Magnitude(endPos - startPos) / settings.velocity;
}
public EffectModuleClient(GameWorld world, BundledResourceManager resourceSystem)
{
m_GameWorld = world;
m_resourceSystem = resourceSystem;
m_HandleSpatialEffectRequests = m_GameWorld.GetECSWorld().CreateManager <HandleSpatialEffectRequests>(m_GameWorld);
m_HandleHitscanEffectRequests = m_GameWorld.GetECSWorld().CreateManager <HandleHitscanEffectRequests>(m_GameWorld);
m_VFXSystem = m_GameWorld.GetECSWorld().CreateManager <VFXSystem>();
}
public ProjectileModuleServer(GameWorld gameWorld, BundledResourceManager resourceSystem)
{
m_GameWorld = gameWorld;
m_handleRequests = m_GameWorld.GetECSWorld().CreateSystem <HandleServerProjectileRequests>(m_GameWorld, resourceSystem);
m_CreateMovementQueries = m_GameWorld.GetECSWorld().CreateSystem <CreateProjectileMovementCollisionQueries>(m_GameWorld);
m_HandleMovementQueries = m_GameWorld.GetECSWorld().CreateSystem <HandleProjectileMovementCollisionQuery>(m_GameWorld);
m_DespawnProjectiles = m_GameWorld.GetECSWorld().CreateSystem <DespawnProjectiles>(m_GameWorld);
}
public ProjectileModuleServer(GameWorld gameWorld, BundledResourceManager resourceSystem)
{
m_GameWorld = gameWorld;
m_handleRequests = World.DefaultGameObjectInjectionWorld.CreateSystem <HandleServerProjectileRequests>(resourceSystem);
m_CreateMovementQueries = World.DefaultGameObjectInjectionWorld.CreateSystem <CreateProjectileMovementCollisionQueries>();
m_HandleMovementQueries = World.DefaultGameObjectInjectionWorld.CreateSystem <HandleProjectileMovementCollisionQuery>();
m_DespawnProjectiles = World.DefaultGameObjectInjectionWorld.CreateSystem <DespawnProjectiles>();
}
public override Entity Create(EntityManager entityManager, BundledResourceManager resourceManager,
GameWorld world, ushort type)
{
var e = ClientCharacterUtilities.CreateCharacter(entityManager, float3.zero);
entityManager.AddComponentData(e, new NewServerEntity()
{
Tick = 1
});
// entityManager.AddComponentData(e, new UpdateUI());
return(e);
}
public override Entity Create(EntityManager entityManager, BundledResourceManager resourceManager,
GameWorld world, ushort type)
{
var entity = entityManager.CreateEntity(typeof(ReplicatedEntityData),
typeof(ProjectileData));
var repData = new ReplicatedEntityData(guid);
entityManager.SetComponentData(entity, repData);
// GameDebug.Log("ProjectileEntityFactory.Crate entity:" + entity + " typeId:" + repData.typeId + " id:" + repData.id);
return(entity);
}
public EffectModuleClient(GameWorld world, BundledResourceManager resourceSystem)
{
m_GameWorld = world;
m_resourceSystem = resourceSystem;
if (world.SceneRoot != null)
{
m_SystemRoot = new GameObject("EffectSystem");
m_SystemRoot.transform.SetParent(world.SceneRoot.transform);
}
m_HandleSpatialEffectRequests = m_GameWorld.GetECSWorld().CreateManager <HandleSpatialEffectRequests>(m_GameWorld, m_SystemRoot, m_resourceSystem);
m_HandleHitscanEffectRequests = m_GameWorld.GetECSWorld().CreateManager <HandleHitscanEffectRequests>(m_GameWorld, m_SystemRoot, m_resourceSystem);
}
public ServerGameWorld(GameWorld world, BundledResourceManager resourceSystem, Dictionary <int, ServerGameLoop.ClientInfo> clients, NetworkServer networkServer)
{
_gameWorld = world;
_networkServer = networkServer;
m_Clients = clients;
m_PlayerModule = new PlayerModuleServer(_gameWorld, resourceSystem);
m_CharacterModule = new CharacterModuleServer(_gameWorld, resourceSystem);
m_ReplicatedEntityModule = new ReplicatedEntityModuleServer(_gameWorld, resourceSystem, networkServer);
m_ReplicatedEntityModule.ReserveSceneEntities(networkServer);
movableSystemServer = new MovableSystemServer(_gameWorld, resourceSystem);
m_GameModeSystem = _gameWorld.GetECSWorld().CreateSystem <GameModeSystemServer>(_gameWorld);
}
public BonusModuleClient(GameWorld world, BundledResourceManager resourceSystem)
{
m_world = world;
var bonusRegistry = resourceSystem.GetResourceRegistry <BonusRegistry>();
foreach (var entry in bonusRegistry.entries)
{
resourceSystem.LoadSingleAssetResource(entry.prefabClient.guid);
}
m_handleSpawnSystems.Add(world.GetECSWorld().CreateManager <HandleBonusSpawnPointInitServer>(world));
m_systems.Add(m_world.GetECSWorld().CreateManager <BonusSpawnerUpdateSystemClient>(world, resourceSystem));
//m_systems.Add(m_world.GetECSWorld().CreateManager<BonusUpdateSystemServer>(world));
}
public Character SpawnCharacter(GameWorld world, PlayerState owner, Vector3 position, Quaternion rotation,
int heroIndex, BundledResourceManager resourceSystem)
{
var heroTypeRegistry = resourceSystem.GetResourceRegistry <HeroTypeRegistry>();
heroIndex = Mathf.Min(heroIndex, heroTypeRegistry.entries.Count);
var heroTypeAsset = heroTypeRegistry.entries[heroIndex];
var charPrefabGUID = m_settings.characterPrefab.guid;
var charResource = resourceSystem.LoadSingleAssetResource(charPrefabGUID);
if (charResource == null)
{
GameDebug.LogError("BundledResourceManager Cant find resource with guid:" + charPrefabGUID);
return(null);
}
var charPrefab = (GameObject)charResource;
var charGameObjectEntity = world.Spawn <GameObjectEntity>(charPrefab);
charGameObjectEntity.name = string.Format("{0}_{1}", charPrefab.name, owner.playerName);
GameDebug.Log("Spawning character:" + charGameObjectEntity.name + " tick:" + m_world.worldTime.tick);
var charEntity = charGameObjectEntity.Entity;
// Set as predicted by owner
var replicatedEntity = EntityManager.GetComponentObject <ReplicatedEntity>(charEntity);
replicatedEntity.predictingPlayerId = owner.playerId;
var character = EntityManager.GetComponentObject <Character>(charEntity);
character.heroTypeIndex = heroIndex;
character.teamId = 0;
character.TeleportTo(position, rotation);
character.behaviourController = heroTypeAsset.behaviorsController.Create(EntityManager, owner.playerId);
// TODO (mogensh) support multiple weapons (for now we just take first)
if (heroTypeAsset.items.Length > 0)
{
character.item = heroTypeAsset.items[0].itemType.Create(EntityManager, owner.playerId);
var itemState = EntityManager.GetComponentData <ItemTypeDefinition.State>(character.item);
itemState.character = charEntity;
EntityManager.SetComponentData(character.item, itemState);
}
return(character);
}
private void EnterPlayingState()
{
GameDebug.Assert(_gameWorld == null && Game.Instance.levelManager.IsCurrentLevelLoaded());
_gameWorld = new GameWorld("ClientWorld");
_gameWorld.RegisterSceneEntities();
m_resourceSystem = new BundledResourceManager(_gameWorld, "BundledResources/Client");
_clientGameWorld = new ClientGameWorld(_gameWorld, _networkClient, _networkStatisticsClient, m_resourceSystem);
m_LocalPlayer = _clientGameWorld.RegisterLocalPlayer(_networkClient.clientId);
_networkClient.QueueEvent((ushort)GameNetworkEvents.EventType.PlayerReady, true, (ref NetworkWriter data) => { });
}
/* public class GetDropdownValueClass : GetDropdownValue
* {
* public GetDropdownValueClass()
* {
* //GameModeSystemServer newGMSS = new GameModeSystemServer();
* //newGMSS.SelectedCharacter = characterTypeValue;
* }
* } */
public GameModeSystemServer(GameWorld world, ChatSystemServer chatSystem, BundledResourceManager resourceSystem)
{
m_World = world;
m_ResourceSystem = resourceSystem;
this.chatSystem = chatSystem;
m_CurrentGameModeName = "";
// TODO (petera) Get rid of need for loading these 'settings' and the use of them below.
// We need a way to spawn a 'naked' replicated entity, i.e. one that is not created from a prefab.
m_Settings = Resources.Load <GameModeSystemSettings>("GameModeSystemSettings");
// Create game mode state
var prefab = (GameObject)resourceSystem.GetSingleAssetResource(m_Settings.gameModePrefab);
gameModeState = m_World.Spawn <GameMode>(prefab);
}
void EnterPlayingState()
{
GameDebug.Assert(m_clientWorld == null && Game.game.levelManager.IsCurrentLevelLoaded());
m_GameWorld.RegisterSceneEntities();
m_resourceSystem = new BundledResourceManager("BundledResources/Client");
m_clientWorld = new ClientGameWorld(m_GameWorld, m_NetworkClient, m_NetworkStatistics, m_resourceSystem);
m_clientWorld.PredictionEnabled = m_predictionEnabled;
m_LocalPlayer = m_clientWorld.RegisterLocalPlayer(m_NetworkClient.clientId);
m_NetworkClient.QueueEvent((ushort)GameNetworkEvents.EventType.PlayerReady, true, (ref NetworkWriter data) => {});
m_ClientState = ClientState.Playing;
}
public Entity Create(EntityManager entityManager, BundledResourceManager resourceManager,
GameWorld world, ReplicatedEntity repEntity)
{
var prefab = repEntity.gameObject;
if (prefab == null)
{
GameDebug.LogError("Cant create. Not gameEntityType. GameEntityTypeDefinition:" + name);
return(Entity.Null);
}
var gameObjectEntity = world.Spawn <GameObjectEntity>(prefab);
gameObjectEntity.name = string.Format("{0}", prefab.name);
var entity = gameObjectEntity.Entity;
return(entity);
}
public ReplicatedEntityModuleClient(GameWorld world, BundledResourceManager resourceSystem)
{
m_world = world;
m_resourceSystem = resourceSystem;
m_assetRegistry = resourceSystem.GetResourceRegistry <ReplicatedEntityRegistry>();
m_entityCollection = new ReplicatedEntityCollection(m_world);
m_UpdateReplicatedOwnerFlag = m_world.GetECSWorld().CreateSystem <UpdateReplicatedOwnerFlag>(m_world);
// Load all replicated entity resources
m_assetRegistry.LoadAllResources(resourceSystem);
if (world.SceneRoot != null)
{
m_SystemRoot = new GameObject("ReplicatedEntitySystem");
m_SystemRoot.transform.SetParent(world.SceneRoot.transform);
}
}
/// <summary>
/// Active state, level loaded
/// </summary>
void EnterActiveState()
{
GameDebug.Assert(m_serverGameWorld == null);
m_GameWorld.RegisterSceneEntities();
m_resourceSystem = new BundledResourceManager(m_GameWorld, "BundledResources/Server");
m_NetworkServer.InitializeMap((ref NetworkWriter data) =>
{
data.WriteString("name", Game.game.levelManager.currentLevel.name);
});
m_serverGameWorld = new ServerGameWorld(m_GameWorld, m_NetworkServer, m_Clients, m_ChatSystem, m_resourceSystem);
foreach (var pair in m_Clients)
{
m_serverGameWorld.HandleClientConnect(pair.Value);
}
}
