public ServerManager(NetworkManager networkManager, Game.Settings.GameSettings gameSettings, PacketManager packetManager) { _netServer = networkManager.GetNetServer(); _gameSettings = gameSettings; _playerData = new ConcurrentDictionary <ushort, ServerPlayerData>(); // Register packet handlers packetManager.RegisterServerPacketHandler <HelloServerPacket>(PacketId.HelloServer, OnHelloServer); packetManager.RegisterServerPacketHandler <ServerPlayerEnterScenePacket>(PacketId.PlayerEnterScene, OnClientEnterScene); packetManager.RegisterServerPacketHandler <ServerPlayerLeaveScenePacket>(PacketId.PlayerLeaveScene, OnClientLeaveScene); packetManager.RegisterServerPacketHandler <ServerUpdatePacket>(PacketId.PlayerUpdate, OnPlayerUpdate); packetManager.RegisterServerPacketHandler <ServerPlayerDisconnectPacket>(PacketId.PlayerDisconnect, OnPlayerDisconnect); packetManager.RegisterServerPacketHandler <ServerPlayerDeathPacket>(PacketId.PlayerDeath, OnPlayerDeath); packetManager.RegisterServerPacketHandler <ServerPlayerTeamUpdatePacket>(PacketId.PlayerTeamUpdate, OnPlayerTeamUpdate); packetManager.RegisterServerPacketHandler <ServerDreamshieldSpawnPacket>(PacketId.DreamshieldSpawn, OnDreamshieldSpawn); packetManager.RegisterServerPacketHandler <ServerDreamshieldDespawnPacket>(PacketId.DreamshieldDespawn, OnDreamshieldDespawn); packetManager.RegisterServerPacketHandler <ServerDreamshieldUpdatePacket>(PacketId.DreamshieldUpdate, OnDreamshieldUpdate); // Register server shutdown handler _netServer.RegisterOnShutdown(OnServerShutdown); // Register application quit handler ModHooks.Instance.ApplicationQuitHook += OnApplicationQuit; }
public void ReadPacket() { GameSettings = new Game.Settings.GameSettings(); // Use reflection to loop over all properties and set their value by reading from the packet foreach (var prop in GameSettings.GetType().GetProperties()) { if (!prop.CanWrite) { continue; } // ReSharper disable once OperatorIsCanBeUsed if (prop.PropertyType == typeof(bool)) { prop.SetValue(GameSettings, ReadBool(), null); } else if (prop.PropertyType == typeof(int)) { prop.SetValue(GameSettings, ReadInt(), null); } else { Logger.Warn(this, $"No read handler for property type: {prop.GetType()}"); } } }
public ServerManager( NetServer netServer, Game.Settings.GameSettings gameSettings, PacketManager packetManager ) { _netServer = netServer; _gameSettings = gameSettings; _playerData = new ConcurrentDictionary <ushort, ServerPlayerData>(); // Register packet handlers packetManager.RegisterServerPacketHandler <HelloServer>(ServerPacketId.HelloServer, OnHelloServer); packetManager.RegisterServerPacketHandler <ServerPlayerEnterScene>(ServerPacketId.PlayerEnterScene, OnClientEnterScene); packetManager.RegisterServerPacketHandler(ServerPacketId.PlayerLeaveScene, OnClientLeaveScene); packetManager.RegisterServerPacketHandler <PlayerUpdate>(ServerPacketId.PlayerUpdate, OnPlayerUpdate); packetManager.RegisterServerPacketHandler <EntityUpdate>(ServerPacketId.EntityUpdate, OnEntityUpdate); packetManager.RegisterServerPacketHandler(ServerPacketId.PlayerDisconnect, OnPlayerDisconnect); packetManager.RegisterServerPacketHandler(ServerPacketId.PlayerDeath, OnPlayerDeath); packetManager.RegisterServerPacketHandler <ServerPlayerTeamUpdate>(ServerPacketId.PlayerTeamUpdate, OnPlayerTeamUpdate); packetManager.RegisterServerPacketHandler <ServerPlayerSkinUpdate>(ServerPacketId.PlayerSkinUpdate, OnPlayerSkinUpdate); packetManager.RegisterServerPacketHandler <ServerPlayerEmoteUpdate>(ServerPacketId.PlayerEmoteUpdate, OnPlayerEmoteUpdate); // Register a heartbeat handler _netServer.RegisterOnClientHeartBeat(OnClientHeartBeat); // Register server shutdown handler _netServer.RegisterOnShutdown(OnServerShutdown); // TODO: make game/console app independent quit handler // Register application quit handler // ModHooks.Instance.ApplicationQuitHook += OnApplicationQuit; }
public void UpdateGameSettings(Game.Settings.GameSettings gameSettings) { lock (CurrentUpdatePacket) { CurrentUpdatePacket.DataPacketIds.Add(ClientPacketId.GameSettingsUpdated); CurrentUpdatePacket.GameSettingsUpdate.GameSettings = gameSettings; } }
public void ReplaceGameSettings(Game.Settings.GameSettings newValue) { var index = GameComponentsLookup.GameSettings; var component = CreateComponent <GameSettingsComponent>(index); component.value = newValue; ReplaceComponent(index, component); }
public GameEntity SetGameSettings(Game.Settings.GameSettings newValue) { if (hasGameSettings) { throw new Entitas.EntitasException("Could not set GameSettings!\n" + this + " already has an entity with GameSettingsComponent!", "You should check if the context already has a gameSettingsEntity before setting it or use context.ReplaceGameSettings()."); } var entity = CreateEntity(); entity.AddGameSettings(newValue); return(entity); }
public void ReplaceGameSettings(Game.Settings.GameSettings newValue) { var entity = gameSettingsEntity; if (entity == null) { entity = SetGameSettings(newValue); } else { entity.ReplaceGameSettings(newValue); } }
public PlayerManager(PacketManager packetManager, Game.Settings.GameSettings gameSettings) { _gameSettings = gameSettings; _skinManager = new SkinManager(); _playerData = new Dictionary <ushort, ClientPlayerData>(); // Create the player prefab, used to instantiate player objects _playerPrefab = new GameObject( "PlayerPrefab", typeof(BoxCollider2D), typeof(DamageHero), typeof(EnemyHitEffectsUninfected), typeof(MeshFilter), typeof(MeshRenderer), typeof(NonBouncer), typeof(SpriteFlash), typeof(tk2dSprite), typeof(tk2dSpriteAnimator), typeof(CoroutineCancelComponent) ) { layer = 9 }; // Add some extra gameObjects related to animation effects new GameObject("Attacks") { layer = 9 }.transform.SetParent(_playerPrefab.transform); new GameObject("Effects") { layer = 9 }.transform.SetParent(_playerPrefab.transform); new GameObject("Spells") { layer = 9 }.transform.SetParent(_playerPrefab.transform); _playerPrefab.SetActive(false); Object.DontDestroyOnLoad(_playerPrefab); // Register packet handlers packetManager.RegisterClientPacketHandler <ClientPlayerTeamUpdate>(ClientPacketId.PlayerTeamUpdate, OnPlayerTeamUpdate); packetManager.RegisterClientPacketHandler <ClientPlayerSkinUpdate>(ClientPacketId.PlayerSkinUpdate, OnPlayerSkinUpdate); }
public ClientSettingsUI( Game.Settings.GameSettings clientGameSettings, ClientManager clientManager, GameObject settingsUiObject, GameObject connectUiObject ) { _clientManager = clientManager; _clientGameSettings = clientGameSettings; _settingsUiObject = settingsUiObject; _connectUiObject = connectUiObject; CreateSettingsUI(); }
public ServerSettingsInterface( Game.Settings.GameSettings gameSettings, ModSettings modSettings, ServerManager serverManager, ComponentGroup settingsGroup, ComponentGroup connectGroup ) { _gameSettings = gameSettings; _modSettings = modSettings; _serverManager = serverManager; _settingsGroup = settingsGroup; _connectGroup = connectGroup; CreateSettings(); CreateSettingsUI(); }
public ServerSettingsUI( Game.Settings.GameSettings gameSettings, ModSettings modSettings, ServerManager serverManager, GameObject settingsUiObject, GameObject connectUiObject ) { _gameSettings = gameSettings; _modSettings = modSettings; _serverManager = serverManager; _settingsUiObject = settingsUiObject; _connectUiObject = connectUiObject; CreateSettings(); CreateSettingsUI(); }
public MapManager(NetworkManager networkManager, Game.Settings.GameSettings gameSettings) { _netClient = networkManager.GetNetClient(); _gameSettings = gameSettings; _mapIcons = new ConcurrentDictionary <int, GameObject>(); _netClient.RegisterOnDisconnect(OnDisconnect); // Register a hero controller update callback, so we can update the map icon position On.HeroController.Update += HeroControllerOnUpdate; // Register when the player closes their map, so we can hide the icons On.GameMap.CloseQuickMap += OnCloseQuickMap; // Register when the player opens their map, which is when the compass position is calculated On.GameMap.PositionCompass += OnPositionCompass; }
public ClientSettingsUI( ModSettings modSettings, Game.Settings.GameSettings clientGameSettings, ClientManager clientManager, UIGroup settingsGroup, UIGroup connectGroup, PingUI pingUi ) { _modSettings = modSettings; _clientManager = clientManager; _clientGameSettings = clientGameSettings; _settingsGroup = settingsGroup; _connectGroup = connectGroup; _pingUi = pingUi; CreateSettingsUI(); }
public ClientSettingsInterface( ModSettings modSettings, Game.Settings.GameSettings clientGameSettings, ClientManager clientManager, ComponentGroup settingsGroup, ComponentGroup connectGroup, PingInterface pingInterface ) { _modSettings = modSettings; _clientManager = clientManager; _clientGameSettings = clientGameSettings; _settingsGroup = settingsGroup; _connectGroup = connectGroup; _pingInterface = pingInterface; CreateSettingsUi(); }
public GameManager(ModSettings modSettings) { ThreadUtil.Instantiate(); FontManager.LoadFonts(); TextureManager.LoadTextures(); var packetManager = new PacketManager(); var networkManager = new NetworkManager(packetManager); var clientGameSettings = new Game.Settings.GameSettings(); var serverGameSettings = modSettings.GameSettings ?? new Game.Settings.GameSettings(); var playerManager = new PlayerManager(packetManager, clientGameSettings); var animationManager = new AnimationManager(networkManager, playerManager, packetManager, clientGameSettings); var mapManager = new MapManager(networkManager, clientGameSettings); var clientManager = new ClientManager( networkManager, playerManager, animationManager, mapManager, clientGameSettings, packetManager ); var serverManager = new ServerManager(networkManager.GetNetServer(), serverGameSettings, packetManager); new UI.UIManager( serverManager, clientManager, clientGameSettings, serverGameSettings, modSettings, networkManager.GetNetClient() ); }
public ClientSettingsInterface( ModSettings modSettings, Game.Settings.GameSettings clientGameSettings, ComponentGroup settingsGroup, ComponentGroup connectGroup, PingInterface pingInterface ) { settingsGroup.SetActive(false); _clientGameSettings = clientGameSettings; var x = 1920f - 210f; var y = 1080f - 100f; new TextComponent( settingsGroup, new Vector2(x, y), new Vector2(240f, ButtonComponent.DefaultHeight), "Settings", UiManager.HeaderFontSize, alignment: TextAnchor.MiddleLeft ); var closeButton = new ButtonComponent( settingsGroup, new Vector2(x + 240f / 2f - ButtonComponent.DefaultHeight / 2f, y), new Vector2(ButtonComponent.DefaultHeight, ButtonComponent.DefaultHeight), "", TextureManager.CloseButtonBg, FontManager.UIFontRegular, UiManager.NormalFontSize ); closeButton.SetOnPress(() => { settingsGroup.SetActive(false); connectGroup.SetActive(true); }); y -= ButtonComponent.DefaultHeight + 30f; var skinSetting = new SettingsEntryInterface( settingsGroup, new Vector2(x, y), "Player skin ID", typeof(byte), 0, 0, o => { OnSkinIdChange?.Invoke((byte)o); }, true ); skinSetting.SetInteractable(false); _skinCondition = new CompoundCondition( () => skinSetting.SetInteractable(true), () => skinSetting.SetInteractable(false), false, true ); y -= InputComponent.DefaultHeight + 8f; new SettingsEntryInterface( settingsGroup, new Vector2(x, y), "Display ping", typeof(bool), false, modSettings.DisplayPing, o => { var newValue = (bool)o; modSettings.DisplayPing = newValue; pingInterface.SetEnabled(newValue); }, true ); y -= SettingsEntryInterface.CheckboxSize + 8f; var teamRadioButton = new RadioButtonBoxComponent( settingsGroup, new Vector2(x, y), "Team selection", new[] { "None", "Moss", "Hive", "Grimm", "Lifeblood", }, 0 ); // Make it non-interactable by default teamRadioButton.SetInteractable(false); _teamCondition = new CompoundCondition( () => teamRadioButton.SetInteractable(true), () => { teamRadioButton.SetInteractable(false); teamRadioButton.Reset(); }, false, false, true ); teamRadioButton.SetOnChange(value => { if (!_clientGameSettings.TeamsEnabled) { return; } OnTeamRadioButtonChange?.Invoke((Team)value); }); }
public UiManager( Game.Settings.GameSettings clientGameSettings, ModSettings modSettings, NetClient netClient ) { _modSettings = modSettings; // First we create a gameObject that will hold all other objects of the UI UiGameObject = new GameObject(); // Create event system object var eventSystemObj = new GameObject("EventSystem"); var eventSystem = eventSystemObj.AddComponent <EventSystem>(); eventSystem.sendNavigationEvents = true; eventSystem.pixelDragThreshold = 10; eventSystemObj.AddComponent <StandaloneInputModule>(); Object.DontDestroyOnLoad(eventSystemObj); // Make sure that our UI is an overlay on the screen UiGameObject.AddComponent <Canvas>().renderMode = RenderMode.ScreenSpaceOverlay; // Also scale the UI with the screen size var canvasScaler = UiGameObject.AddComponent <CanvasScaler>(); canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize; canvasScaler.referenceResolution = new Vector2(1920f, 1080f); UiGameObject.AddComponent <GraphicRaycaster>(); Object.DontDestroyOnLoad(UiGameObject); PrecacheText(); var uiGroup = new ComponentGroup(); var pauseMenuGroup = new ComponentGroup(false, uiGroup); var connectGroup = new ComponentGroup(parent: pauseMenuGroup); var settingsGroup = new ComponentGroup(parent: pauseMenuGroup); ConnectInterface = new ConnectInterface( modSettings, connectGroup, settingsGroup ); var inGameGroup = new ComponentGroup(parent: uiGroup); var infoBoxGroup = new ComponentGroup(parent: inGameGroup); InternalChatBox = new ChatBox(infoBoxGroup, modSettings); var pingGroup = new ComponentGroup(parent: inGameGroup); _pingInterface = new PingInterface( pingGroup, modSettings, netClient ); SettingsInterface = new ClientSettingsInterface( modSettings, clientGameSettings, settingsGroup, connectGroup, _pingInterface ); // Register callbacks to make sure the UI is hidden and shown at correct times On.UIManager.SetState += (orig, self, state) => { orig(self, state); if (state == UIState.PAUSED) { // Only show UI in gameplay scenes if (!SceneUtil.IsNonGameplayScene(SceneUtil.GetCurrentSceneName())) { _canShowPauseUi = true; pauseMenuGroup.SetActive(!_isUiHiddenByKeyBind); } inGameGroup.SetActive(false); } else { pauseMenuGroup.SetActive(false); _canShowPauseUi = false; // Only show chat box UI in gameplay scenes if (!SceneUtil.IsNonGameplayScene(SceneUtil.GetCurrentSceneName())) { inGameGroup.SetActive(true); } } }; UnityEngine.SceneManagement.SceneManager.activeSceneChanged += (oldScene, newScene) => { if (SceneUtil.IsNonGameplayScene(newScene.name)) { eventSystem.enabled = false; _canShowPauseUi = false; pauseMenuGroup.SetActive(false); inGameGroup.SetActive(false); } else { eventSystem.enabled = true; inGameGroup.SetActive(true); } }; // The game is automatically unpaused when the knight dies, so we need // to disable the UI menu manually // TODO: this still gives issues, since it displays the cursor while we are supposed to be unpaused ModHooks.AfterPlayerDeadHook += () => { pauseMenuGroup.SetActive(false); }; MonoBehaviourUtil.Instance.OnUpdateEvent += () => { CheckKeyBinds(uiGroup); }; }
//private event Action ServerKnightChangeEvent; public ClientManager( NetworkManager networkManager, PlayerManager playerManager, AnimationManager animationManager, MapManager mapManager, Game.Settings.GameSettings gameSettings, PacketManager packetManager ) { _netClient = networkManager.GetNetClient(); _playerManager = playerManager; _animationManager = animationManager; _mapManager = mapManager; _gameSettings = gameSettings; _entityManager = new EntityManager(_netClient); new PauseManager(_netClient).RegisterHooks(); _heartBeatReceiveStopwatch = new Stopwatch(); // Register packet handlers packetManager.RegisterClientPacketHandler(ClientPacketId.ServerShutdown, OnServerShutdown); packetManager.RegisterClientPacketHandler <PlayerConnect>(ClientPacketId.PlayerConnect, OnPlayerConnect); packetManager.RegisterClientPacketHandler <ClientPlayerDisconnect>(ClientPacketId.PlayerDisconnect, OnPlayerDisconnect); packetManager.RegisterClientPacketHandler <ClientPlayerEnterScene>(ClientPacketId.PlayerEnterScene, OnPlayerEnterScene); packetManager.RegisterClientPacketHandler <ClientPlayerAlreadyInScene>(ClientPacketId.PlayerAlreadyInScene, OnPlayerAlreadyInScene); packetManager.RegisterClientPacketHandler <GenericClientData>(ClientPacketId.PlayerLeaveScene, OnPlayerLeaveScene); packetManager.RegisterClientPacketHandler <PlayerUpdate>(ClientPacketId.PlayerUpdate, OnPlayerUpdate); packetManager.RegisterClientPacketHandler <EntityUpdate>(ClientPacketId.EntityUpdate, OnEntityUpdate); packetManager.RegisterClientPacketHandler <GameSettingsUpdate>(ClientPacketId.GameSettingsUpdated, OnGameSettingsUpdated); // Register the Hero Controller Start, which is when the local player spawns On.HeroController.Start += (orig, self) => { // Execute the original method orig(self); // If we are connect to a server, add a username to the player object if (networkManager.GetNetClient().IsConnected) { _playerManager.AddNameToPlayer(HeroController.instance.gameObject, _username, _playerManager.LocalPlayerTeam); } }; networkManager.GetNetClient().RegisterOnConnect(() => { // We should only be able to connect during a gameplay scene, // which is when the player is spawned already, so we can add the username _playerManager.AddNameToPlayer(HeroController.instance.gameObject, _username, _playerManager.LocalPlayerTeam); }); // Register handlers for scene change and player update UnityEngine.SceneManagement.SceneManager.activeSceneChanged += OnSceneChange; On.HeroController.Update += OnPlayerUpdate; // Register client connect handler _netClient.RegisterOnConnect(OnClientConnect); _netClient.RegisterOnHeartBeat(OnHeartBeat); // Register application quit handler ModHooks.Instance.ApplicationQuitHook += OnApplicationQuit; }
public UIManager( ServerManager serverManager, ClientManager clientManager, Game.Settings.GameSettings clientGameSettings, Game.Settings.GameSettings serverGameSettings, ModSettings modSettings ) { _modSettings = modSettings; // First we create a gameObject that will hold all other objects of the UI var topUiObject = new GameObject(); // Create event system object var eventSystemObj = new GameObject("EventSystem"); var eventSystem = eventSystemObj.AddComponent <EventSystem>(); eventSystem.sendNavigationEvents = true; eventSystem.pixelDragThreshold = 10; eventSystemObj.AddComponent <StandaloneInputModule>(); Object.DontDestroyOnLoad(eventSystemObj); // Make sure that our UI is an overlay on the screen topUiObject.AddComponent <Canvas>().renderMode = RenderMode.ScreenSpaceOverlay; // Also scale the UI with the screen size var canvasScaler = topUiObject.AddComponent <CanvasScaler>(); canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize; canvasScaler.referenceResolution = new Vector2(Screen.width, Screen.height); topUiObject.AddComponent <GraphicRaycaster>(); Object.DontDestroyOnLoad(topUiObject); PrecacheText(topUiObject); _pauseMenuUiObject = new GameObject(); _pauseMenuUiObject.transform.SetParent(topUiObject.transform); _pauseMenuUiObject.SetActive(false); var connectUiObject = new GameObject(); connectUiObject.transform.SetParent(_pauseMenuUiObject.transform); var clientSettingsUiObject = new GameObject(); clientSettingsUiObject.transform.SetParent(_pauseMenuUiObject.transform); var serverSettingsUiObject = new GameObject(); serverSettingsUiObject.transform.SetParent(_pauseMenuUiObject.transform); new ConnectUI( modSettings, clientManager, serverManager, connectUiObject, clientSettingsUiObject, serverSettingsUiObject ); new ClientSettingsUI( clientGameSettings, clientManager, clientSettingsUiObject, connectUiObject ); new ServerSettingsUI( serverGameSettings, modSettings, serverManager, serverSettingsUiObject, connectUiObject ); var inGameUiObject = new GameObject(); inGameUiObject.transform.SetParent(topUiObject.transform); var infoBoxUiObject = new GameObject(); infoBoxUiObject.transform.SetParent(inGameUiObject.transform); InfoBox = new InfoBoxUI(infoBoxUiObject); // Register callbacks to make sure the UI is hidden and shown at correct times On.HeroController.Pause += (orig, self) => { // Execute original method orig(self); // Only show UI in gameplay scenes if (!SceneUtil.IsNonGameplayScene(SceneUtil.GetCurrentSceneName())) { _canShowPauseUi = true; _pauseMenuUiObject.SetActive(!_isPauseUiHiddenByKeybind); } infoBoxUiObject.SetActive(false); }; On.HeroController.UnPause += (orig, self) => { // Execute original method orig(self); _pauseMenuUiObject.SetActive(false); _canShowPauseUi = false; // Only show info box UI in gameplay scenes if (!SceneUtil.IsNonGameplayScene(SceneUtil.GetCurrentSceneName())) { infoBoxUiObject.SetActive(true); } }; UnityEngine.SceneManagement.SceneManager.activeSceneChanged += (oldScene, newScene) => { if (SceneUtil.IsNonGameplayScene(newScene.name)) { eventSystem.enabled = false; _canShowPauseUi = false; _pauseMenuUiObject.SetActive(false); infoBoxUiObject.SetActive(false); } else { eventSystem.enabled = true; infoBoxUiObject.SetActive(true); } }; // The game is automatically unpaused when the knight dies, so we need // to disable the UI menu manually // TODO: this still gives issues, since it displays the cursor while we are supposed to be unpaused ModHooks.Instance.AfterPlayerDeadHook += () => { _pauseMenuUiObject.SetActive(false); }; MonoBehaviourUtil.Instance.OnUpdateEvent += CheckKeybinds; }
public void SetGameSettings(Game.Settings.GameSettings gameSettings) { GameSettings = gameSettings; }