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);
}
