public bool TrySelectEnvironment(int index)
{
if (CurrentEnvironment == index)
{
return(true);
}
if (index < -1 || index > environmentsInBuild.Length - 1)
{
return(false);
}
// Unload the previous environment.
if (CurrentEnvironment != -1)
{
SceneManager.UnloadSceneAsync(environmentsInBuild[CurrentEnvironment]);
}
// Load the environment.
CurrentEnvironment = index;
if (CurrentEnvironment >= 0)
{
SceneManager.LoadSceneAsync(environmentsInBuild[CurrentEnvironment], LoadSceneMode.Additive);
}
EnvironmentChanged?.Invoke(CurrentEnvironment);
return(true);
}
/// <summary>
/// Sets the the current environment ID name.
/// </summary>
/// <param name="currentEnvironment">Current Environment object containing the current environment name and ID</param>
public void SetCurrentEnvironment(JObject currentEnvironment)
{
m_DataStore.currentEnvironment = currentEnvironment["name"].Value <string>();
m_DataStore.currentEnvironmentId = currentEnvironment["id"].Value <string>();
m_DataStore.currentEnvironmentIsDefault = false;
if (currentEnvironment["isDefault"] != null)
{
m_DataStore.currentEnvironmentIsDefault = currentEnvironment["isDefault"].Value <bool>();
}
EnvironmentChanged?.Invoke();
}
/// <summary>
/// Stops the <paramref name="environment"/> if it is the currently playing environment.
/// </summary>
public void StopEnvironment(PlaybackEnvironment environment, bool transition = true)
{
if (this.currentEnvironment != environment)
{
return;
}
PlaybackEnvironment previous;
this.lck.Wait();
try {
if (this.currentEnvironment != environment)
{
return;
}
previous = Interlocked.Exchange(ref this.currentEnvironment, null);
var originalPrevious = Interlocked.Exchange(ref this.previousEnvironment, previous);
originalPrevious?.Stop();
} finally {
this.lck.Release();
}
if (previous == null)
{
return;
}
if (transition)
{
previous.FadeOutAsync(TransitionTime);
}
else
{
previous.Stop();
}
EnvironmentChanged?.Invoke(this, new PlaybackEnvironmentChangedEventArgs(previous, null));
}
public void PlayEnvironment(PlaybackEnvironment environment, bool transition = true)
{
if (environment is null)
{
throw new ArgumentNullException(nameof(environment));
}
PlaybackEnvironment previous;
this.lck.Wait();
try {
previous = Interlocked.Exchange(ref this.currentEnvironment, environment);
if (previous != null)
{
var originalPrevious = Interlocked.Exchange(ref this.previousEnvironment, previous);
originalPrevious?.Stop();
if (transition)
{
previous.TransitionToAsync(environment, TransitionTime);
}
else
{
previous.Stop();
}
}
else if (transition)
{
environment.FadeInAsync(TransitionTime);
}
} finally {
this.lck.Release();
}
EnvironmentChanged?.Invoke(this, new PlaybackEnvironmentChangedEventArgs(previous, environment));
}
public static void HandleAction(EditorAction action, bool redo)
{
if (redo)
{
switch (action.type)
{
case EditorAction.ActionType.EnvironmentChanged:
// set map environment settings to new settings
EnvironmentChanged ec = action as EnvironmentChanged;
EditorMain.instance.LoadedMap.AmbientColor = ec.newAmbientColor;
EditorMain.instance.LoadedMap.BaseplateColor = ec.newBaseplateColor;
EditorMain.instance.LoadedMap.SkyColor = ec.newSkyColor;
EditorMain.instance.LoadedMap.BaseplateSize = ec.newBaseplateSize;
EditorMain.instance.LoadedMap.SunIntensity = ec.newSunIntensity;
MapBuilder.instance.UpdateEnvironment(EditorMain.instance.LoadedMap);
break;
case EditorAction.ActionType.ElementsAdded:
// add elements
ElementsAdded ea = action as ElementsAdded;
if (ea.bricksAdded != null)
{
for (int i = 0; i < ea.bricksAdded.Length; i++)
{
EditorUI.instance.ImportBrick(ea.bricksAdded[i].ToBrick(false));
}
}
if (ea.groupsAdded != null)
{
for (int i = 0; i < ea.groupsAdded.Length; i++)
{
EditorUI.instance.ImportGroup(ea.groupsAdded[i].ToGroup(false));
}
}
break;
case EditorAction.ActionType.ElementsChanged:
// set element settings to new settings
ElementsChanged elc = action as ElementsChanged;
for (int i = 0; i < elc.oldBricks.Length; i++)
{
EditorMain.instance.SetBrickProperties(elc.newBricks[i], elc.oldBricks[i].ID);
EditorUI.instance.UpdateElement(elc.oldBricks[i].ID);
}
EditorUI.instance.UpdateInspector();
break;
case EditorAction.ActionType.ElementsRemoved:
// remove elements
ElementsRemoved er = action as ElementsRemoved;
if (er.bricksRemoved != null)
{
for (int i = 0; i < er.bricksRemoved.Length; i++)
{
EditorUI.instance.DeleteElement(er.bricksRemoved[i].ID);
}
}
if (er.groupsRemoved != null)
{
for (int i = 0; i < er.groupsRemoved.Length; i++)
{
EditorUI.instance.DeleteElement(er.groupsRemoved[i].ID);
}
}
break;
case EditorAction.ActionType.GenericMapChange:
// load new saved map
break;
}
}
else
{
switch (action.type)
{
case EditorAction.ActionType.EnvironmentChanged:
// revert map environment settings to old settings
EnvironmentChanged ec = action as EnvironmentChanged;
EditorMain.instance.LoadedMap.AmbientColor = ec.oldAmbientColor;
EditorMain.instance.LoadedMap.BaseplateColor = ec.oldBaseplateColor;
EditorMain.instance.LoadedMap.SkyColor = ec.oldSkyColor;
EditorMain.instance.LoadedMap.BaseplateSize = ec.oldBaseplateSize;
EditorMain.instance.LoadedMap.SunIntensity = ec.oldSunIntensity;
MapBuilder.instance.UpdateEnvironment(EditorMain.instance.LoadedMap);
break;
case EditorAction.ActionType.ElementsAdded:
// remove added elements
ElementsAdded ea = action as ElementsAdded;
if (ea.bricksAdded != null)
{
for (int i = 0; i < ea.bricksAdded.Length; i++)
{
EditorUI.instance.DeleteElement(ea.bricksAdded[i].ID);
}
}
if (ea.groupsAdded != null)
{
for (int i = 0; i < ea.groupsAdded.Length; i++)
{
EditorUI.instance.DeleteElement(ea.groupsAdded[i].ID);
}
}
break;
case EditorAction.ActionType.ElementsChanged:
// revert element settings to old settings
ElementsChanged elc = action as ElementsChanged;
for (int i = 0; i < elc.newBricks.Length; i++)
{
EditorMain.instance.SetBrickProperties(elc.oldBricks[i], elc.newBricks[i].ID);
EditorUI.instance.UpdateElement(elc.newBricks[i].ID);
}
EditorUI.instance.UpdateInspector();
break;
case EditorAction.ActionType.ElementsRemoved:
// add removed elements
ElementsRemoved er = action as ElementsRemoved;
if (er.bricksRemoved != null)
{
for (int i = 0; i < er.bricksRemoved.Length; i++)
{
EditorUI.instance.ImportBrick(er.bricksRemoved[i].ToBrick(false));
}
}
if (er.groupsRemoved != null)
{
for (int i = 0; i < er.groupsRemoved.Length; i++)
{
EditorUI.instance.ImportGroup(er.groupsRemoved[i].ToGroup(false));
}
}
break;
case EditorAction.ActionType.GenericMapChange:
// load old saved map
GenericMapChange gmc = action as GenericMapChange;
break;
}
}
}
/// <summary>
/// Event handler for the <see cref="EnvironmentChanged"/> event.
/// </summary>
/// <param name="sender">The object that sends the request. Unused.</param>
/// <param name="args">Information about the environment that has changed.</param>
protected virtual void OnEnvironmentChanged(object sender, EnvironmentChangedEventArgs args)
{
EnvironmentChanged?.Invoke(this, args);
}
/// <summary>
/// Sets the the current environment ID name.
/// </summary>
/// <param name="currentEnvironment">Current Environment object containing the current environment name and ID</param>
public void SetCurrentEnvironment(Environment currentEnvironment)
{
m_DataStore.currentEnvironmentId = currentEnvironment.id;
EnvironmentChanged?.Invoke();
}
