1169 lines
35 KiB
C#
1169 lines
35 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using DunGen.Graph;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
|
|
namespace DunGen
|
|
{
|
|
[Serializable]
|
|
public class DungeonGenerator : ISerializationCallbackReceiver
|
|
{
|
|
public const int CurrentFileVersion = 1;
|
|
|
|
[SerializeField]
|
|
[FormerlySerializedAs("AllowImmediateRepeats")]
|
|
private bool allowImmediateRepeats;
|
|
|
|
public int Seed;
|
|
|
|
public bool ShouldRandomizeSeed = true;
|
|
|
|
public int MaxAttemptCount = 20;
|
|
|
|
public bool UseMaximumPairingAttempts;
|
|
|
|
public int MaxPairingAttempts = 5;
|
|
|
|
public bool IgnoreSpriteBounds;
|
|
|
|
public AxisDirection UpDirection = AxisDirection.PosY;
|
|
|
|
[FormerlySerializedAs("OverrideAllowImmediateRepeats")]
|
|
public bool OverrideRepeatMode;
|
|
|
|
public TileRepeatMode RepeatMode;
|
|
|
|
public bool OverrideAllowTileRotation;
|
|
|
|
public bool AllowTileRotation;
|
|
|
|
public bool DebugRender;
|
|
|
|
public float LengthMultiplier = 1f;
|
|
|
|
public bool PlaceTileTriggers = true;
|
|
|
|
public int TileTriggerLayer = 2;
|
|
|
|
public bool GenerateAsynchronously;
|
|
|
|
public float MaxAsyncFrameMilliseconds = 50f;
|
|
|
|
public float PauseBetweenRooms;
|
|
|
|
public bool RestrictDungeonToBounds;
|
|
|
|
public Bounds TilePlacementBounds = new Bounds(Vector3.zero, Vector3.one * 10f);
|
|
|
|
public float OverlapThreshold = 0.01f;
|
|
|
|
public float Padding;
|
|
|
|
public bool DisallowOverhangs;
|
|
|
|
public GameObject Root;
|
|
|
|
public DungeonFlow DungeonFlow;
|
|
|
|
protected int retryCount;
|
|
|
|
protected DungeonProxy proxyDungeon;
|
|
|
|
protected readonly Dictionary<TilePlacementResult, int> tilePlacementResultCounters = new Dictionary<TilePlacementResult, int>();
|
|
|
|
protected readonly List<GameObject> useableTiles = new List<GameObject>();
|
|
|
|
protected int targetLength;
|
|
|
|
protected List<InjectedTile> tilesPendingInjection;
|
|
|
|
protected List<DungeonGeneratorPostProcessStep> postProcessSteps = new List<DungeonGeneratorPostProcessStep>();
|
|
|
|
[SerializeField]
|
|
private int fileVersion;
|
|
|
|
private int nextNodeIndex;
|
|
|
|
private DungeonArchetype currentArchetype;
|
|
|
|
private GraphLine previousLineSegment;
|
|
|
|
private List<TileProxy> preProcessData = new List<TileProxy>();
|
|
|
|
private Stopwatch yieldTimer = new Stopwatch();
|
|
|
|
private Dictionary<TileProxy, InjectedTile> injectedTiles = new Dictionary<TileProxy, InjectedTile>();
|
|
|
|
public RandomStream RandomStream { get; protected set; }
|
|
|
|
public Vector3 UpVector => UpDirection switch
|
|
{
|
|
AxisDirection.PosX => new Vector3(1f, 0f, 0f),
|
|
AxisDirection.NegX => new Vector3(-1f, 0f, 0f),
|
|
AxisDirection.PosY => new Vector3(0f, 1f, 0f),
|
|
AxisDirection.NegY => new Vector3(0f, -1f, 0f),
|
|
AxisDirection.PosZ => new Vector3(0f, 0f, 1f),
|
|
AxisDirection.NegZ => new Vector3(0f, 0f, -1f),
|
|
_ => throw new NotImplementedException("AxisDirection '" + UpDirection.ToString() + "' not implemented"),
|
|
};
|
|
|
|
public GenerationStatus Status { get; private set; }
|
|
|
|
public GenerationStats GenerationStats { get; private set; }
|
|
|
|
public int ChosenSeed { get; protected set; }
|
|
|
|
public Dungeon CurrentDungeon { get; private set; }
|
|
|
|
public bool IsGenerating { get; private set; }
|
|
|
|
public bool IsAnalysis { get; set; }
|
|
|
|
public event GenerationStatusDelegate OnGenerationStatusChanged;
|
|
|
|
public static event GenerationStatusDelegate OnAnyDungeonGenerationStatusChanged;
|
|
|
|
public event TileInjectionDelegate TileInjectionMethods;
|
|
|
|
public event Action Cleared;
|
|
|
|
public event Action Retrying;
|
|
|
|
public DungeonGenerator()
|
|
{
|
|
GenerationStats = new GenerationStats();
|
|
}
|
|
|
|
public DungeonGenerator(GameObject root)
|
|
: this()
|
|
{
|
|
Root = root;
|
|
}
|
|
|
|
public void Generate()
|
|
{
|
|
if (!IsGenerating)
|
|
{
|
|
IsAnalysis = false;
|
|
IsGenerating = true;
|
|
Wait(OuterGenerate());
|
|
}
|
|
}
|
|
|
|
public void Cancel()
|
|
{
|
|
if (IsGenerating)
|
|
{
|
|
Clear(stopCoroutines: true);
|
|
IsGenerating = false;
|
|
}
|
|
}
|
|
|
|
public Dungeon DetachDungeon()
|
|
{
|
|
if (CurrentDungeon == null)
|
|
{
|
|
return null;
|
|
}
|
|
Dungeon currentDungeon = CurrentDungeon;
|
|
CurrentDungeon = null;
|
|
Root = null;
|
|
Clear(stopCoroutines: true);
|
|
return currentDungeon;
|
|
}
|
|
|
|
protected virtual IEnumerator OuterGenerate()
|
|
{
|
|
Clear(stopCoroutines: false);
|
|
yieldTimer.Restart();
|
|
Status = GenerationStatus.NotStarted;
|
|
ChosenSeed = (ShouldRandomizeSeed ? new RandomStream().Next() : Seed);
|
|
RandomStream = new RandomStream(ChosenSeed);
|
|
if (Root == null)
|
|
{
|
|
Root = new GameObject("Dungeon");
|
|
}
|
|
yield return Wait(InnerGenerate(isRetry: false));
|
|
IsGenerating = false;
|
|
}
|
|
|
|
private Coroutine Wait(IEnumerator routine)
|
|
{
|
|
if (GenerateAsynchronously)
|
|
{
|
|
return CoroutineHelper.Start(routine);
|
|
}
|
|
while (routine.MoveNext())
|
|
{
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void RandomizeSeed()
|
|
{
|
|
Seed = new RandomStream().Next();
|
|
}
|
|
|
|
protected virtual IEnumerator InnerGenerate(bool isRetry)
|
|
{
|
|
if (isRetry)
|
|
{
|
|
ChosenSeed = RandomStream.Next();
|
|
RandomStream = new RandomStream(ChosenSeed);
|
|
if (retryCount >= MaxAttemptCount && Application.isEditor)
|
|
{
|
|
string text = "Failed to generate the dungeon " + MaxAttemptCount + " times.\nThis could indicate a problem with the way the tiles are set up. Try to make sure most rooms have more than one doorway and that all doorways are easily accessible.\nHere are a list of all reasons a tile placement had to be retried:";
|
|
foreach (KeyValuePair<TilePlacementResult, int> tilePlacementResultCounter in tilePlacementResultCounters)
|
|
{
|
|
if (tilePlacementResultCounter.Value > 0)
|
|
{
|
|
text = text + "\n" + tilePlacementResultCounter.Key.ToString() + " (x" + tilePlacementResultCounter.Value + ")";
|
|
}
|
|
}
|
|
UnityEngine.Debug.LogError(text);
|
|
ChangeStatus(GenerationStatus.Failed);
|
|
yield break;
|
|
}
|
|
retryCount++;
|
|
GenerationStats.IncrementRetryCount();
|
|
if (this.Retrying != null)
|
|
{
|
|
this.Retrying();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retryCount = 0;
|
|
GenerationStats.Clear();
|
|
}
|
|
CurrentDungeon = Root.GetComponent<Dungeon>();
|
|
if (CurrentDungeon == null)
|
|
{
|
|
CurrentDungeon = Root.AddComponent<Dungeon>();
|
|
}
|
|
CurrentDungeon.DebugRender = DebugRender;
|
|
CurrentDungeon.PreGenerateDungeon(this);
|
|
Clear(stopCoroutines: false);
|
|
targetLength = Mathf.RoundToInt((float)DungeonFlow.Length.GetRandom(RandomStream) * LengthMultiplier);
|
|
targetLength = Mathf.Max(targetLength, 2);
|
|
Transform debugVisualsRoot = ((PauseBetweenRooms > 0f) ? Root.transform : null);
|
|
proxyDungeon = new DungeonProxy(debugVisualsRoot);
|
|
GenerationStats.BeginTime(GenerationStatus.TileInjection);
|
|
if (tilesPendingInjection == null)
|
|
{
|
|
tilesPendingInjection = new List<InjectedTile>();
|
|
}
|
|
else
|
|
{
|
|
tilesPendingInjection.Clear();
|
|
}
|
|
injectedTiles.Clear();
|
|
GatherTilesToInject();
|
|
GenerationStats.BeginTime(GenerationStatus.PreProcessing);
|
|
PreProcess();
|
|
GenerationStats.BeginTime(GenerationStatus.MainPath);
|
|
yield return Wait(GenerateMainPath());
|
|
if (Status == GenerationStatus.Complete || Status == GenerationStatus.Failed)
|
|
{
|
|
yield break;
|
|
}
|
|
GenerationStats.BeginTime(GenerationStatus.Branching);
|
|
yield return Wait(GenerateBranchPaths());
|
|
foreach (InjectedTile item in tilesPendingInjection)
|
|
{
|
|
if (item.IsRequired)
|
|
{
|
|
yield return Wait(InnerGenerate(isRetry: true));
|
|
yield break;
|
|
}
|
|
}
|
|
if (Status == GenerationStatus.Complete || Status == GenerationStatus.Failed)
|
|
{
|
|
yield break;
|
|
}
|
|
if (DungeonFlow.BranchPruneTags.Count > 0)
|
|
{
|
|
PruneBranches();
|
|
}
|
|
proxyDungeon.ConnectOverlappingDoorways(DungeonFlow.DoorwayConnectionChance, DungeonFlow, RandomStream);
|
|
CurrentDungeon.FromProxy(proxyDungeon, this);
|
|
yield return Wait(PostProcess());
|
|
yield return null;
|
|
IDungeonCompleteReceiver[] componentsInChildren = CurrentDungeon.gameObject.GetComponentsInChildren<IDungeonCompleteReceiver>(includeInactive: false);
|
|
for (int i = 0; i < componentsInChildren.Length; i++)
|
|
{
|
|
componentsInChildren[i].OnDungeonComplete(CurrentDungeon);
|
|
}
|
|
ChangeStatus(GenerationStatus.Complete);
|
|
if (true)
|
|
{
|
|
DungenCharacter[] array = UnityEngine.Object.FindObjectsOfType<DungenCharacter>();
|
|
for (int i = 0; i < array.Length; i++)
|
|
{
|
|
array[i].ForceRecheckTile();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void PruneBranches()
|
|
{
|
|
Stack<TileProxy> stack = new Stack<TileProxy>();
|
|
foreach (TileProxy tile2 in proxyDungeon.BranchPathTiles)
|
|
{
|
|
if (!tile2.UsedDoorways.Select((DoorwayProxy d) => d.ConnectedDoorway.TileProxy).Any((TileProxy t) => t.Placement.BranchDepth > tile2.Placement.BranchDepth))
|
|
{
|
|
stack.Push(tile2);
|
|
}
|
|
}
|
|
while (stack.Count > 0)
|
|
{
|
|
TileProxy tile = stack.Pop();
|
|
if ((tile.Placement.InjectionData == null || !tile.Placement.InjectionData.IsRequired) && DungeonFlow.ShouldPruneTileWithTags(tile.PrefabTile.Tags))
|
|
{
|
|
ProxyDoorwayConnection connection = (from d in tile.UsedDoorways
|
|
select d.ConnectedDoorway into d
|
|
where d.TileProxy.Placement.IsOnMainPath || d.TileProxy.Placement.BranchDepth < tile.Placement.BranchDepth
|
|
select new ProxyDoorwayConnection(d, d.ConnectedDoorway)).First();
|
|
proxyDungeon.RemoveTile(tile);
|
|
proxyDungeon.RemoveConnection(connection);
|
|
GenerationStats.PrunedBranchTileCount++;
|
|
TileProxy tileProxy = connection.A.TileProxy;
|
|
if (!tileProxy.Placement.IsOnMainPath)
|
|
{
|
|
stack.Push(tileProxy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual void Clear(bool stopCoroutines)
|
|
{
|
|
if (stopCoroutines)
|
|
{
|
|
CoroutineHelper.StopAll();
|
|
}
|
|
if (proxyDungeon != null)
|
|
{
|
|
proxyDungeon.ClearDebugVisuals();
|
|
}
|
|
proxyDungeon = null;
|
|
if (CurrentDungeon != null)
|
|
{
|
|
CurrentDungeon.Clear();
|
|
}
|
|
useableTiles.Clear();
|
|
preProcessData.Clear();
|
|
previousLineSegment = null;
|
|
tilePlacementResultCounters.Clear();
|
|
if (this.Cleared != null)
|
|
{
|
|
this.Cleared();
|
|
}
|
|
}
|
|
|
|
private void ChangeStatus(GenerationStatus status)
|
|
{
|
|
GenerationStatus status2 = Status;
|
|
Status = status;
|
|
if (status == GenerationStatus.Complete || status == GenerationStatus.Failed)
|
|
{
|
|
IsGenerating = false;
|
|
}
|
|
if (status == GenerationStatus.Failed)
|
|
{
|
|
Clear(stopCoroutines: true);
|
|
}
|
|
if (status2 != status)
|
|
{
|
|
this.OnGenerationStatusChanged?.Invoke(this, status);
|
|
DungeonGenerator.OnAnyDungeonGenerationStatusChanged?.Invoke(this, status);
|
|
}
|
|
}
|
|
|
|
protected virtual void PreProcess()
|
|
{
|
|
if (preProcessData.Count > 0)
|
|
{
|
|
return;
|
|
}
|
|
ChangeStatus(GenerationStatus.PreProcessing);
|
|
foreach (TileSet item in DungeonFlow.GetUsedTileSets().Concat(tilesPendingInjection.Select((InjectedTile x) => x.TileSet)).Distinct())
|
|
{
|
|
foreach (GameObjectChance weight in item.TileWeights.Weights)
|
|
{
|
|
if (weight.Value != null)
|
|
{
|
|
useableTiles.Add(weight.Value);
|
|
weight.TileSet = item;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void GatherTilesToInject()
|
|
{
|
|
RandomStream randomStream = new RandomStream(ChosenSeed);
|
|
foreach (TileInjectionRule tileInjectionRule in DungeonFlow.TileInjectionRules)
|
|
{
|
|
if (!(tileInjectionRule.TileSet == null) && (tileInjectionRule.CanAppearOnMainPath || tileInjectionRule.CanAppearOnBranchPath))
|
|
{
|
|
bool isOnMainPath = !tileInjectionRule.CanAppearOnBranchPath || (tileInjectionRule.CanAppearOnMainPath && randomStream.NextDouble() > 0.5);
|
|
InjectedTile item = new InjectedTile(tileInjectionRule, isOnMainPath, randomStream);
|
|
tilesPendingInjection.Add(item);
|
|
}
|
|
}
|
|
if (this.TileInjectionMethods != null)
|
|
{
|
|
this.TileInjectionMethods(randomStream, ref tilesPendingInjection);
|
|
}
|
|
}
|
|
|
|
protected virtual IEnumerator GenerateMainPath()
|
|
{
|
|
ChangeStatus(GenerationStatus.MainPath);
|
|
nextNodeIndex = 0;
|
|
List<GraphNode> list = new List<GraphNode>(DungeonFlow.Nodes.Count);
|
|
bool flag = false;
|
|
int num = 0;
|
|
List<List<TileSet>> tileSets = new List<List<TileSet>>(targetLength);
|
|
List<DungeonArchetype> archetypes = new List<DungeonArchetype>(targetLength);
|
|
List<GraphNode> nodes = new List<GraphNode>(targetLength);
|
|
List<GraphLine> lines = new List<GraphLine>(targetLength);
|
|
while (!flag)
|
|
{
|
|
float num2 = Mathf.Clamp((float)num / (float)(targetLength - 1), 0f, 1f);
|
|
GraphLine lineAtDepth = DungeonFlow.GetLineAtDepth(num2);
|
|
if (lineAtDepth == null)
|
|
{
|
|
yield return Wait(InnerGenerate(isRetry: true));
|
|
yield break;
|
|
}
|
|
if (lineAtDepth != previousLineSegment)
|
|
{
|
|
currentArchetype = lineAtDepth.GetRandomArchetype(RandomStream, archetypes);
|
|
previousLineSegment = lineAtDepth;
|
|
}
|
|
GraphNode graphNode = null;
|
|
GraphNode[] array = DungeonFlow.Nodes.OrderBy((GraphNode x) => x.Position).ToArray();
|
|
GraphNode[] array2 = array;
|
|
foreach (GraphNode graphNode2 in array2)
|
|
{
|
|
if (num2 >= graphNode2.Position && !list.Contains(graphNode2))
|
|
{
|
|
graphNode = graphNode2;
|
|
list.Add(graphNode2);
|
|
break;
|
|
}
|
|
}
|
|
List<TileSet> tileSets2;
|
|
if (graphNode != null)
|
|
{
|
|
tileSets2 = graphNode.TileSets;
|
|
nextNodeIndex = ((nextNodeIndex >= array.Length - 1) ? (-1) : (nextNodeIndex + 1));
|
|
archetypes.Add(null);
|
|
lines.Add(null);
|
|
nodes.Add(graphNode);
|
|
if (graphNode == array[^1])
|
|
{
|
|
flag = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tileSets2 = currentArchetype.TileSets;
|
|
archetypes.Add(currentArchetype);
|
|
lines.Add(lineAtDepth);
|
|
nodes.Add(null);
|
|
}
|
|
tileSets.Add(tileSets2);
|
|
num++;
|
|
}
|
|
int tileRetryCount = 0;
|
|
int totalForLoopRetryCount = 0;
|
|
for (int i = 0; i < tileSets.Count; i++)
|
|
{
|
|
TileProxy attachTo = ((i == 0) ? null : proxyDungeon.MainPathTiles[proxyDungeon.MainPathTiles.Count - 1]);
|
|
TileProxy tileProxy = AddTile(attachTo, tileSets[i], (float)i / (float)(tileSets.Count - 1), archetypes[i]);
|
|
if (i > 5 && tileProxy == null && tileRetryCount < 5 && totalForLoopRetryCount < 20)
|
|
{
|
|
TileProxy tileProxy2 = proxyDungeon.MainPathTiles[i - 1];
|
|
if (injectedTiles.TryGetValue(tileProxy2, out var value))
|
|
{
|
|
tilesPendingInjection.Add(value);
|
|
injectedTiles.Remove(tileProxy2);
|
|
}
|
|
proxyDungeon.RemoveLastConnection();
|
|
proxyDungeon.RemoveTile(tileProxy2);
|
|
i -= 2;
|
|
tileRetryCount++;
|
|
totalForLoopRetryCount++;
|
|
}
|
|
else
|
|
{
|
|
if (tileProxy == null)
|
|
{
|
|
yield return Wait(InnerGenerate(isRetry: true));
|
|
break;
|
|
}
|
|
tileProxy.Placement.GraphNode = nodes[i];
|
|
tileProxy.Placement.GraphLine = lines[i];
|
|
tileRetryCount = 0;
|
|
if (ShouldSkipFrame(isRoomPlacement: true))
|
|
{
|
|
yield return GetRoomPause();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool ShouldSkipFrame(bool isRoomPlacement)
|
|
{
|
|
if (!GenerateAsynchronously)
|
|
{
|
|
return false;
|
|
}
|
|
if (isRoomPlacement && PauseBetweenRooms > 0f)
|
|
{
|
|
return true;
|
|
}
|
|
if (yieldTimer.Elapsed.TotalMilliseconds >= (double)MaxAsyncFrameMilliseconds)
|
|
{
|
|
yieldTimer.Restart();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private YieldInstruction GetRoomPause()
|
|
{
|
|
if (PauseBetweenRooms > 0f)
|
|
{
|
|
return new WaitForSeconds(PauseBetweenRooms);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected virtual IEnumerator GenerateBranchPaths()
|
|
{
|
|
ChangeStatus(GenerationStatus.Branching);
|
|
int[] mainPathBranches = new int[proxyDungeon.MainPathTiles.Count];
|
|
BranchCountHelper.ComputeBranchCounts(DungeonFlow, RandomStream, proxyDungeon, ref mainPathBranches);
|
|
for (int b = 0; b < mainPathBranches.Length; b++)
|
|
{
|
|
TileProxy tile = proxyDungeon.MainPathTiles[b];
|
|
int branchCount = mainPathBranches[b];
|
|
if (tile.Placement.Archetype == null || branchCount == 0)
|
|
{
|
|
continue;
|
|
}
|
|
for (int i = 0; i < branchCount; i++)
|
|
{
|
|
TileProxy previousTile = tile;
|
|
int branchDepth = tile.Placement.Archetype.BranchingDepth.GetRandom(RandomStream);
|
|
for (int j = 0; j < branchDepth; j++)
|
|
{
|
|
List<TileSet> useableTileSets = ((j != branchDepth - 1 || !tile.Placement.Archetype.GetHasValidBranchCapTiles()) ? tile.Placement.Archetype.TileSets : ((tile.Placement.Archetype.BranchCapType != 0) ? tile.Placement.Archetype.TileSets.Concat(tile.Placement.Archetype.BranchCapTileSets).ToList() : tile.Placement.Archetype.BranchCapTileSets));
|
|
float num = ((branchDepth <= 1) ? 1f : ((float)j / (float)(branchDepth - 1)));
|
|
TileProxy tileProxy = AddTile(previousTile, useableTileSets, num, tile.Placement.Archetype);
|
|
if (tileProxy == null)
|
|
{
|
|
break;
|
|
}
|
|
tileProxy.Placement.BranchDepth = j;
|
|
tileProxy.Placement.NormalizedBranchDepth = num;
|
|
tileProxy.Placement.GraphNode = previousTile.Placement.GraphNode;
|
|
tileProxy.Placement.GraphLine = previousTile.Placement.GraphLine;
|
|
previousTile = tileProxy;
|
|
if (ShouldSkipFrame(isRoomPlacement: true))
|
|
{
|
|
yield return GetRoomPause();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual TileProxy AddTile(TileProxy attachTo, IEnumerable<TileSet> useableTileSets, float normalizedDepth, DungeonArchetype archetype, TilePlacementResult result = TilePlacementResult.None)
|
|
{
|
|
bool flag = Status == GenerationStatus.MainPath;
|
|
bool flag2 = attachTo == null;
|
|
InjectedTile injectedTile = null;
|
|
int index = -1;
|
|
bool flag3 = flag && archetype == null;
|
|
if (tilesPendingInjection != null && !flag3)
|
|
{
|
|
float pathDepth = (flag ? normalizedDepth : ((float)attachTo.Placement.PathDepth / ((float)targetLength - 1f)));
|
|
float branchDepth = (flag ? 0f : normalizedDepth);
|
|
for (int i = 0; i < tilesPendingInjection.Count; i++)
|
|
{
|
|
InjectedTile injectedTile2 = tilesPendingInjection[i];
|
|
if (injectedTile2.ShouldInjectTileAtPoint(flag, pathDepth, branchDepth))
|
|
{
|
|
injectedTile = injectedTile2;
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
IEnumerable<GameObjectChance> collection = ((injectedTile == null) ? useableTileSets.SelectMany((TileSet x) => x.TileWeights.Weights) : new List<GameObjectChance>(injectedTile.TileSet.TileWeights.Weights));
|
|
bool value = !flag2 && attachTo.PrefabTile.AllowRotation;
|
|
if (OverrideAllowTileRotation)
|
|
{
|
|
value = AllowTileRotation;
|
|
}
|
|
DoorwayPairFinder obj = new DoorwayPairFinder
|
|
{
|
|
DungeonFlow = DungeonFlow,
|
|
RandomStream = RandomStream,
|
|
Archetype = archetype,
|
|
GetTileTemplateDelegate = GetTileTemplate,
|
|
IsOnMainPath = flag,
|
|
NormalizedDepth = normalizedDepth,
|
|
PreviousTile = attachTo,
|
|
UpVector = UpVector,
|
|
AllowRotation = value,
|
|
TileWeights = new List<GameObjectChance>(collection),
|
|
IsTileAllowedPredicate = delegate(TileProxy previousTile, TileProxy potentialNextTile, ref float weight)
|
|
{
|
|
bool flag4 = previousTile != null && potentialNextTile.Prefab == previousTile.Prefab;
|
|
TileRepeatMode tileRepeatMode = TileRepeatMode.Allow;
|
|
if (OverrideRepeatMode)
|
|
{
|
|
tileRepeatMode = RepeatMode;
|
|
}
|
|
else if (potentialNextTile != null)
|
|
{
|
|
tileRepeatMode = potentialNextTile.PrefabTile.RepeatMode;
|
|
}
|
|
bool flag5 = true;
|
|
return tileRepeatMode switch
|
|
{
|
|
TileRepeatMode.Allow => true,
|
|
TileRepeatMode.DisallowImmediate => !flag4,
|
|
TileRepeatMode.Disallow => !proxyDungeon.AllTiles.Where((TileProxy t) => t.Prefab == potentialNextTile.Prefab).Any(),
|
|
_ => throw new NotImplementedException("TileRepeatMode " + tileRepeatMode.ToString() + " is not implemented"),
|
|
};
|
|
}
|
|
};
|
|
int? maxCount = (UseMaximumPairingAttempts ? new int?(MaxPairingAttempts) : null);
|
|
Queue<DoorwayPair> doorwayPairs = obj.GetDoorwayPairs(maxCount);
|
|
TilePlacementResult tilePlacementResult = TilePlacementResult.NoValidTile;
|
|
TileProxy tile = null;
|
|
while (doorwayPairs.Count > 0)
|
|
{
|
|
DoorwayPair pair = doorwayPairs.Dequeue();
|
|
tilePlacementResult = TryPlaceTile(pair, archetype, out tile);
|
|
if (tilePlacementResult == TilePlacementResult.None)
|
|
{
|
|
break;
|
|
}
|
|
AddTilePlacementResult(tilePlacementResult);
|
|
}
|
|
if (tilePlacementResult == TilePlacementResult.None)
|
|
{
|
|
if (injectedTile != null)
|
|
{
|
|
tile.Placement.InjectionData = injectedTile;
|
|
injectedTiles[tile] = injectedTile;
|
|
tilesPendingInjection.RemoveAt(index);
|
|
if (flag)
|
|
{
|
|
targetLength++;
|
|
}
|
|
}
|
|
return tile;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
protected void AddTilePlacementResult(TilePlacementResult result)
|
|
{
|
|
if (!tilePlacementResultCounters.TryGetValue(result, out var value))
|
|
{
|
|
tilePlacementResultCounters[result] = 1;
|
|
}
|
|
else
|
|
{
|
|
tilePlacementResultCounters[result] = value + 1;
|
|
}
|
|
}
|
|
|
|
protected TilePlacementResult TryPlaceTile(DoorwayPair pair, DungeonArchetype archetype, out TileProxy tile)
|
|
{
|
|
tile = null;
|
|
TileProxy nextTemplate = pair.NextTemplate;
|
|
DoorwayProxy previousDoorway = pair.PreviousDoorway;
|
|
if (nextTemplate == null)
|
|
{
|
|
return TilePlacementResult.TemplateIsNull;
|
|
}
|
|
int index = pair.NextTemplate.Doorways.IndexOf(pair.NextDoorway);
|
|
tile = new TileProxy(nextTemplate);
|
|
tile.Placement.IsOnMainPath = Status == GenerationStatus.MainPath;
|
|
tile.Placement.Archetype = archetype;
|
|
tile.Placement.TileSet = pair.NextTileSet;
|
|
if (previousDoorway != null)
|
|
{
|
|
DoorwayProxy myDoorway = tile.Doorways[index];
|
|
tile.PositionBySocket(myDoorway, previousDoorway);
|
|
Bounds bounds = tile.Placement.Bounds;
|
|
if (RestrictDungeonToBounds && !TilePlacementBounds.Contains(bounds))
|
|
{
|
|
return TilePlacementResult.OutOfBounds;
|
|
}
|
|
if (IsCollidingWithAnyTile(tile, previousDoorway.TileProxy))
|
|
{
|
|
return TilePlacementResult.TileIsColliding;
|
|
}
|
|
}
|
|
if (tile == null)
|
|
{
|
|
return TilePlacementResult.NewTileIsNull;
|
|
}
|
|
if (tile.Placement.IsOnMainPath)
|
|
{
|
|
if (pair.PreviousTile != null)
|
|
{
|
|
tile.Placement.PathDepth = pair.PreviousTile.Placement.PathDepth + 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tile.Placement.PathDepth = pair.PreviousTile.Placement.PathDepth;
|
|
tile.Placement.BranchDepth = ((!pair.PreviousTile.Placement.IsOnMainPath) ? (pair.PreviousTile.Placement.BranchDepth + 1) : 0);
|
|
}
|
|
if (previousDoorway != null)
|
|
{
|
|
DoorwayProxy b = tile.Doorways[index];
|
|
proxyDungeon.MakeConnection(previousDoorway, b);
|
|
}
|
|
proxyDungeon.AddTile(tile);
|
|
return TilePlacementResult.None;
|
|
}
|
|
|
|
protected TileProxy GetTileTemplate(GameObject prefab)
|
|
{
|
|
TileProxy tileProxy = preProcessData.Where((TileProxy x) => x.Prefab == prefab).FirstOrDefault();
|
|
if (tileProxy == null)
|
|
{
|
|
tileProxy = new TileProxy(prefab, IgnoreSpriteBounds, UpVector);
|
|
preProcessData.Add(tileProxy);
|
|
}
|
|
return tileProxy;
|
|
}
|
|
|
|
protected TileProxy PickRandomTemplate(DoorwaySocket socketGroupFilter)
|
|
{
|
|
GameObject prefab = useableTiles[RandomStream.Next(0, useableTiles.Count)];
|
|
TileProxy tileTemplate = GetTileTemplate(prefab);
|
|
if (socketGroupFilter != null && !tileTemplate.UnusedDoorways.Where((DoorwayProxy d) => d.Socket == socketGroupFilter).Any())
|
|
{
|
|
return PickRandomTemplate(socketGroupFilter);
|
|
}
|
|
return tileTemplate;
|
|
}
|
|
|
|
protected int NormalizedDepthToIndex(float normalizedDepth)
|
|
{
|
|
return Mathf.RoundToInt(normalizedDepth * (float)(targetLength - 1));
|
|
}
|
|
|
|
protected float IndexToNormalizedDepth(int index)
|
|
{
|
|
return (float)index / (float)targetLength;
|
|
}
|
|
|
|
protected bool IsCollidingWithAnyTile(TileProxy newTile, TileProxy previousTile)
|
|
{
|
|
foreach (TileProxy allTile in proxyDungeon.AllTiles)
|
|
{
|
|
bool flag = previousTile == allTile;
|
|
float maxOverlap = (flag ? OverlapThreshold : (0f - Padding));
|
|
if (DisallowOverhangs && !flag)
|
|
{
|
|
if (newTile.IsOverlappingOrOverhanging(allTile, UpDirection, maxOverlap))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else if (newTile.IsOverlapping(allTile, maxOverlap))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void RegisterPostProcessStep(Action<DungeonGenerator> postProcessCallback, int priority = 0, PostProcessPhase phase = PostProcessPhase.AfterBuiltIn)
|
|
{
|
|
postProcessSteps.Add(new DungeonGeneratorPostProcessStep(postProcessCallback, priority, phase));
|
|
}
|
|
|
|
public void UnregisterPostProcessStep(Action<DungeonGenerator> postProcessCallback)
|
|
{
|
|
for (int i = 0; i < postProcessSteps.Count; i++)
|
|
{
|
|
if (postProcessSteps[i].PostProcessCallback == postProcessCallback)
|
|
{
|
|
postProcessSteps.RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual IEnumerator PostProcess()
|
|
{
|
|
int length = proxyDungeon.MainPathTiles.Count;
|
|
int maxBranchDepth = 0;
|
|
if (proxyDungeon.BranchPathTiles.Count > 0)
|
|
{
|
|
List<TileProxy> list = proxyDungeon.BranchPathTiles.ToList();
|
|
list.Sort((TileProxy a, TileProxy b) => b.Placement.BranchDepth.CompareTo(a.Placement.BranchDepth));
|
|
maxBranchDepth = list[0].Placement.BranchDepth;
|
|
}
|
|
yield return null;
|
|
GenerationStats.BeginTime(GenerationStatus.PostProcessing);
|
|
ChangeStatus(GenerationStatus.PostProcessing);
|
|
postProcessSteps.Sort((DungeonGeneratorPostProcessStep a, DungeonGeneratorPostProcessStep b) => b.Priority.CompareTo(a.Priority));
|
|
foreach (DungeonGeneratorPostProcessStep step2 in postProcessSteps)
|
|
{
|
|
if (ShouldSkipFrame(isRoomPlacement: false))
|
|
{
|
|
yield return null;
|
|
}
|
|
if (step2.Phase == PostProcessPhase.BeforeBuiltIn)
|
|
{
|
|
step2.PostProcessCallback(this);
|
|
}
|
|
}
|
|
yield return null;
|
|
if (!IsAnalysis)
|
|
{
|
|
foreach (Tile tile2 in CurrentDungeon.AllTiles)
|
|
{
|
|
if (ShouldSkipFrame(isRoomPlacement: false))
|
|
{
|
|
yield return null;
|
|
}
|
|
tile2.Placement.NormalizedPathDepth = (float)tile2.Placement.PathDepth / (float)(length - 1);
|
|
}
|
|
CurrentDungeon.PostGenerateDungeon(this);
|
|
foreach (Tile tile2 in CurrentDungeon.AllTiles)
|
|
{
|
|
if (ShouldSkipFrame(isRoomPlacement: false))
|
|
{
|
|
yield return null;
|
|
}
|
|
ProcessProps(tile2, tile2.gameObject);
|
|
}
|
|
ProcessGlobalProps();
|
|
if (DungeonFlow.KeyManager != null)
|
|
{
|
|
PlaceLocksAndKeys();
|
|
}
|
|
}
|
|
GenerationStats.SetRoomStatistics(CurrentDungeon.MainPathTiles.Count, CurrentDungeon.BranchPathTiles.Count, maxBranchDepth);
|
|
preProcessData.Clear();
|
|
yield return null;
|
|
foreach (DungeonGeneratorPostProcessStep step2 in postProcessSteps)
|
|
{
|
|
if (ShouldSkipFrame(isRoomPlacement: false))
|
|
{
|
|
yield return null;
|
|
}
|
|
if (step2.Phase == PostProcessPhase.AfterBuiltIn)
|
|
{
|
|
step2.PostProcessCallback(this);
|
|
}
|
|
}
|
|
GenerationStats.EndTime();
|
|
foreach (GameObject door in CurrentDungeon.Doors)
|
|
{
|
|
if (door != null)
|
|
{
|
|
door.SetActive(value: true);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void ProcessProps(Tile tile, GameObject root)
|
|
{
|
|
if (root == null)
|
|
{
|
|
return;
|
|
}
|
|
RandomProp[] components = root.GetComponents<RandomProp>();
|
|
for (int i = 0; i < components.Length; i++)
|
|
{
|
|
components[i].Process(RandomStream, tile);
|
|
}
|
|
if (root == null)
|
|
{
|
|
return;
|
|
}
|
|
int childCount = root.transform.childCount;
|
|
List<GameObject> list = new List<GameObject>(childCount);
|
|
for (int j = 0; j < childCount; j++)
|
|
{
|
|
GameObject gameObject = root.transform.GetChild(j).gameObject;
|
|
list.Add(gameObject);
|
|
}
|
|
foreach (GameObject item in list)
|
|
{
|
|
if (item != null)
|
|
{
|
|
ProcessProps(tile, item);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected virtual void ProcessGlobalProps()
|
|
{
|
|
Dictionary<int, GameObjectChanceTable> dictionary = new Dictionary<int, GameObjectChanceTable>();
|
|
foreach (Tile allTile in CurrentDungeon.AllTiles)
|
|
{
|
|
GlobalProp[] componentsInChildren = allTile.GetComponentsInChildren<GlobalProp>();
|
|
foreach (GlobalProp globalProp in componentsInChildren)
|
|
{
|
|
GameObjectChanceTable value = null;
|
|
if (!dictionary.TryGetValue(globalProp.PropGroupID, out value))
|
|
{
|
|
value = new GameObjectChanceTable();
|
|
dictionary[globalProp.PropGroupID] = value;
|
|
}
|
|
float num = (allTile.Placement.IsOnMainPath ? globalProp.MainPathWeight : globalProp.BranchPathWeight);
|
|
num *= globalProp.DepthWeightScale.Evaluate(allTile.Placement.NormalizedDepth);
|
|
value.Weights.Add(new GameObjectChance(globalProp.gameObject, num, 0f, null));
|
|
}
|
|
}
|
|
foreach (GameObjectChanceTable value2 in dictionary.Values)
|
|
{
|
|
foreach (GameObjectChance weight in value2.Weights)
|
|
{
|
|
weight.Value.SetActive(value: false);
|
|
}
|
|
}
|
|
List<int> list = new List<int>(dictionary.Count);
|
|
foreach (KeyValuePair<int, GameObjectChanceTable> pair in dictionary)
|
|
{
|
|
if (list.Contains(pair.Key))
|
|
{
|
|
UnityEngine.Debug.LogWarning("Dungeon Flow contains multiple entries for the global prop group ID: " + pair.Key + ". Only the first entry will be used.");
|
|
continue;
|
|
}
|
|
DungeonFlow.GlobalPropSettings globalPropSettings = DungeonFlow.GlobalProps.Where((DungeonFlow.GlobalPropSettings x) => x.ID == pair.Key).FirstOrDefault();
|
|
if (globalPropSettings == null)
|
|
{
|
|
continue;
|
|
}
|
|
GameObjectChanceTable gameObjectChanceTable = pair.Value.Clone();
|
|
int random = globalPropSettings.Count.GetRandom(RandomStream);
|
|
random = Mathf.Clamp(random, 0, gameObjectChanceTable.Weights.Count);
|
|
for (int j = 0; j < random; j++)
|
|
{
|
|
GameObjectChance random2 = gameObjectChanceTable.GetRandom(RandomStream, isOnMainPath: true, 0f, null, allowImmediateRepeats: true, removeFromTable: true);
|
|
if (random2 != null && random2.Value != null)
|
|
{
|
|
random2.Value.SetActive(value: true);
|
|
}
|
|
}
|
|
list.Add(pair.Key);
|
|
}
|
|
}
|
|
|
|
protected virtual void PlaceLocksAndKeys()
|
|
{
|
|
GraphNode[] array = (from x in CurrentDungeon.ConnectionGraph.Nodes
|
|
select x.Tile.Placement.GraphNode into x
|
|
where x != null
|
|
select x).Distinct().ToArray();
|
|
GraphLine[] array2 = (from x in CurrentDungeon.ConnectionGraph.Nodes
|
|
select x.Tile.Placement.GraphLine into x
|
|
where x != null
|
|
select x).Distinct().ToArray();
|
|
Dictionary<Doorway, Key> lockedDoorways = new Dictionary<Doorway, Key>();
|
|
GraphNode[] array3 = array;
|
|
foreach (GraphNode node in array3)
|
|
{
|
|
foreach (KeyLockPlacement @lock in node.Locks)
|
|
{
|
|
Tile tile = CurrentDungeon.AllTiles.Where((Tile x) => x.Placement.GraphNode == node).FirstOrDefault();
|
|
List<DungeonGraphConnection> connections = CurrentDungeon.ConnectionGraph.Nodes.Where((DungeonGraphNode x) => x.Tile == tile).FirstOrDefault().Connections;
|
|
Doorway doorway = null;
|
|
Doorway doorway2 = null;
|
|
foreach (DungeonGraphConnection item in connections)
|
|
{
|
|
if (item.DoorwayA.Tile == tile)
|
|
{
|
|
doorway2 = item.DoorwayA;
|
|
}
|
|
else if (item.DoorwayB.Tile == tile)
|
|
{
|
|
doorway = item.DoorwayB;
|
|
}
|
|
}
|
|
Key keyByID = node.Graph.KeyManager.GetKeyByID(@lock.ID);
|
|
if (doorway != null && (node.LockPlacement & NodeLockPlacement.Entrance) == NodeLockPlacement.Entrance)
|
|
{
|
|
lockedDoorways.Add(doorway, keyByID);
|
|
}
|
|
if (doorway2 != null && (node.LockPlacement & NodeLockPlacement.Exit) == NodeLockPlacement.Exit)
|
|
{
|
|
lockedDoorways.Add(doorway2, keyByID);
|
|
}
|
|
}
|
|
}
|
|
GraphLine[] array4 = array2;
|
|
foreach (GraphLine line in array4)
|
|
{
|
|
List<Doorway> list = (from x in CurrentDungeon.ConnectionGraph.Connections.Where(delegate(DungeonGraphConnection x)
|
|
{
|
|
bool flag4 = lockedDoorways.ContainsKey(x.DoorwayA) || lockedDoorways.ContainsKey(x.DoorwayB);
|
|
bool flag5 = x.DoorwayA.Tile.Placement.TileSet.LockPrefabs.Count > 0;
|
|
return x.DoorwayA.Tile.Placement.GraphLine == line && x.DoorwayB.Tile.Placement.GraphLine == line && !flag4 && flag5;
|
|
})
|
|
select x.DoorwayA).ToList();
|
|
if (list.Count == 0)
|
|
{
|
|
continue;
|
|
}
|
|
foreach (KeyLockPlacement lock2 in line.Locks)
|
|
{
|
|
int random = lock2.Range.GetRandom(RandomStream);
|
|
random = Mathf.Clamp(random, 0, list.Count);
|
|
for (int j = 0; j < random; j++)
|
|
{
|
|
if (list.Count == 0)
|
|
{
|
|
break;
|
|
}
|
|
Doorway doorway3 = list[RandomStream.Next(0, list.Count)];
|
|
list.Remove(doorway3);
|
|
if (!lockedDoorways.ContainsKey(doorway3))
|
|
{
|
|
Key keyByID2 = line.Graph.KeyManager.GetKeyByID(lock2.ID);
|
|
lockedDoorways.Add(doorway3, keyByID2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
foreach (Tile allTile in CurrentDungeon.AllTiles)
|
|
{
|
|
if (allTile.Placement.InjectionData == null || !allTile.Placement.InjectionData.IsLocked)
|
|
{
|
|
continue;
|
|
}
|
|
List<Doorway> list2 = new List<Doorway>();
|
|
foreach (Doorway usedDoorway in allTile.UsedDoorways)
|
|
{
|
|
bool num = lockedDoorways.ContainsKey(usedDoorway) || lockedDoorways.ContainsKey(usedDoorway.ConnectedDoorway);
|
|
bool flag = allTile.Placement.TileSet.LockPrefabs.Count > 0;
|
|
bool flag2 = allTile.GetEntranceDoorway() == usedDoorway;
|
|
if (!num && flag && flag2)
|
|
{
|
|
list2.Add(usedDoorway);
|
|
}
|
|
}
|
|
if (list2.Any())
|
|
{
|
|
Doorway key2 = list2.First();
|
|
Key keyByID3 = DungeonFlow.KeyManager.GetKeyByID(allTile.Placement.InjectionData.LockID);
|
|
lockedDoorways.Add(key2, keyByID3);
|
|
}
|
|
}
|
|
List<Doorway> list3 = new List<Doorway>();
|
|
foreach (KeyValuePair<Doorway, Key> item2 in lockedDoorways)
|
|
{
|
|
Doorway key3 = item2.Key;
|
|
Key key = item2.Value;
|
|
List<Tile> list4 = new List<Tile>();
|
|
foreach (Tile allTile2 in CurrentDungeon.AllTiles)
|
|
{
|
|
if (!(allTile2.Placement.NormalizedPathDepth >= key3.Tile.Placement.NormalizedPathDepth))
|
|
{
|
|
bool flag3 = false;
|
|
if (allTile2.Placement.GraphNode != null && allTile2.Placement.GraphNode.Keys.Where((KeyLockPlacement x) => x.ID == key.ID).Count() > 0)
|
|
{
|
|
flag3 = true;
|
|
}
|
|
else if (allTile2.Placement.GraphLine != null && allTile2.Placement.GraphLine.Keys.Where((KeyLockPlacement x) => x.ID == key.ID).Count() > 0)
|
|
{
|
|
flag3 = true;
|
|
}
|
|
if (flag3)
|
|
{
|
|
list4.Add(allTile2);
|
|
}
|
|
}
|
|
}
|
|
List<IKeySpawnable> list5 = list4.SelectMany((Tile x) => x.GetComponentsInChildren<Component>().OfType<IKeySpawnable>()).ToList();
|
|
if (list5.Count == 0)
|
|
{
|
|
list3.Add(key3);
|
|
continue;
|
|
}
|
|
int random2 = key.KeysPerLock.GetRandom(RandomStream);
|
|
random2 = Math.Min(random2, list5.Count);
|
|
for (int k = 0; k < random2; k++)
|
|
{
|
|
int index = RandomStream.Next(0, list5.Count);
|
|
IKeySpawnable keySpawnable = list5[index];
|
|
keySpawnable.SpawnKey(key, DungeonFlow.KeyManager);
|
|
foreach (IKeyLock item3 in (keySpawnable as Component).GetComponentsInChildren<Component>().OfType<IKeyLock>())
|
|
{
|
|
item3.OnKeyAssigned(key, DungeonFlow.KeyManager);
|
|
}
|
|
list5.RemoveAt(index);
|
|
}
|
|
}
|
|
foreach (Doorway item4 in list3)
|
|
{
|
|
lockedDoorways.Remove(item4);
|
|
}
|
|
foreach (KeyValuePair<Doorway, Key> item5 in lockedDoorways)
|
|
{
|
|
item5.Key.RemoveUsedPrefab();
|
|
LockDoorway(item5.Key, item5.Value, DungeonFlow.KeyManager);
|
|
}
|
|
}
|
|
|
|
protected virtual void LockDoorway(Doorway doorway, Key key, KeyManager keyManager)
|
|
{
|
|
TilePlacementData placement = doorway.Tile.Placement;
|
|
GameObjectChanceTable[] array = (from x in doorway.Tile.Placement.TileSet.LockPrefabs.Where(delegate(LockedDoorwayAssociation x)
|
|
{
|
|
DoorwaySocket socket = x.Socket;
|
|
return socket == null || DoorwaySocket.CanSocketsConnect(socket, doorway.Socket);
|
|
})
|
|
select x.LockPrefabs).ToArray();
|
|
if (array.Length == 0)
|
|
{
|
|
return;
|
|
}
|
|
GameObject gameObject = UnityEngine.Object.Instantiate(array[RandomStream.Next(0, array.Length)].GetRandom(RandomStream, placement.IsOnMainPath, placement.NormalizedDepth, null, allowImmediateRepeats: true).Value, doorway.transform);
|
|
DungeonUtil.AddAndSetupDoorComponent(CurrentDungeon, gameObject, doorway);
|
|
doorway.SetUsedPrefab(gameObject);
|
|
doorway.ConnectedDoorway.SetUsedPrefab(gameObject);
|
|
foreach (IKeyLock item in gameObject.GetComponentsInChildren<Component>().OfType<IKeyLock>())
|
|
{
|
|
item.OnKeyAssigned(key, keyManager);
|
|
}
|
|
}
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
fileVersion = 1;
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (fileVersion < 1)
|
|
{
|
|
RepeatMode = ((!allowImmediateRepeats) ? TileRepeatMode.DisallowImmediate : TileRepeatMode.Allow);
|
|
}
|
|
}
|
|
}
|
|
}
|