public void SetOverride(LevelID overrideID)
{
foreach (LevelSelectUI ui in uis)
{
ui.SetOverride(overrideID);
}
}
public static int MaxLevel()
{
LevelData[] levels = GetAllLevelData();
return(levels
.Select(level => LevelID.FromSceneName(level.Level.SceneName).LevelNumber)
.Max());
}
public static string GetLevelName(this LevelID levelId, GameSettings gameSettings)
{
switch (levelId)
{
case LevelID.SnowyPeaks:
return(gameSettings.SnowyPeaksSceneName);
case LevelID.Jimsterburg:
return(gameSettings.JimsterburgSceneName);
case LevelID.ParabeneForest:
return(gameSettings.ParabeneForestSceneName);
case LevelID.BlemburgCitadel:
return(gameSettings.BlemburgCitadelSceneName);
case LevelID.DarkTower:
return(gameSettings.DarkTowerSceneName);
case LevelID.RinfretVillage:
return(gameSettings.RinfretVillageSceneName);
case LevelID.TulipValley:
return(gameSettings.TulipValleySceneName);
case LevelID.Morktress:
return(gameSettings.MorktressSceneName);
default:
throw new ArgumentOutOfRangeException(nameof(levelId), levelId, null);
}
}
public static LevelData GetLevelData(LevelID levelID)
{
// Setup the path to use the enclosure number only if it is not level 0
string path = $"LevelData/Level{levelID.LevelNumber}/L{levelID.LevelNumber}";
if (levelID.LevelNumber != 0)
{
path += $"E{levelID.EnclosureNumber}";
}
path += "Data";
// Load the data at the computed path
LevelData data = Resources.Load <LevelData>(path);
// If you got level data then return it
if (data)
{
return(data);
}
// If you did not get level data then throw an exception
else
{
throw new MissingReferenceException($"{nameof(LevelDataLoader)}: " +
$"Failed to load level {levelID.LevelName} from resource path {path}");
}
}
public override void Setup()
{
base.Setup();
// Setup the bookmark target to get-set the enclosure id
bookmarkTarget.Setup(() => CurrentLevelID, x => CurrentLevelID = (LevelID)x);
// Clear out any existing options
levelDropdown.ClearOptions();
enclosureDropdown.ClearOptions();
// Loop through all enclosure id's and add them to the list
foreach (LevelID id in UIParent.Data.Levels)
{
TMP_Dropdown.OptionData option = LevelNumberToOptionData(id.LevelNumber);
// If no option with the same text yet exists, then add it to the dropdown
if (levelDropdown.options.FindIndex(x => x.text == option.text) < 0)
{
levelDropdown.options.Add(option);
}
}
// Update the level dropdown to reflect the current level
LevelID currentLevel = LevelID.Current();
levelDropdown.value = currentLevel.LevelNumber;
levelDropdown.RefreshShownValue();
OnLevelDropdownValueChanged(levelDropdown.value);
// Add listeners for the value changed events
levelDropdown.onValueChanged.AddListener(OnLevelDropdownValueChanged);
enclosureDropdown.onValueChanged.AddListener(OnEnclosureDropdownValueChanged);
}
////////////////////////////////////////////////////////////////
void ResetResetPlants(LevelID levelID)
{
for (int i = 0; i < m_ResetPlantSpawners.Count; i++)
{
m_ResetPlantSpawners[i].ResetSpawnTimer();
}
for (int i = 0; i < m_ResetPlantData.Count; i++)
{
ResetPlantData resetPlantData = m_ResetPlantData[i];
if (resetPlantData._ResetPlant._LevelID != levelID)
{
continue;
}
if (!resetPlantData._Respawns)
{
// #destroySpawnedResetPlant
GameObject.Destroy(resetPlantData._ResetPlant.gameObject);
m_ResetPlantData.RemoveAt(i);
i--;
continue;
}
// Reset Timers
resetPlantData._PloppedTimer = new GameTicks(0);
resetPlantData._ResetPlant.TransitionToState(ResetPlantState.Default, false);
}
}
private void OnLevelDropdownValueChanged(int value)
{
int selectedLevel = OptionDataToLevelNumber(levelDropdown.options[value]);
// Clear out the options in the enclosure dropdown
enclosureDropdown.ClearOptions();
foreach (LevelID id in UIParent.Data.Levels)
{
if (id.LevelNumber == selectedLevel)
{
enclosureDropdown.options.Add(EnclosureNumberToOptionData(id.EnclosureNumber));
}
}
// Get the enclosure represented in the current scene
LevelID currentLevel = LevelID.Current();
// If we selected the current level, then select the current enclosure number
if (currentLevel.LevelNumber == selectedLevel)
{
enclosureDropdown.value = currentLevel.EnclosureNumber - 1;
}
else
{
enclosureDropdown.value = 0;
}
// Set the enclosure to the first one selected
enclosureDropdown.RefreshShownValue();
OnEnclosureDropdownValueChanged(enclosureDropdown.value);
}
public void OnLevelEncountered(LevelID level)
{
// Get all entries with the given level
Entry latestEntry = GetEntryWithLatestAttempt(level);
if (latestEntry != null)
{
// Add an entry for the next attempt to the list of entries
entries.Add(new Entry
{
level = level,
attempt = latestEntry.attempt + 1,
reviews = new ReviewedResourceRequestList()
});
}
// If no entries were found with this level, then we add the first one
else
{
entries.Add(new Entry
{
level = level,
attempt = 1,
reviews = new ReviewedResourceRequestList()
});
}
}
public Entry GetEntryWithLatestAttempt(LevelID level)
{
IEnumerable <Entry> entries = GetEntriesWithLevel(level);
// If some entries exist then search for the latest one
if (entries.Count() > 0)
{
Entry maxEntry = null;
foreach (Entry entry in entries)
{
// If max entry is not yet set then make it this entry
if (maxEntry == null)
{
maxEntry = entry;
}
// If this entry was attempted later than the max entry,
// make the max entry this entry
else if (entry.attempt > maxEntry.attempt)
{
maxEntry = entry;
}
}
return(maxEntry);
}
// If no entries exist then return null
else
{
return(null);
}
}
private void OnEnclosureSelected(LevelID id)
{
// Destroy all existing editors
foreach (TestAndMetricsEntryEditor editor in currentEditors)
{
Destroy(editor.gameObject);
}
// Clear out the list
currentEditors.Clear();
// Foreach entry in the selected list, add an editor
foreach (TestAndMetricsEntryData entry in UIParent.Data.TestAndMetrics.GetEntryList(id).Entries)
{
TestAndMetricsEntryEditor editor = Instantiate(editorPrefab, editorParent.transform);
editor.Setup(id, entry, editorScroller);
currentEditors.Add(editor);
}
// If the enclosure selected is the current enclosure, then add a new editor
// that we can use to add more entries
if (id == LevelID.Current())
{
CreateAddingEntry();
}
}
public static void SetMessageLevel(MethodID messageMethod = MethodID.MESS_METHOD_GENERAL_ID,
LevelID messageLevel = LevelID.MESS_LEVEL_GENERAL)
{
//Call the version 6 and 7 set message level first, if the file is 6 then the ZSetMessageLevel will not work, and we can still use MethodIDs for 7.
DSS.ZSet("mlvl", "", (int)messageLevel);
DSS.ZSetMessageLevel((int)messageMethod, (int)messageLevel);
}
/// <summary>
/// Connects the player to the requested game level
/// Will find the first open rooom with available slots
/// </summary>
public void JoinGameLevel(LevelID level)
{
SetStatus("Joining Level");
m_levelJoined = level;
PhotonNetwork.JoinLobby(m_lobbys[(int)level]);
}
public void Setup(NotebookTab tab, ToggleGroup parent, UnityAction <NotebookTab> callback)
{
// Setup the notebook child base
base.Setup();
// Set the tab
this.tab = tab;
// Setup the toggle
myToggle.group = parent;
myToggle.onValueChanged.AddListener(OnToggleStateChanged);
// Listen for the callback when selected event is raised
selectedEvent.AddListener(callback);
// Set the text on the GUI element
tabName.text = tab.ToString();
if (GameManager.Instance)
{
// This toggle is only interactable if the tab scaffold says so
LevelID current = LevelID.Current();
myToggle.interactable = UIParent.Config.TabScaffold.GetMask(current).Get(tab);
}
else
{
myToggle.interactable = true;
}
}
public void Setup(LevelID levelID)
{
// Check if the interactability is based on completion or not
if (basedOnCompletion)
{
// Get the id of the previous level
LevelID previous = new LevelID(levelID.Type, levelID.Index - 1);
// If it is valid, the button is interactable if the previous level has been completed
if (previous.IsValid)
{
button.interactable = PlayerData.GetCompletionData(previous).Completed;
}
else
{
button.interactable = true;
}
}
else
{
button.interactable = true;
}
// Add listener to the button if it is interactable
if (button.interactable)
{
button.onClick.AddListener(() => GameplayManager.PlayLevel(levelID));
}
// Set the text on the component
text.text = levelID.Data.Name;
}
public static void QualifyForLevel(LevelID level)
{
if (level > Instance.latestLevelQualified)
{
Instance.latestLevelQualified = level;
}
}
public override void Setup()
{
base.Setup();
// Add listener for the enclosure picked event
enclosurePicker.OnLevelIDPicked.AddListener(OnEnclosureSelected);
OnEnclosureSelected(LevelID.Current());
}
private void CreateAddingEntry()
{
TestAndMetricsEntryEditor editor = Instantiate(editorPrefab, editorParent.transform);
editor.Setup(LevelID.Current(), null, editorScroller);
editor.OnNewEntryCreated.AddListener(OnNewEntryCreated);
currentEditors.Add(editor);
}
public void SetOverride(LevelID levelOverride)
{
overridden = true;
this.levelOverride = levelOverride;
// Disable outline in case this makes the ui not interactable anymore
outline.SetActive(false);
}
public static void TrySetLatestLevelIntro(LevelID id)
{
//If the latest level Intro finished is less, than update
if (Instance.latestLevelIntroFinished < id)
{
Instance.latestLevelIntroFinished = id;
}
}
public override void Setup()
{
base.Setup();
// Add listnener to enclosure id picked event and select the enclosure for the current scene
enclosurePicker.OnLevelIDPicked.AddListener(OnEnclosureSelected);
OnEnclosureSelected(LevelID.Current());
}
public ObservationsEntryListData(NotebookConfig config, LevelID id) : base(config)
{
// Copy the list from the initial entries to this one
LevelScaffold scaffold = config.Observations.Scaffold;
List <ObservationsEntryListData> initialEntries = config.Observations.InitialEntries;
ObservationsEntryListData copyList = initialEntries[scaffold.ScaffoldLevel(id)];
entries = new List <ObservationsEntryData>(copyList.entries);
}
private void OnEnclosureDropdownValueChanged(int value)
{
TMP_Dropdown.OptionData levelOptionSelected = levelDropdown.options[levelDropdown.value];
TMP_Dropdown.OptionData enclosureOptionSelected = enclosureDropdown.options[value];
LevelID levelSelected = new LevelID(OptionDataToLevelNumber(levelOptionSelected), OptionDataToEnclosureNumber(enclosureOptionSelected));
onLevelIDPicked.Invoke(levelSelected);
UIParent.OnContentChanged.Invoke();
}
////////////////////////////////////////////////////////////////
private void InitializePlayerForLevel(LevelID level)
{
if (m_PlayerController == null || m_PlayerController.gameObject == null)
{
// Get player asset
AssetDataPlayer assetData = AssetManager.GetAssetData <AssetDataPlayer>();
// Spawn the player
GameObject playerObject = GameObject.Instantiate(assetData.PlayerPrefab, GameCore.Get().transform);
m_PlayerController = playerObject.GetComponentInChildren <PlayerController>();
}
AssetDataLevels assetDataLevels = AssetManager.GetAssetData <AssetDataLevels>();
bool isIntroCutsceneLevel = level == assetDataLevels.LevelWithIntroCutscene;
m_GameState = isIntroCutsceneLevel ? GameState.Pregameplay : GameState.Gameplay;
////////////////////////////////////////////////////////////////
// 1st prio: current spawn point (set by loading level)
if (m_CurrentPlayerSpawnPoint != null)
{
m_PlayerController.Reset(m_CurrentPlayerSpawnPoint.transform.position);
return;
}
// 2nd prio: spawn at first spawnpoint in this level
//Find all spawn points in level
List <PlayerSpawnPoint> validSpawnPoints = m_PlayerSpawnPoints.FindAll((PlayerSpawnPoint psp) => {
return(psp._LevelID == level);
});
bool success = validSpawnPoints.Count != 0;
if (success)
{
// Sort by ID
validSpawnPoints.Sort((PlayerSpawnPoint lhs, PlayerSpawnPoint rhs) => {
if (lhs.Index == rhs.Index)
{
return(0);
}
return((lhs.Index < rhs.Index) ? -1 : 1);
});
m_PlayerController.Reset(validSpawnPoints[0].transform.position);
}
else
{
m_PlayerController.Reset(Vector3.zero);
}
m_PlayerController.SetVisible(!isIntroCutsceneLevel);
}
public void ToggleOverride(LevelID overrideID)
{
if (Overridden)
{
ClearOverride();
}
else
{
SetOverride(overrideID);
}
}
public static LevelID[] GetAllLevelIDsOfType(LevelType type)
{
LevelID[] ids = new LevelID[Instance.levelDatas.Get(type).list.Length];
for (int i = 0; i < ids.Length; i++)
{
ids[i] = new LevelID(type, i);
}
return(ids);
}
public string GetLevelHash()
{
if (IsOST)
{
return("");
}
else
{
return(LevelID.Substring(CustomLevelLoader.kCustomLevelPrefixId.Length, 40));
}
}
private void ToggleLevelSelectOverride()
{
LevelNavigator navigator = FindObjectOfType <LevelNavigator>();
// If the navigator exists then toggle its override
if (navigator)
{
LevelID maxID = new LevelID(LevelDataLoader.MaxLevel() + 1, 1);
navigator.ToggleOverride(maxID);
}
}
////////////////////////////////////////////////////////////////
private bool InitializePlayerSpawnPointToStartFrom(LevelID level)
{
SetPlayerSpawnPoint(m_PlayerSpawnPoints.Find((PlayerSpawnPoint psp) => {
return(psp.Index == m_PlayerSpawnPointToStartFrom.Value.ID && psp._LevelID == m_PlayerSpawnPointToStartFrom.Value.Level);
}));
SoundManager.Get().FitSoundToArea(m_CurrentPlayerSpawnPoint._AreaID);
Debug.Assert(m_CurrentPlayerSpawnPoint != null, "Could not find serialized player spawnpoint ID " + m_PlayerSpawnPointToStartFrom.Value.ID + " in level " + level.ToString());
return(m_CurrentPlayerSpawnPoint != null);
}
private void Start()
{
// Load the notebook from save, or create a new one if save data doesn't exist
data = GameManager.Instance.LoadNotebook() ?? new NotebookData(config);
// Set the configuration of the notebook data
data.SetConfig(config);
// Add the current level
data.OnLevelEncountered(LevelID.Current());
// Try to get an instance of the game manager
GameManager instance = GameManager.Instance;
// If the instance exists then unlock all item id's that exist in the list of items
if (instance)
{
foreach (LevelData.ItemData item in instance.LevelData.ItemQuantities)
{
data.UnlockItem(item.itemObject.ItemID);
}
}
// Setup the tab picker first of all children
tabPicker.Setup();
// Get the resource request editor manually
resourceRequestEditor = GetComponentInChildren <ResourceRequestEditor>(true);
// Setup all children, ensuring correct initialization order
NotebookUIChild[] children = GetComponentsInChildren <NotebookUIChild>(true);
foreach (NotebookUIChild child in children)
{
child.Setup();
}
// Map all bookmark targets to their corresponding game object names
BookmarkTarget[] allBookmarkTargets = GetComponentsInChildren <BookmarkTarget>(true);
foreach (BookmarkTarget bookmarkTarget in allBookmarkTargets)
{
nameTargetMap.Add(bookmarkTarget.name, bookmarkTarget);
}
// Setup sound events after all children are set up
soundManager.SetupSoundEvents();
// This line of code prevents the notebook from turning off the first time that it is turned on,
// while also making sure it is turned off at the start
if (!isOpen)
{
SetIsOpen(false);
}
}
public static LevelData GetLevelData(LevelID id)
{
LevelData[] list = Instance.levelDatas.Get(id.Type).list;
if (id.Index >= 0 && id.Index < list.Length)
{
return(list[id.Index]);
}
else
{
return(null);
}
}
/// <summary>
/// Selects the level
/// </summary>
private void SelectNewLevel(GameObject level)
{
m_selectedLevel = (LevelID)(int.Parse(level.name) - 1); // Levels start at 0
selectedLevel = level;
SetMaxPlayerSlider(true);
slider.GetComponentInParent<GUIMaxPlayers>().SetMaxPlayers(
Utilities.GetMaxPlayersForLevel(m_selectedLevel));
if (m_firstSelection)
{
m_unselectedColor = GetSelectedBackground().color;
m_firstSelection = false;
}
GetSelectedBackground().color = m_selectedColour;
isReady.isOn = false;
}
/// <summary>
/// Connects the player to the requested game level
/// Will find the first open rooom with available slots
/// </summary>
public void JoinGameLevel(LevelID level)
{
SetStatus("Joining Level");
m_levelJoined = level;
PhotonNetwork.JoinLobby(m_lobbys[(int)level]);
}
/// <summary>
/// Called after the connection to the master is established and
/// authenticated but only when PhotonNetwork.autoJoinLobby is false.
/// </summary>
public override void OnConnectedToMaster()
{
SetStatus("Connected to server");
if(Utilities.IsLevelLoaded() && !IsConnectedToLevel())
{
// Level has not been joined using the lobby (for development)
// Or level joined can be easily rejoined
if(m_levelJoined == LevelID.NO_LEVEL ||
Utilities.IsOpenLeveL(m_levelJoined))
{
JoinGameLevel(Utilities.GetLoadedLevel());
}
else
{
// Player has disconnected during a closed level
// Force move the player back to the lobby
m_levelJoined = LevelID.NO_LEVEL;
Application.LoadLevel((int)SceneID.LOBBY);
}
}
}