/// <summary>
/// Adds a new screen to the manager
/// </summary>
public static void AddScreen(ScreenLayer screen)
{
_screens.Add(screen);
if (_initialized)
{
screen.LoadContent();
}
}
public void Restart(ScreenLayer initialLayer = null, string message = null)
{
initializeOverlay();
ScreenLayerManager.Set(initialLayer ?? new StartMenu());
if (message != null)
{
ScreenLayerManager.ShowMessage(message);
}
}
/// <summary>
/// Removes a screen from the manager
/// </summary>
/// <param name="screen"></param>
public static void RemoveScreen(ScreenLayer screen)
{
if (screen != null)
{
screen.UnloadContent();
}
_screens.Remove(screen);
_updateScreens.Remove(screen);
}
private static void PrefixFinalize(ScreenBase __instance, ScreenLayer layer)
{
if (__instance is GauntletPartyScreen && screenLayer != null)
{
GauntletPartyScreen obj = (GauntletPartyScreen)__instance;
GauntletLayer layer2 = screenLayer;
screenLayer = null;
obj.RemoveLayer(layer2);
}
}
public void RenderLayer(ScreenLayer layer)
{
layer.Draw();
surfaces.ViewMatrix.Matrix = layer.ViewMatrix;
surfaces.ProjectionMatrix.Matrix = layer.ProjectionMatrix;
surfaces.ConsoleBackground.Render();
surfaces.ConsoleFontSurface.Render();
}
public static void Prefix(ref ScreenBase __instance, ref ScreenLayer layer)
{
if (__instance is GauntletPartyScreen && screenLayer != null && layer.Input.IsCategoryRegistered(HotKeyManager.GetCategory("PartyHotKeyCategory")))
{
__instance.RemoveLayer(screenLayer);
enhancementVm.OnFinalize();
enhancementVm = null;
screenLayer = null;
}
}
// *** Push ***
// Push a new layer onto the list
public void Push(ScreenLayer layer)
{
gameHasStarted = true;
layers.Add(layer);
// If the added layer is not transparent, it must be the first layer drawn
if (lowestVisibleLayer == -1 || !layer.isTransparent)
{
lowestVisibleLayer = layers.Count - 1;
}
}
public void DestroyScreen(ScreenLayer layerName)
{
for (int i = 0; i < inGameActiveScreens.Count; i++)
{
if (inGameActiveScreens[i].screenLayer == layerName)
{
Destroy(inGameActiveScreens[i].screenObject);
inGameActiveScreens.RemoveAt(i);
}
}
}
private static void PostfixActivate(ScreenBase __instance, ScreenLayer layer)
{
if (__instance is GauntletPartyScreen && screenLayer == null)
{
GauntletPartyScreen obj = (GauntletPartyScreen)__instance;
PartyVM value = Traverse.Create(obj).Field <PartyVM>("_dataSource").Value;
screenLayer = new GauntletLayer(99);
screenLayer.LoadMovie("AutoPartyManager", new AutoPartyManagerVM(value));
screenLayer.InputRestrictions.SetInputRestrictions();
obj.AddLayer(screenLayer);
}
}
public void RenderLayer(ScreenLayer layer)
{
layer.Draw();
_surfaces.ViewMatrix.Matrix = layer.ViewMatrix;
_surfaces.ProjectionMatrix.Matrix = layer.ProjectionMatrix;
_surfaces.FreshmanFontSurface.Render();
_surfaces.ConsolasFontSurface.Render();
_surfaces.SpriteSurface.Render();
_surfaces.PhotonSurface.Render();
}
public static void Prefix(ref ScreenBase __instance, ref ScreenLayer layer)
{
bool flag = __instance is GauntletClanScreen && ClanScreenLayerPatch.screenLayer != null && layer.Input.IsCategoryRegistered(HotKeyManager.GetCategory("GenericCampaignPanelsGameKeyCategory"));
if (flag)
{
__instance.RemoveLayer(ClanScreenLayerPatch.screenLayer);
ClanScreenLayerPatch.spouseClanView.OnFinalize();
ClanScreenLayerPatch.spouseClanView = null;
ClanScreenLayerPatch.screenLayer = null;
}
}
public static void Prefix(ref ScreenBase __instance, ref ScreenLayer layer)
{
bool flag = __instance is GauntletKingdomScreen && KindomScreenLayerPatch.screenLayer != null && layer.Input.IsCategoryRegistered(HotKeyManager.GetCategory("GenericCampaignPanelsGameKeyCategory"));
if (flag)
{
__instance.RemoveLayer(KindomScreenLayerPatch.screenLayer);
KindomScreenLayerPatch.kindomScreenVM.OnFinalize();
KindomScreenLayerPatch.kindomScreenVM = null;
KindomScreenLayerPatch.screenLayer = null;
}
}
private void ConstructLayers()
{
foreach (MDScreenLayer ScreenLayer in (MDScreenLayer[])Enum.GetValues(typeof(MDScreenLayer)))
{
MDLayerStack LayerStack = new MDLayerStack
{
Name = ScreenLayer.ToString() + "Layer",
LayerType = ScreenLayer
};
LayerMap.Add(ScreenLayer, LayerStack);
AddChild(LayerStack);
}
}
public void Initialize(ScreenLayer initialLayer = null)
{
ResourceContainer = new AssemblyResourceContainer(Assembly.GetEntryAssembly(), $"{nameof(StorybrewEditor)}.Resources", "resources");
DrawState.Initialize(ResourceContainer, Window.Width, Window.Height);
drawContext = new DrawContext();
drawContext.Register(this, false);
drawContext.Register <TextureContainer>(new TextureContainerAtlas(ResourceContainer), true);
drawContext.Register <QuadRenderer>(new QuadRendererBuffered(), true);
drawContext.Register <LineRenderer>(new LineRendererBuffered(), true);
try
{
var brewLibAssembly = Assembly.GetAssembly(typeof(Drawable));
Skin = new Skin(drawContext.Get <TextureContainer>())
{
ResolveDrawableType = (drawableTypeName) =>
brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(BrewLib.Graphics)}.{nameof(BrewLib.Graphics.Drawables)}.{drawableTypeName}", true, true),
ResolveWidgetType = (widgetTypeName) =>
Type.GetType($"{nameof(StorybrewEditor)}.{nameof(UserInterface)}.{widgetTypeName}", false, true) ??
brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(UserInterface)}.{widgetTypeName}", true, true),
ResolveStyleType = (styleTypeName) =>
Type.GetType($"{nameof(StorybrewEditor)}.{nameof(UserInterface)}.{nameof(UserInterface.Skinning)}.{nameof(UserInterface.Skinning.Styles)}.{styleTypeName}", false, true) ??
brewLibAssembly.GetType($"{nameof(BrewLib)}.{nameof(UserInterface)}.{nameof(UserInterface.Skinning)}.{nameof(UserInterface.Skinning.Styles)}.{styleTypeName}", true, true),
};
Skin.Load("skin.json", ResourceContainer);
}
catch (Exception e)
{
Trace.WriteLine($"Failed to load skin: {e}");
Skin = new Skin(drawContext.Get <TextureContainer>());
}
var inputDispatcher = new InputDispatcher();
InputManager = new InputManager(Window, inputDispatcher);
ScreenLayerManager = new ScreenLayerManager(Window, clock, this);
inputDispatcher.Add(createOverlay(ScreenLayerManager));
inputDispatcher.Add(ScreenLayerManager.InputHandler);
Restart(initialLayer);
Window.Resize += window_Resize;
Window.Closing += window_Closing;
resizeToWindow();
}
// *** Pop ***
// Remove and return the topmost layer
public ScreenLayer Pop()
{
ScreenLayer sl = layers[layers.Count - 1];
layers.RemoveAt(layers.Count - 1);
// Recalculate lowestVisibleLayer
lowestVisibleLayer = -1;
for (int i = layers.Count - 1; i >= 0; i--)
{
if (!layers[i].isTransparent)
{
lowestVisibleLayer = i;
break;
}
}
if (layers.Count > 0)
{
layers[layers.Count - 1].state = ScreenState.Active;
}
return(sl);
}
/// <summary>
/// Allows each screen to run logic
/// </summary>
/// <param name="gameTime"></param>
public override void Update(GameTime gameTime)
{
//Lets make a copy of the master list
_updateScreens.Clear();
foreach (ScreenLayer screen in _screens)
{
_updateScreens.Add(screen);
}
bool hasFocus = !Game.IsActive;
bool covered = false;
while (_updateScreens.Count > 0)
{
ScreenLayer screen = _updateScreens[_updateScreens.Count - 1];
_updateScreens.RemoveAt(_updateScreens.Count - 1);
// Update the screen.
screen.Update(gameTime, hasFocus, covered);
if (screen.ScreenState == ScreenState.On ||
screen.ScreenState == ScreenState.Active)
{
if (!hasFocus)
{
screen.HandleInput(GameManager.Input);
hasFocus = true;
}
if (!screen.IsPopup)
{
covered = true;
}
}
}
}
public void RenderLayer(ScreenLayer layer)
{
prepareForRendering(layer);
renderWithOptions(layer.RenderOptions);
}
private void setMatricesFrom(ScreenLayer layer)
{
surfaces.ViewMatrix.Matrix = layer.ViewMatrix;
surfaces.ProjectionMatrix.Matrix = layer.ProjectionMatrix;
}
private void prepareForRendering(ScreenLayer layer)
{
layer.Draw();
setMatricesFrom(layer);
}
