private void OnSequenceEntered(SegmentSequence sequence)
{
if (sequence.customPathGenerator != null)
{
LevelPathGenerator lastGenerator = currentPathGenerator;
if (usePathGeneratorInstance)
{
overridePathGenerator = Instantiate(sequence.customPathGenerator);
}
else
{
overridePathGenerator = sequence.customPathGenerator;
}
overridePathGenerator.Continue(lastGenerator);
}
else if (overridePathGenerator != null)
{
pathGenerator.Continue(overridePathGenerator);
if (usePathGeneratorInstance)
{
Destroy(overridePathGenerator);
}
overridePathGenerator = null;
}
}
IEnumerator ClearRoutine()
{
_ready = false;
if (usePathGeneratorInstance && overridePathGenerator != null)
{
Destroy(overridePathGenerator);
}
overridePathGenerator = null;
while (isLoadingLevel)
{
yield return(null);
}
LevelSegment.ResetGenerationState();
SegmentExtruder.instance.Stop();
for (int i = 0; i < levels.Length; i++)
{
if (levels[i].remoteSequence && levels[i].isReady)
{
yield return(StartCoroutine(UnloadRemoteLevel(levels[i], ThreadPriority.High)));
}
}
for (int i = 0; i < _segments.Count; i++)
{
_segments[i].DestroyImmediate();
}
ResourceManagement.UnloadResources();
_segments.Clear();
enteredLevel = null;
_enteredSegment = -1;
}
public override void OnBeforeGeneration(LevelPathGenerator generator)
{
base.OnBeforeGeneration(generator);
if (!(generator is RandomPathGenerator))
{
return;
}
RandomPathGenerator randomGenerator = (RandomPathGenerator)generator;
if (setYaw)
{
randomGenerator.SetTargetYaw(targetYaw);
}
if (setPitch)
{
randomGenerator.SetTargetPitch(targetPitch);
}
if (setRoll)
{
randomGenerator.SetTargetRoll(targetRoll);
}
if (setYawStep)
{
randomGenerator.SetYawStep(yawStep);
}
if (setPitchStep)
{
randomGenerator.SetPitchStep(pitchStep);
}
if (setRollStep)
{
randomGenerator.SetRollStep(rollStep);
}
}
public override void Continue(LevelPathGenerator previousGenerator)
{
base.Continue(previousGenerator);
currentSegmentIndex = 0;
CreateSpline();
if (useRelativeCoordinates)
{
SetTRS();
}
}
/// <summary>
/// Logic for transfering internal data from the previous generator to the new one
/// when changing path generators on-the-fly at runtime
/// </summary>
/// <param name="previousGenerator"></param>
public virtual void Continue(LevelPathGenerator previousGenerator)
{
level = previousGenerator.level;
segment = previousGenerator.segment;
_isNewLevel = previousGenerator._isNewLevel;
transform = previousGenerator.transform;
lastPoint = previousGenerator.lastPoint;
FloatingOrigin.onOriginOffset -= previousGenerator.OnOriginOffset;
FloatingOrigin.onOriginOffset -= OnOriginOffset;
FloatingOrigin.onOriginOffset += OnOriginOffset;
}
public void StartGeneration()
{
StopAllCoroutines();
if (usePathGeneratorInstance)
{
if (overridePathGenerator != null)
{
Destroy(overridePathGenerator);
}
if (pathGeneratorInstance != null)
{
Destroy(pathGeneratorInstance);
}
pathGeneratorInstance = Instantiate(sharedPathGenerator);
}
overridePathGenerator = null;
if (currentPathGenerator == null)
{
Debug.LogError("Level Generator " + name + " does not have a Path Generator assigned");
return;
}
enteredLevel = null;
_enteredSegment = -1;
segmentIndex = 0;
if (startLevel >= levels.Length)
{
startLevel = levels.Length - 1;
}
switch (levelIteration)
{
case LevelIteration.Ordered: levelChangeHandler = IncrementClamp; break;
case LevelIteration.OrderedClamp: levelChangeHandler = IncrementClamp; break;
case LevelIteration.OrderedLoop: levelChangeHandler = IncrementRepeat; break;
case LevelIteration.Random: levelChangeHandler = RandomLevel; break;
}
levelIndex = startLevel;
while (!levels[levelIndex].enabled)
{
levelIndex++;
if (levelIndex >= levels.Length)
{
break;
}
}
LoadLevel(levels[levelIndex], true);
currentPathGenerator.Initialize(this);
StartCoroutine(StartRoutine());
}
public override void Continue(LevelPathGenerator previousGenerator)
{
base.Continue(previousGenerator);
if (!(previousGenerator is HighLevelPathGenerator))
{
Quaternion lookRot = Quaternion.LookRotation(previousGenerator.lastPoint.tangent2 - previousGenerator.lastPoint.position, previousGenerator.lastPoint.normal);
orientation = lookRot.eulerAngles;
return;
}
HighLevelPathGenerator previousHighLevel = (HighLevelPathGenerator)previousGenerator;
orientation = previousHighLevel.orientation;
roll = previousHighLevel.roll;
lastPointHL = previousHighLevel.lastPointHL;
}
public virtual void OnBeforeGeneration(LevelPathGenerator generator)
{
}
public override void Continue(LevelPathGenerator previousGenerator)
{
base.Continue(previousGenerator);
continueOrientation = orientation;
}
private void OnGUI()
{
if (editor == null)
{
Close();
return;
}
string name = sequence.name;
name = EditorGUILayout.TextField("Name", name);
if (name != sequence.name)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.name = name;
}
if (!sequence.isCustom)
{
SegmentSequence.Type type = sequence.type;
type = (SegmentSequence.Type)EditorGUILayout.EnumPopup("Shuffle Type", type);
if (type != sequence.type)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.type = type;
}
if (type == SegmentSequence.Type.Random)
{
int spawnCount = sequence.spawnCount;
spawnCount = EditorGUILayout.IntField(new GUIContent("Spawn Count", "How many segments should this random sequence spawn? Zero will go on forever."), spawnCount);
if (spawnCount != sequence.spawnCount)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.spawnCount = spawnCount;
}
bool preventRepeat = sequence.preventRepeat;
preventRepeat = EditorGUILayout.Toggle(new GUIContent("Prevent Repeating", "If true, the random algorithm will make sure not to spawn the same segment twice in a row."), preventRepeat);
if (preventRepeat != sequence.preventRepeat)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.preventRepeat = preventRepeat;
}
}
else if (sequence.type == SegmentSequence.Type.Custom)
{
SegmentShuffle customShuffle = sequence.customShuffle;
customShuffle = (SegmentShuffle)EditorGUILayout.ObjectField("Shuffle", customShuffle, typeof(SegmentShuffle), false);
if (customShuffle != sequence.customShuffle)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.customShuffle = customShuffle;
}
}
}
EditorGUILayout.Space();
LevelPathGenerator pathGenerator = sequence.customPathGenerator;
pathGenerator = (LevelPathGenerator)EditorGUILayout.ObjectField("Custom Path Generator", pathGenerator, typeof(LevelPathGenerator), false);
if (pathGenerator != sequence.customPathGenerator)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.customPathGenerator = pathGenerator;
}
EditorGUILayout.Space();
bool isCustom = sequence.isCustom;
isCustom = EditorGUILayout.Toggle("Custom Sequence", isCustom);
if (isCustom != sequence.isCustom)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.isCustom = isCustom;
}
if (isCustom)
{
CustomSequence customSequence = sequence.customSequence;
customSequence = (CustomSequence)EditorGUILayout.ObjectField("Sequence Asset", customSequence, typeof(CustomSequence), false);
if (customSequence != sequence.customSequence)
{
if (onWillChange != null)
{
onWillChange();
}
sequence.customSequence = customSequence;
}
return;
}
}
