public Playing(LevelRep context, State sourceState, ILevelManager runningLevel) : base(context) { this.RunningLevel = runningLevel; this.sourceState = sourceState; runningLevel.Ending += RunningLevelEnding; }
/// <summary> /// Returns loader that can load the level into editing mode, where players are just placeholders. /// </summary> /// <param name="levelRep">Presentation of the level for the user.</param> /// <param name="storedLevel">Stored serialized state of the level.</param> /// <param name="parentProgress">Progress watcher for the parent process.</param> /// <param name="loadingSubsectionSize">Size of this loading process as a part of the parent process.</param> /// <returns>Loader that can load the level into editing mode.</returns> public static ILevelLoader GetLoaderForEditing(LevelRep levelRep, StLevel storedLevel, IProgressEventWatcher parentProgress = null, double loadingSubsectionSize = 100) { return(new SavedLevelEditorLoader(levelRep, storedLevel, parentProgress, loadingSubsectionSize)); }
async void SaveAsButtonReleased(ReleasedEventArgs args) { if (Level.LevelRep.GamePack.TryGetLevel(name, out LevelRep oldLevel)) { bool confirm = await MenuUIManager.ConfirmationPopUp.RequestConfirmation("Override level", "Do you want to override existing level with the same name?", null, proxy); if (!confirm) { return; } } LevelRep newLevelRep = null; try { newLevelRep = Level.LevelRep.CreateClone(name, description, ThumbnailPath); newLevelRep.SaveToGamePack(true); MenuUIManager.SwitchBack(); } catch (Exception) { newLevelRep?.Dispose(); await MenuUIManager.ErrorPopUp.DisplayError("Package Error", "There was an error while saving the level to package, see log for details.", proxy); } }
/// <summary> /// Returns loader that can generate new level based on provided data. /// </summary> /// <param name="levelRep">Presentation of the level for the user.</param> /// <param name="mapSize">Size of the map to generate.</param> /// <param name="parentProgress">Progress watcher for the parent process.</param> /// <param name="loadingSubsectionSize">Size of this loading process as a part of the parent process.</param> /// <returns>Loader that can generate new level.</returns> public static ILevelLoader GetLoaderForDefaultLevel(LevelRep levelRep, IntVector2 mapSize, IProgressEventWatcher parentProgress = null, double loadingSubsectionSize = 100) { return(new DefaultLevelLoader(levelRep, mapSize, parentProgress, loadingSubsectionSize)); }
public LevelPickingLevelItem(LevelRep level, MHUrhoApp game) : base(game, "UI/LevelItemStyle.xml", true) { this.Level = level; XmlFile styleFile = game.PackageManager.GetXmlFile("UI/LevelItemStyle.xml", true); UIElement fixedElementContents = game.UI.LoadLayout(game.PackageManager.GetXmlFile("UI/LevelItemFixedLayout.xml", true), styleFile); FixedElement.AddChild(fixedElementContents); UIElement expandingElementContents = game.UI.LoadLayout(game.PackageManager.GetXmlFile("UI/LevelItemExpandingLayout.xml", true), styleFile); ExpandingElement.AddChild(expandingElementContents); var thumbnailElement = (BorderImage)fixedElementContents.GetChild("Thumbnail", true); thumbnailElement.Texture = level.Thumbnail; thumbnailElement.ImageRect = new IntRect(0, 0, level.Thumbnail.Width, level.Thumbnail.Height); var nameElement = (Text)CheckBox.GetChild("NameText", true); nameElement.Value = level.Name; ((Text)ExpandingElement.GetChild("DescriptionText", true)).Value = level.Description; }
//1 for finishloading /// <summary> /// Creates loader to generate the level represented by <paramref name="levelRep"/>. /// </summary> /// <param name="levelRep">Presentation part of the level.</param> /// <param name="mapSize">Size of the map to generate the level with.</param> /// <param name="parentProgress">Progress watcher for the parent process.</param> /// <param name="loadingSubsectionSize">Size of this loading process as a part of the parent process.</param> public DefaultLevelLoader(LevelRep levelRep, IntVector2 mapSize, IProgressEventWatcher parentProgress = null, double loadingSubsectionSize = 100) : base(levelRep, true, parentProgress, loadingSubsectionSize) { this.mapSize = mapSize; if (LevelRep.MaxNumberOfPlayers < 1) { throw new ArgumentException("Level without players does not make sense", nameof(levelRep)); } if (mapSize.X < WorldMap.Map.MinSize.X || WorldMap.Map.MaxSize.X < mapSize.X || mapSize.Y < WorldMap.Map.MinSize.Y || WorldMap.Map.MaxSize.Y < mapSize.Y) { throw new ArgumentOutOfRangeException(nameof(mapSize), mapSize, "MapSize was out of bounds set by Map.MinSize and Map.MaxSize"); } if (mapSize.X % WorldMap.Map.ChunkSize.X != 0 || mapSize.Y % WorldMap.Map.ChunkSize.Y != 0) { throw new ArgumentException("MapSize has to be an integer multiple of Map.ChunkSize", nameof(mapSize)); } }
public ILevelLoader GetLevelLoaderForPlaying(LevelRep level, PlayerSpecification players, LevelLogicCustomSettings customSettings, IProgressEventWatcher parentProgress = null, double subsectionSize = 100) { throw new NotImplementedException(); }
void DescriptionChanged(TextChangedEventArgs args) { if (!LevelRep.IsDescriptionValid(args.Text)) { descriptionEdit.Text = description; } description = descriptionEdit.Text; }
void NameChanged(TextChangedEventArgs args) { if (!LevelRep.IsNameValid(args.Text)) { nameEdit.Text = name; } name = nameEdit.Text; }
/// <summary> /// Creates loader to load the level represented by <paramref name="levelRep"/> into the mode specified by <paramref name="editorMode"/>. /// Can be added as part of bigger process with <paramref name="parentProgress"/> and <paramref name="loadingSubsectionSize"/>. /// </summary> /// <param name="levelRep">The rep of the level to load.</param> /// <param name="editorMode">If the level should be loaded into editor mode or playing mode.</param> /// <param name="parentProgress">Progress watcher for the parent process.</param> /// <param name="loadingSubsectionSize">Size of this loading process as a part of the parent process.</param> protected BaseLoader(LevelRep levelRep, bool editorMode, IProgressEventWatcher parentProgress, double loadingSubsectionSize) { this.LevelRep = levelRep; this.EditorMode = editorMode; this.Progress = new ProgressWatcher(parentProgress, loadingSubsectionSize); this.Progress.Finished += LoadingFinished; this.Progress.Failed += LoadingFailed; }
/// <summary> /// Returns loader that can load the level into playing mode. /// </summary> /// <param name="levelRep">Presentation of the level for the user.</param> /// <param name="storedLevel">Stored serialized state of the level.</param> /// <param name="players">Data to initialize the players.</param> /// <param name="customSettings">Data to initialize the level logic instance plugin.</param> /// <param name="parentProgress">Progress watcher for the parent process.</param> /// <param name="loadingSubsectionSize">Size of this loading process as a part of the parent process.</param> /// <returns>Loader that can load the level into playing mode.</returns> public static ILevelLoader GetLoaderForPlaying(LevelRep levelRep, StLevel storedLevel, PlayerSpecification players, LevelLogicCustomSettings customSettings, IProgressEventWatcher parentProgress = null, double loadingSubsectionSize = 100) { return(new SavedLevelPlayingLoader(levelRep, storedLevel, players, customSettings, parentProgress, loadingSubsectionSize)); }
/// <summary> /// If there is a paused running level, ends it and then creates a loader for loading <paramref name="level"/> /// for editing. /// Can send loading updates if given <paramref name="parentProgress"/>. /// Scales the percentage updates by <paramref name="subsectionSize"/>, to enable us and the parent to go from 0 to 100. /// </summary> /// <param name="level">The level to create the loader for.</param> /// <param name="parentProgress">The progress watcher for the parent.</param> /// <param name="subsectionSize">The precentage size of the level loading in the whole loading process.</param> /// <returns>A loader for the <paramref name="level"/> that can be used to load the <paramref name="level"/> for editing.</returns> public ILevelLoader GetLevelLoaderForEditing(LevelRep level, IProgressEventWatcher parentProgress = null, double subsectionSize = 100) { if (pausedLevelController != null) { EndPausedLevel(); } return(level.GetLoaderForEditing(parentProgress, subsectionSize)); }
/// <summary> /// If there is a paused running level, ends it and then creates a loader for loading <paramref name="level"/> /// for playing. /// Initializes players based on <paramref name="players"/>. /// Initializes level logic based on <paramref name="customSettings"/>. /// Can send loading updates if given <paramref name="parentProgress"/>. /// Scales the percentage updates by <paramref name="subsectionSize"/>, to enable us and the parent to go from 0 to 100. /// </summary> /// <param name="level">The level to create the loader for.</param> /// <param name="players">Data to use for player initialization.</param> /// <param name="customSettings">Settings to use for level logic plugin initialization.</param> /// <param name="parentProgress">The progress watcher for the parent.</param> /// <param name="subsectionSize">The precentage size of the level loading in the whole loading process.</param> /// <returns>A loader for the <paramref name="level"/> that can be used to load the <paramref name="level"/> for editing.</returns> public ILevelLoader GetLevelLoaderForPlaying(LevelRep level, PlayerSpecification players, LevelLogicCustomSettings customSettings, IProgressEventWatcher parentProgress = null, double subsectionSize = 100) { if (pausedLevelController != null) { EndPausedLevel(); } return(level.GetLoaderForPlaying(players, customSettings, parentProgress, subsectionSize)); }
/// <summary> /// Creates a loader that loads saved level into a playing mode. /// </summary> /// <param name="levelRep">Presentation part of the level.</param> /// <param name="storedLevel">Saved level.</param> /// <param name="players">Data for player initialization.</param> /// <param name="customSettings">Data for level logic initialization.</param> /// <param name="parentProgress">Progress watcher for the parent process.</param> /// <param name="loadingSubsectionSize">Size of this loading process as a part of the parent process.</param> public SavedLevelPlayingLoader(LevelRep levelRep, StLevel storedLevel, PlayerSpecification players, LevelLogicCustomSettings customSettings, IProgressEventWatcher parentProgress = null, double loadingSubsectionSize = 100) : base(levelRep, storedLevel, false, parentProgress, loadingSubsectionSize) { this.players = players; this.customSettings = customSettings; if ((players == PlayerSpecification.LoadFromSavedGame) != (customSettings == LevelLogicCustomSettings.LoadFromSavedGame)) { throw new ArgumentException("Argument mismatch, one argument is loaded from save and the other is not"); } }
/// <summary> /// Creates level manager that controls a level presented by <paramref name="levelRep"/> to the user, /// represented by <paramref name="levelNode"/> in the game engine. /// </summary> /// <param name="levelNode">The <see cref="Node"/> representing the level in the game engine.</param> /// <param name="levelRep">Presentation of the level for the user.</param> /// <param name="app">Current running application.</param> /// <param name="octree">Engine component used for raycasting.</param> /// <param name="editorMode">If the level is in editor mode or playig mode.</param> protected LevelManager(Node levelNode, LevelRep levelRep, MHUrhoApp app, Octree octree, bool editorMode) { this.LevelNode = levelNode; this.LevelRep = levelRep; this.EditorMode = editorMode; //Plugin is set in the loader after the creation of LevelManager //this.Plugin = plugin; this.units = new Dictionary <int, IUnit>(); this.players = new Dictionary <int, IPlayer>(); this.buildings = new Dictionary <int, IBuilding>(); this.projectiles = new Dictionary <int, IProjectile>(); this.entities = new Dictionary <int, IEntity>(); this.rangeTargets = new Dictionary <int, IRangeTarget>(); this.nodeToEntity = new Dictionary <Node, IEntity>(); this.rng = new Random(); this.App = app; this.octree = octree; this.DefaultComponentFactory = new DefaultComponentFactory(); this.IsEnding = false; ReceiveSceneUpdates = true; }
public override State CloneToNewContext(LevelRep newContext) { throw new InvalidOperationException("Cannot clone freshly created level, load it, save it, then clone it"); }
public ILevelLoader GetLevelLoaderForEditing(LevelRep level, IProgressEventWatcher parentProgress = null, double subsectionSize = 100) { throw new NotImplementedException(); }
/// <inheritdoc /> public void ChangeRep(LevelRep newLevelRep) { LevelRep.DetachFromLevel(); LevelRep = newLevelRep; }
public Prototype(LevelRep context) : base(context) { }
public Editing(LevelRep context, ILevelManager runningLevel) : base(context) { this.RunningLevel = runningLevel; runningLevel.Ending += RunningLevelEnding; }
public override State CloneToNewContext(LevelRep newContext) { return(new ClonedEditing(newContext, RunningLevel)); }
public override State CloneToNewContext(LevelRep newContext) { return(new ClonedPrototype(newContext, sourceState)); }
public LevelCreationScreen SwitchToLevelCreationScreen(LevelRep level) { LevelCreationScreen.Level = level; SwitchToScreen(LevelCreationScreen); return(LevelCreationScreen); }
public LevelSettingsScreen SwitchToLevelSettingsScreen(LevelRep level) { LevelSettingsScreen.Level = level; SwitchToScreen(LevelSettingsScreen); return(LevelSettingsScreen); }
public NewlyCreated(IntVector2 mapSize, LevelRep context) : base(context) { this.mapSize = mapSize; }
public override State CloneToNewContext(LevelRep newContext) { throw new InvalidOperationException("Cannot clone loaded saved level"); }
public LoadedSaved(LevelRep context, string savedLevelPath, StLevel savedLevel) : base(context) { this.savedLevelPath = savedLevelPath; this.savedLevel = savedLevel; }
public override State CloneToNewContext(LevelRep newContext) { throw new InvalidOperationException("Cannot clone level in play mode"); }
public ClonedEditing(LevelRep context, ILevelManager runningLevel) : base(context, runningLevel) { }
public ClonedPrototype(LevelRep context, Prototype sourceState) : base(context) { this.sourceState = sourceState; }