private void InitStorm() { Dungeon m_dungeonPrefab = DungeonDatabase.GetOrLoadByName("finalscenario_guide"); DungeonFlow dungeonFlowPrefab = m_dungeonPrefab.PatternSettings.flows[0]; PrototypeDungeonRoom GuidePastRoom = dungeonFlowPrefab.AllNodes[0].overrideExactRoom; GameObject GuidePastRoomObject = GuidePastRoom.placedObjects[0].nonenemyBehaviour.gameObject; GameObject m_RainPrefab = GuidePastRoomObject.transform.Find("Rain").gameObject; m_ThunderStorm = Instantiate(m_RainPrefab); m_ThunderStorm.name = "ChaosRain"; ThunderstormController stormController = m_ThunderStorm.GetComponent <ThunderstormController>(); ParticleSystem m_CachedParticleSystem = stormController.RainSystemTransform.GetComponent <ParticleSystem>(); if (useCustomIntensity) { BraveUtility.SetEmissionRate(m_CachedParticleSystem, RainIntensity); } m_cachedEmissionRate = m_CachedParticleSystem.emission.rate.constant; stormController.DecayVertical = false; stormController.DoLighting = false; m_ChaosLightning = new GameObject("ChaosLightning"); m_ChaosLightning.AddComponent <ChaosWeatherController>(); ChaosWeatherController LightningComponent = m_ChaosLightning.GetComponent <ChaosWeatherController>(); LightningComponent.LightningRenderers = stormController.LightningRenderers; dungeonFlowPrefab = null; m_dungeonPrefab = null; }
public static DungeonFlow LoadOfficialFlow(string target) { string flowName = target; if (flowName.Contains("/")) { flowName = target.Substring(target.LastIndexOf("/") + 1); } AssetBundle m_assetBundle_orig = ResourceManager.LoadAssetBundle("flows_base_001"); DebugTime.RecordStartTime(); DungeonFlow result = m_assetBundle_orig.LoadAsset <DungeonFlow>(flowName); DebugTime.Log("AssetBundle.LoadAsset<DungeonFlow>({0})", new object[] { flowName }); if (result == null) { Debug.Log("ERROR: Requested DungeonFlow not found!\nCheck that you provided correct DungeonFlow name and that it actually exists!"); m_assetBundle_orig = null; return(null); } else { m_assetBundle_orig = null; return(result); } }
public static DungeonFlow CreateSequentialThesisFlow(Dungeon dungeon) { DungeonFlow dungeonFlow = CreateEntranceFlow(dungeon); dungeonFlow.name = "thesis_flow_sequential"; DungeonFlowNode parent = dungeonFlow.FirstNode; ThesisFloorGenerator.AppendRoom(dungeonFlow, parent, "a1_legendarychests.room"); parent = ThesisFloorGenerator.AppendRoom(dungeonFlow, parent, "b1_bossroom_gullA_test.room"); parent = ThesisFloorGenerator.AppendRoom(dungeonFlow, parent, "c1_bufferroom.room"); parent = ThesisFloorGenerator.AppendRoom(dungeonFlow, parent, "b1_bossroom_gullA_test.room"); parent = ThesisFloorGenerator.AppendRoom(dungeonFlow, parent, "c1_bufferroom.room"); parent = ThesisFloorGenerator.AppendRoom(dungeonFlow, parent, "b1_bossroom_gullA_test.room"); parent = ThesisFloorGenerator.AppendExitElevator(dungeonFlow, parent); dungeon = null; return(dungeonFlow); }
private void CheckNodes(DungeonFlow flow, DungeonValidator validator) { if (flow.Nodes.Count < 2) { validator.AddError("The dungeon flow must contain at least two nodes"); } foreach (var node in flow.Nodes) { if (node.TileSets.Count == 0) { validator.AddError("The node '{0}' in the dungeon flow graph has no tile sets applied", node.Label); } else { foreach (var tileSet in node.TileSets) { if (tileSet == null) { validator.AddError("Node '{0}' in your dungeon flow graph has an unset tileset value", node.Label); } } } } }
private void CheckDoorwayForwardVectors(DungeonFlow flow, DungeonValidator validator, Dictionary <GameObject, Doorway[]> tileDoorways) { foreach (var pair in tileDoorways) { var tile = pair.Key; var bounds = UnityUtil.CalculateObjectBounds(tile, true, false); foreach (var doorway in pair.Value) { Vector3 forwardVector = doorway.transform.forward; if (!IsAxisAligned(forwardVector)) { validator.AddError("Doorway '{0}' in tile '{1}' has an invalid rotation. the forward vector is not axis-aligned", tile, doorway.name, tile.name); } else { Vector3 centerToDoorway = (doorway.transform.position - bounds.center).normalized; float angle = Vector3.Angle(centerToDoorway, forwardVector); if (angle > 85f) { validator.AddError("Doorway '{0}' in tile '{1}' is facing the wrong way. Doorways should face outwards from the tile (local z-axis, blue line)", tile, doorway.name, tile.name); } } } } }
private void Start() { Dungeon m_dungeonPrefab = DungeonDatabase.GetOrLoadByName("finalscenario_guide"); DungeonFlow dungeonFlowPrefab = m_dungeonPrefab.PatternSettings.flows[0]; PrototypeDungeonRoom GuidePastRoom = dungeonFlowPrefab.AllNodes[0].overrideExactRoom; GameObject GuidePastRoomObject = GuidePastRoom.placedObjects[0].nonenemyBehaviour.gameObject; GameObject m_RainPrefab = GuidePastRoomObject.transform.Find("Rain").gameObject; GameObject m_ThunderStorm = Instantiate(m_RainPrefab); m_ThunderStorm.name = "ExpandRain"; m_StormController = m_ThunderStorm.GetComponent <ThunderstormController>(); ParticleSystem m_CachedParticleSystem = m_StormController.RainSystemTransform.GetComponent <ParticleSystem>(); if (useCustomIntensity) { BraveUtility.SetEmissionRate(m_CachedParticleSystem, RainIntensity); } m_StormController.DecayVertical = isLocalToRoom; m_StormController.DoLighting = false; LightningRenderers = m_StormController.LightningRenderers; m_ThunderStorm.transform.parent = gameObject.transform; dungeonFlowPrefab = null; m_dungeonPrefab = null; isActive = true; }
private void CheckDoorwayCount(DungeonFlow flow, DungeonValidator validator) { var pathTileSets = new List <TileSet>(); foreach (var node in flow.Nodes) { if (node.NodeType != NodeType.Start && node.NodeType != NodeType.Goal) { pathTileSets.AddRange(node.TileSets); } } foreach (var line in flow.Lines) { foreach (var archetype in line.DungeonArchetypes) { pathTileSets.AddRange(archetype.TileSets); } } var pathTiles = pathTileSets.SelectMany(ts => ts.TileWeights.Weights.Select(w => w.Value)).Where(t => t != null); foreach (var tile in pathTiles) { int doorwayCount = tile.GetComponentsInChildren <Doorway>(true).Count(); if (doorwayCount < 2) { validator.AddError("Tile '{0}' does not have enough doorways. Two doorways are required for all tiles except those that appear exclusively as a start node, goal node, or branch cap", tile, tile.name); } } }
// Token: 0x06000054 RID: 84 RVA: 0x000056A8 File Offset: 0x000038A8 public static DungeonFlow CreateRoomTypeSampleFlow(Dungeon dungeon) { DungeonFlow dungeonFlow = SampleFlow.CreateNewFlow(dungeon); dungeonFlow.name = "type_sample_flow"; DungeonFlowNode dungeonFlowNode = SampleFlow.NodeFromAssetName(dungeonFlow, "elevator entrance"); dungeonFlow.FirstNode = dungeonFlowNode; dungeonFlow.AddNodeToFlow(dungeonFlowNode, null); DungeonFlowNode parent = dungeonFlow.FirstNode; DungeonMaterial[] roomMaterialDefinitions = dungeon.roomMaterialDefinitions; Tools.Print <int?>((roomMaterialDefinitions != null) ? new int?(roomMaterialDefinitions.Length) : null, "FFFFFF", false); for (int i = 0; i < dungeon.roomMaterialDefinitions.Length; i++) { bool flag = dungeon.name == OfficialFlows.dungeonPrefabNames[3] && i == 5; if (!flag) { PrototypeDungeonRoom prototypeDungeonRoom = RoomFactory.CreateEmptyRoom(14, 14); prototypeDungeonRoom.overrideRoomVisualType = i; DungeonFlowNode dungeonFlowNode2 = new DungeonFlowNode(dungeonFlow) { overrideExactRoom = prototypeDungeonRoom }; dungeonFlow.AddNodeToFlow(dungeonFlowNode2, parent); parent = dungeonFlowNode2; } } dungeonFlow.AddNodeToFlow(SampleFlow.NodeFromAssetName(dungeonFlow, "exit_room_basic"), parent); dungeon = null; return(dungeonFlow); }
// Token: 0x06000053 RID: 83 RVA: 0x000055AC File Offset: 0x000037AC public static DungeonFlow CreateDebugFlow(Dungeon dungeon) { DungeonFlow dungeonFlow = SampleFlow.CreateEntranceExitFlow(dungeon); dungeonFlow.name = "debug_flow"; DungeonFlowNode dungeonFlowNode = new DungeonFlowNode(dungeonFlow) { overrideExactRoom = RoomFactory.CreateEmptyRoom(12, 12) }; DungeonFlowNode parent = dungeonFlowNode; dungeonFlow.AddNodeToFlow(dungeonFlowNode, dungeonFlow.FirstNode); foreach (RoomFactory.RoomData roomData in RoomFactory.rooms.Values) { string str = "Adding room to flow: "; PrototypeDungeonRoom room = roomData.room; Tools.Log <string>(str + ((room != null) ? room.ToString() : null)); DungeonFlowNode dungeonFlowNode2 = new DungeonFlowNode(dungeonFlow) { overrideExactRoom = roomData.room }; dungeonFlow.AddNodeToFlow(dungeonFlowNode2, parent); dungeonFlowNode = new DungeonFlowNode(dungeonFlow) { overrideExactRoom = RoomFactory.CreateEmptyRoom(12, 12) }; dungeonFlow.AddNodeToFlow(dungeonFlowNode, dungeonFlowNode2); parent = dungeonFlowNode; } dungeon = null; return(dungeonFlow); }
private void CheckArchetypes(DungeonFlow flow, DungeonValidator validator) { var archetypes = flow.GetUsedArchetypes(); foreach (var archetype in archetypes) { if (archetype == null) { continue; } if (archetype.TileSets.Count == 0) { validator.AddError("The archetype '{0}' has no tile sets assigned", archetype, archetype.name); } else { foreach (var tileSet in archetype.TileSets) { if (tileSet == null) { validator.AddError("The archetype '{0}' has a missing tile set", archetype, archetype.name); } } } foreach (var tileSet in archetype.BranchCapTileSets) { if (tileSet == null) { validator.AddError("Archetype '{0}' has a missing branch cap tile set", archetype, archetype.name); } } } }
public static DungeonFlow F1b_Hat_flow_01() { try { DungeonFlow m_CachedFlow = ScriptableObject.CreateInstance<DungeonFlow>(); DungeonFlowNode entranceNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.ENTRANCE, ModRoomPrefabs.Mod_Entrance_Room); DungeonFlowNode exitNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.EXIT, ModRoomPrefabs.Mod_Exit_Room); DungeonFlowNode HatRoomNode_01 = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.HUB); DungeonFlowNode HatRoomNode_02 = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.NORMAL); m_CachedFlow.name = "F1b_FloorName_Flow_01"; m_CachedFlow.fallbackRoomTable = ModPrefabs.FloorNameRoomTable; m_CachedFlow.phantomRoomTable = null; m_CachedFlow.subtypeRestrictions = new List<DungeonFlowSubtypeRestriction>(0); m_CachedFlow.flowInjectionData = new List<ProceduralFlowModifierData>(0); m_CachedFlow.sharedInjectionData = new List<SharedInjectionData>() { BaseSharedInjectionData }; m_CachedFlow.Initialize(); m_CachedFlow.AddNodeToFlow(entranceNode, null); // First Looping branch m_CachedFlow.AddNodeToFlow(HatRoomNode_01, entranceNode); m_CachedFlow.AddNodeToFlow(HatRoomNode_02, HatRoomNode_01); m_CachedFlow.AddNodeToFlow(exitNode, HatRoomNode_02); m_CachedFlow.FirstNode = entranceNode; return m_CachedFlow; } catch (Exception e) { ETGModConsole.Log(e.ToString()); return null; } }
public static DungeonFlow CreateBranchingThesisFlow(Dungeon dungeon) { DungeonFlow dungeonFlow = SampleFlow.CreateNewFlow(dungeon); dungeonFlow.name = "thesis_flow_branching"; DungeonFlowNode parent = null; if (Module.Debug) { parent = MakeNode(LoadRoom("lobby.room"), dungeonFlow); } else { parent = MakeNode(LoadRoom("lobby_.room"), dungeonFlow); } dungeonFlow.FirstNode = parent; dungeonFlow.AddNodeToFlow(parent, null); AppendBossRoom(dungeonFlow, parent); if (Module.Debug) { ThesisFloorGenerator.AppendRoom(dungeonFlow, parent, "a1_legendarychests.room"); } AppendBossRoom(dungeonFlow, parent); AppendBossRoom(dungeonFlow, parent); dungeon = null; return(dungeonFlow); }
// Token: 0x0600000B RID: 11 RVA: 0x00003198 File Offset: 0x00001398 public static void CollectDataForAnalysis(DungeonFlow flow, Dungeon dungeon) { try { foreach (WeightedRoom weightedRoom in flow.fallbackRoomTable.includedRooms.elements) { string str = "Fallback table: "; bool flag = weightedRoom == null; string str2; if (flag) { str2 = null; } else { PrototypeDungeonRoom room = weightedRoom.room; str2 = ((room != null) ? room.name : null); } Tools.Print <string>(str + str2, "FFFFFF", false); } } catch (Exception e) { Tools.PrintException(e, "FF0000"); } }
private static DungeonFlowNode AppendExitElevator(DungeonFlow dungeonFlow, DungeonFlowNode parentNode) { var dungeonFlowNode = SampleFlow.NodeFromAssetName(dungeonFlow, "exit_room_basic"); dungeonFlow.AddNodeToFlow(dungeonFlowNode, parentNode); return(dungeonFlowNode); }
private static void AppendBossRoom(DungeonFlow dungeonFlow, DungeonFlowNode parentNode) { DungeonFlowNode dungeonFlowNode = SampleFlow.NodeFromAssetName(dungeonFlow, "GatlingGullRoom02"); dungeonFlowNode.overrideExactRoom.subCategoryBoss = PrototypeDungeonRoom.RoomBossSubCategory.MINI_BOSS; dungeonFlow.AddNodeToFlow(dungeonFlowNode, parentNode); }
public static DungeonFlow Test_CustomRoom_Flow() { DungeonFlow m_CachedFlow = ScriptableObject.CreateInstance <DungeonFlow>(); DungeonFlowNode entranceNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.ENTRANCE, ExpandPrefabs.elevator_entrance); DungeonFlowNode exitNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.EXIT, ExpandRoomPrefabs.SecretExitRoom); DungeonFlowNode bossfoyerNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.SPECIAL, overrideTable: ExpandPrefabs.boss_foyertable); DungeonFlowNode bossNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.BOSS, ExpandRoomPrefabs.Expand_Jungle_Boss); DungeonFlowNode TestRoomNode_01 = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.NORMAL, ExpandRoomPrefabs.Expand_Apache_RickRollChest); DungeonFlowNode TestShopNode = GenerateDefaultNode(m_CachedFlow, ExpandPrefabs.shop02.category, overrideTable: ExpandPrefabs.shop_room_table); DungeonFlowNode TestRewardNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.CONNECTOR, ExpandPrefabs.gungeon_rewardroom_1); DungeonFlowNode TestSecretRoomNode = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.SECRET, ExpandRoomPrefabs.Expand_GlitchedSecret); DungeonFlowNode testConnectorNode01 = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.NORMAL, ExpandRoomPrefabs.Expand_BootlegRoom); DungeonFlowNode TestRoomNode_02 = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.NORMAL, ExpandRoomPrefabs.Expand_Apache_RainbowRoom); // DungeonFlowNode SecondSecretRoom = GenerateDefaultNode(m_CachedFlow, PrototypeDungeonRoom.RoomCategory.SECRET, ExpandRoomPrefabs.Secret_Expand_logo); /*foreach (PrototypeDungeonRoom room in ExpandRoomPrefabs.Expand_Jungle_Rooms) { * if (room.name == "Expand_Forest_Mixed22") { * TestRoomNode_02.overrideExactRoom = room; * break; * } * }*/ m_CachedFlow.name = "Test_CustomRoom_Flow"; m_CachedFlow.fallbackRoomTable = null; m_CachedFlow.phantomRoomTable = null; m_CachedFlow.subtypeRestrictions = new List <DungeonFlowSubtypeRestriction>(0); m_CachedFlow.flowInjectionData = new List <ProceduralFlowModifierData>(0); m_CachedFlow.sharedInjectionData = new List <SharedInjectionData>(0); m_CachedFlow.Initialize(); m_CachedFlow.AddNodeToFlow(entranceNode, null); m_CachedFlow.AddNodeToFlow(TestRoomNode_01, entranceNode); m_CachedFlow.AddNodeToFlow(TestRewardNode, TestRoomNode_01); m_CachedFlow.AddNodeToFlow(TestSecretRoomNode, TestRewardNode); m_CachedFlow.AddNodeToFlow(TestShopNode, TestRoomNode_01); // m_CachedFlow.AddNodeToFlow(SecondSecretRoom, TestShopNode); m_CachedFlow.AddNodeToFlow(TestRoomNode_02, TestShopNode); m_CachedFlow.AddNodeToFlow(testConnectorNode01, TestRoomNode_01); m_CachedFlow.AddNodeToFlow(bossfoyerNode, testConnectorNode01); m_CachedFlow.AddNodeToFlow(bossNode, bossfoyerNode); m_CachedFlow.AddNodeToFlow(exitNode, bossNode); m_CachedFlow.FirstNode = entranceNode; return(m_CachedFlow); }
public static DungeonFlow GetRandomFlowFromNextDungeonPrefabForGlitchFloor() { int NextLevelIndex = ReflectionHelpers.ReflectGetField <int>(typeof(GameManager), "nextLevelIndex", GameManager.Instance); Dungeon dungeon = null; bool useFallBack = true; switch (NextLevelIndex) { case 2: dungeon = DungeonDatabase.GetOrLoadByName("Base_Castle"); break; case 3: dungeon = DungeonDatabase.GetOrLoadByName("Base_Gungeon"); break; case 4: dungeon = DungeonDatabase.GetOrLoadByName("Base_Mines"); break; case 5: dungeon = DungeonDatabase.GetOrLoadByName("Base_Catacombs"); break; case 6: dungeon = DungeonDatabase.GetOrLoadByName("Base_Forge"); break; case 7: dungeon = DungeonDatabase.GetOrLoadByName("Base_Bullethell"); break; default: dungeon = DungeonDatabase.GetOrLoadByName("Base_Mines"); break; } DungeonFlow m_AssignedFallBackFlow = FlowDatabase.GetOrLoadByName(BraveUtility.RandomElement(GlitchChestFlows)); DungeonFlow m_AssignedFlow = FlowHelpers.DuplicateDungeonFlow(BraveUtility.RandomElement(dungeon.PatternSettings.flows)); dungeon = null; foreach (DungeonFlowNode node in m_AssignedFlow.AllNodes) { if (node.roomCategory == PrototypeDungeonRoom.RoomCategory.BOSS) { node.overrideExactRoom = ExpandPrefabs.doublebeholsterroom01; useFallBack = false; break; } } if (useFallBack) { return(m_AssignedFallBackFlow); } else { return(m_AssignedFlow); } }
private void DrawTileInjectionRules(DungeonFlow data) { EditorGUILayout.Space(); EditorGUILayout.Space(); showTileInjectionRules = EditorGUILayout.Foldout(showTileInjectionRules, "Special Tile Injection"); if (!showTileInjectionRules) return; int indexToRemove = -1; EditorGUILayout.BeginVertical("box"); for (int i = 0; i < data.TileInjectionRules.Count; i++ ) { var rule = data.TileInjectionRules[i]; EditorGUILayout.BeginVertical("box"); EditorGUILayout.BeginHorizontal(); //string title = (rule.TileSet == null) ? "None" : rule.TileSet.name; //EditorGUILayout.LabelField(title, EditorStyles.boldLabel); rule.TileSet = EditorGUILayout.ObjectField(rule.TileSet, typeof(TileSet), false) as TileSet; if (GUILayout.Button("x", EditorStyles.miniButton, GUILayout.Width(20))) indexToRemove = i; EditorGUILayout.EndHorizontal(); EditorGUILayout.Space(); rule.IsRequired = EditorGUILayout.ToggleLeft("Is Required?", rule.IsRequired); rule.CanAppearOnMainPath = EditorGUILayout.ToggleLeft("Can appear on Main Path?", rule.CanAppearOnMainPath); rule.CanAppearOnBranchPath = EditorGUILayout.ToggleLeft("Can appear on Branch Path?", rule.CanAppearOnBranchPath); EditorGUILayout.Space(); EditorUtil.DrawLimitedFloatRange("Path Depth", rule.NormalizedPathDepth); bool previousEnabled = GUI.enabled; GUI.enabled = rule.CanAppearOnBranchPath; EditorUtil.DrawLimitedFloatRange("Branch Depth", rule.NormalizedBranchDepth); GUI.enabled = previousEnabled; EditorGUILayout.EndVertical(); EditorGUILayout.Space(); } if (indexToRemove > -1) data.TileInjectionRules.RemoveAt(indexToRemove); if (GUILayout.Button("Add New Rule")) data.TileInjectionRules.Add(new TileInjectionRule()); EditorGUILayout.EndVertical(); }
public static DungeonFlowNode MakeNode(PrototypeDungeonRoom room, DungeonFlow dungeonFlow) { DungeonFlowNode dungeonFlowNode = new DungeonFlowNode(dungeonFlow) { overrideExactRoom = room }; return(dungeonFlowNode); }
// Generate a DungeonFlowNode with a default configuration public static DungeonFlowNode GenerateDefaultNode(DungeonFlow targetflow, PrototypeDungeonRoom.RoomCategory roomType, PrototypeDungeonRoom overrideRoom = null, GenericRoomTable overrideTable = null, bool oneWayLoopTarget = false, bool isWarpWingNode = false, string nodeGUID = null, DungeonFlowNode.NodePriority priority = DungeonFlowNode.NodePriority.MANDATORY, float percentChance = 1, bool handlesOwnWarping = true) { try { if (string.IsNullOrEmpty(nodeGUID)) { nodeGUID = Guid.NewGuid().ToString(); } DungeonFlowNode m_CachedNode = new DungeonFlowNode(targetflow) { isSubchainStandin = false, nodeType = DungeonFlowNode.ControlNodeType.ROOM, roomCategory = roomType, percentChance = percentChance, priority = priority, overrideExactRoom = overrideRoom, overrideRoomTable = overrideTable, capSubchain = false, subchainIdentifier = string.Empty, limitedCopiesOfSubchain = false, maxCopiesOfSubchain = 1, subchainIdentifiers = new List <string>(0), receivesCaps = false, isWarpWingEntrance = isWarpWingNode, handlesOwnWarping = handlesOwnWarping, forcedDoorType = DungeonFlowNode.ForcedDoorType.NONE, loopForcedDoorType = DungeonFlowNode.ForcedDoorType.NONE, nodeExpands = false, initialChainPrototype = "n", chainRules = new List <ChainRule>(0), minChainLength = 3, maxChainLength = 8, minChildrenToBuild = 1, maxChildrenToBuild = 1, canBuildDuplicateChildren = false, guidAsString = nodeGUID, parentNodeGuid = string.Empty, childNodeGuids = new List <string>(0), loopTargetNodeGuid = string.Empty, loopTargetIsOneWay = oneWayLoopTarget, flow = targetflow }; return(m_CachedNode); } catch (Exception e) { ETGModConsole.Log(e.ToString()); return(null); } }
private void OnEnable() { DungeonFlow flow = target as DungeonFlow; if (flow != null) { foreach (var line in flow.Lines) line.Graph = flow; foreach (var node in flow.Nodes) node.Graph = flow; } }
public bool Validate(DungeonFlow dungeonFlow) { messages.Clear(); foreach (var rule in rules) { rule.Validate(dungeonFlow, this); } PrintMessages(dungeonFlow); return(!messages.Any(m => m.Type == MessageType.Error)); }
private static DungeonFlow CreateEntranceFlow(Dungeon dungeon) { DungeonFlow dungeonFlow = SampleFlow.CreateNewFlow(dungeon); dungeonFlow.name = "entrance_flow"; DungeonFlowNode dungeonFlowNode = SampleFlow.NodeFromAssetName(dungeonFlow, "elevator entrance"); dungeonFlow.FirstNode = dungeonFlowNode; dungeonFlow.AddNodeToFlow(dungeonFlowNode, null); dungeon = null; return(dungeonFlow); }
public static void ListNodes(this DungeonFlow flow) { Tools.Print(flow.name + " node:"); Tools.Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); foreach (var node in flow.AllNodes) { if (node != null && node.overrideExactRoom) { Tools.Print(node.overrideExactRoom); } } }
public void LoadDataFromId(int id) { DungeonBaseData dbd = RandomDungeonDataBase.GetDataFromId(id); DungeonFlow df = Resources.Load(dbd.dungeonFlowPath) as DungeonFlow; if (df == null) { Debug.LogError("flow null: " + dbd.dungeonFlowPath); dbd.dungeonFlowPath = dungeonFlowPath; } dungeonData = dbd; }
private void CheckDoorwayUpVectors(DungeonFlow flow, DungeonValidator validator, Dictionary <GameObject, Doorway[]> tileDoorways) { var doorwaysByUpVector = new Dictionary <Vector3, List <DoorwayInfo> >(); foreach (var pair in tileDoorways) { foreach (var doorway in pair.Value) { Vector3 upVector = doorway.transform.up; List <DoorwayInfo> doorwaySet = null; foreach (var existingPair in doorwaysByUpVector) { if (Vector3.Angle(upVector, existingPair.Key) <= AngleThreshold) { doorwaySet = existingPair.Value; } } if (doorwaySet == null) { doorwaySet = new List <DoorwayInfo>(); doorwaysByUpVector[upVector] = doorwaySet; } doorwaySet.Add(new DoorwayInfo(doorway, pair.Key)); } } if (doorwaysByUpVector.Count > 1) { Vector3 mostCommonUpVector = doorwaysByUpVector.OrderByDescending(x => x.Value.Count).First().Key; if (!IsAxisAligned(mostCommonUpVector)) { validator.AddError("The most common doorway up vector is not axis-aligned"); } foreach (var pair in doorwaysByUpVector) { if (pair.Key == mostCommonUpVector) { continue; } foreach (var info in pair.Value) { validator.AddError("Doorway '{0}' in tile '{1}' has an invalid rotation. The most common up-vector among doorways is {2}", info.TilePrefab, info.Doorway.name, info.TilePrefab.name, mostCommonUpVector); } } } }
// Token: 0x06000058 RID: 88 RVA: 0x00005900 File Offset: 0x00003B00 public static DungeonFlowNode NodeFromAssetName(DungeonFlow flow, string name) { DungeonFlowNode dungeonFlowNode = new DungeonFlowNode(flow); PrototypeDungeonRoom prototypeDungeonRoom = SampleFlow.RoomFromAssetName(name); bool flag = prototypeDungeonRoom == null; if (flag) { Tools.Print <string>("Error loading room " + name, "FF0000", false); } dungeonFlowNode.overrideExactRoom = prototypeDungeonRoom; return(dungeonFlowNode); }
// Token: 0x06000055 RID: 85 RVA: 0x000057A8 File Offset: 0x000039A8 public static DungeonFlow CreateEntranceExitFlow(Dungeon dungeon) { DungeonFlow dungeonFlow = SampleFlow.CreateNewFlow(dungeon); dungeonFlow.name = "entrance_exit_flow"; DungeonFlowNode dungeonFlowNode = SampleFlow.NodeFromAssetName(dungeonFlow, "elevator entrance"); dungeonFlow.FirstNode = dungeonFlowNode; dungeonFlow.AddNodeToFlow(dungeonFlowNode, null); dungeonFlow.AddNodeToFlow(SampleFlow.NodeFromAssetName(dungeonFlow, "exit_room_basic"), dungeonFlowNode); dungeon = null; return(dungeonFlow); }
// Token: 0x0600005A RID: 90 RVA: 0x000059B4 File Offset: 0x00003BB4 public static void ListNodes(this DungeonFlow flow) { Tools.Print <string>(flow.name + " node:", "FFFFFF", false); Tools.Print <string>("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", "FFFFFF", false); foreach (DungeonFlowNode dungeonFlowNode in flow.AllNodes) { bool flag = dungeonFlowNode != null && dungeonFlowNode.overrideExactRoom; if (flag) { Tools.Print <PrototypeDungeonRoom>(dungeonFlowNode.overrideExactRoom, "FFFFFF", false); } } }
// Generate a DungeonFlowNode with a default configuration public static DungeonFlowNode GenerateDefaultNode(DungeonFlow targetflow, PrototypeDungeonRoom.RoomCategory roomType, PrototypeDungeonRoom overrideRoom = null, GenericRoomTable overrideTable = null, bool oneWayLoopTarget = false, bool isWarpWingNode = false, string nodeGUID = null) { DungeonFlowNode m_CachedNode = new DungeonFlowNode(targetflow); m_CachedNode.isSubchainStandin = false; m_CachedNode.nodeType = DungeonFlowNode.ControlNodeType.ROOM; m_CachedNode.roomCategory = roomType; m_CachedNode.percentChance = 1f; m_CachedNode.priority = DungeonFlowNode.NodePriority.MANDATORY; m_CachedNode.overrideExactRoom = overrideRoom; m_CachedNode.overrideRoomTable = overrideTable; m_CachedNode.capSubchain = false; m_CachedNode.subchainIdentifier = string.Empty; m_CachedNode.limitedCopiesOfSubchain = false; m_CachedNode.maxCopiesOfSubchain = 1; m_CachedNode.subchainIdentifiers = new List <string>(0); m_CachedNode.receivesCaps = false; m_CachedNode.isWarpWingEntrance = isWarpWingNode; if (isWarpWingNode) { m_CachedNode.handlesOwnWarping = true; } else { m_CachedNode.handlesOwnWarping = false; } m_CachedNode.forcedDoorType = DungeonFlowNode.ForcedDoorType.NONE; m_CachedNode.loopForcedDoorType = DungeonFlowNode.ForcedDoorType.NONE; m_CachedNode.nodeExpands = false; m_CachedNode.initialChainPrototype = "n"; m_CachedNode.chainRules = new List <ChainRule>(0); m_CachedNode.minChainLength = 3; m_CachedNode.maxChainLength = 8; m_CachedNode.minChildrenToBuild = 1; m_CachedNode.maxChildrenToBuild = 1; m_CachedNode.canBuildDuplicateChildren = false; m_CachedNode.parentNodeGuid = string.Empty; m_CachedNode.childNodeGuids = new List <string>(0); m_CachedNode.loopTargetNodeGuid = string.Empty; m_CachedNode.loopTargetIsOneWay = oneWayLoopTarget; if (nodeGUID == null) { m_CachedNode.guidAsString = Guid.NewGuid().ToString(); } else { m_CachedNode.guidAsString = nodeGUID; } m_CachedNode.flow = targetflow; return(m_CachedNode); }