public virtual Level GetLevel(Player player, string name)
{
Level level = Levels.FirstOrDefault(l => l.LevelId.Equals(name, StringComparison.InvariantCultureIgnoreCase));
if (level == null)
{
AnvilWorldProvider worldProvider = new AnvilWorldProvider
{
MissingChunkProvider = new FlatLandWorldGenerator(),
ReadSkyLight = !Config.GetProperty("CalculateLights", false),
ReadBlockLight = !Config.GetProperty("CalculateLights", false),
};
level = new Level(this, name, worldProvider, EntityManager, _gameMode, _difficulty, _viewDistance)
{
EnableBlockTicking = _enableBlockTicking,
EnableChunkTicking = _enableChunkTicking,
IsWorldTimeStarted = _isWorldTimeStarted
};
level.Initialize();
Levels.Add(level);
OnLevelCreated(new LevelEventArgs(null, level));
}
return(level);
}
/// <summary>
/// Creates Levels within the supplied Envelope, starting at Envelope.Elevation and proceeding upward at equal intervals until placing the last Level at Envelope.Elevation + Envelope.Height.
/// </summary>
/// <param name="envelope">Envelope that will encompass the new Levels.</param>
/// <param name="interval">Desired vertical distance between Levels.</param>
/// <returns>A List of Levels ordered from lowest Elevation to highest.</returns>
public void MakeLevels(Envelope envelope, double interval, bool first = true, bool last = true)
{
var perimeter = envelope.Profile.Perimeter;
if (perimeter.IsClockWise())
{
perimeter = perimeter.Reversed();
}
if (first)
{
Levels.Add(new Level(envelope.Elevation, Guid.NewGuid(), ""));
LevelPerimeters.Add(new LevelPerimeter(perimeter.Area(), envelope.Elevation, perimeter, Guid.NewGuid(), ""));
}
;
var openHeight = envelope.Height;
var stdHeight = Math.Abs(openHeight / Math.Floor(openHeight / interval) - 1);
var atHeight = envelope.Elevation + stdHeight;
while (openHeight >= stdHeight * 2)
{
Levels.Add(new Level(atHeight, Guid.NewGuid(), ""));
LevelPerimeters.Add(new LevelPerimeter(perimeter.Area(), atHeight, perimeter, Guid.NewGuid(), ""));
openHeight -= stdHeight;
atHeight += stdHeight;
}
if (last)
{
Levels.Add(new Level(envelope.Elevation + envelope.Height, Guid.NewGuid(), ""));
LevelPerimeters.Add(new LevelPerimeter(perimeter.Area(), envelope.Elevation + envelope.Height, perimeter, Guid.NewGuid(), ""));
}
}
public override Level GetLevel(Player player, string name)
{
Level level = Levels.FirstOrDefault(l => l.LevelId.Equals(name, StringComparison.InvariantCultureIgnoreCase));
if (level == null)
{
int viewDistance = Config.GetProperty("ViewDistance", 11);
bool isWorldTimeStarted = Config.GetProperty("IsWorldTimeStarted", false);
string basePath = Config.GetProperty("PCWorldFolder", "World").Trim();
var worldProvider = new AnvilWorldProvider(basePath)
{
MissingChunkProvider = new PlotWorldGenerator(),
ReadSkyLight = !Config.GetProperty("CalculateLights", false),
ReadBlockLight = !Config.GetProperty("CalculateLights", false),
};
level = new Level(this, name, worldProvider, EntityManager, GameMode.Creative, Difficulty.Normal, viewDistance)
{
IsWorldTimeStarted = isWorldTimeStarted
};
level.Initialize();
Levels.Add(level);
OnLevelCreated(new LevelEventArgs(null, level));
}
return(level);
}
void ScrollArea()
{
EditorGUILayout.BeginVertical(GUILayout.Width(250));
if (GUILayout.Button("+", GUILayout.ExpandWidth(true)))
{
lvls.Add(new Level());
}
scrollPosition = GUILayout.BeginScrollView(scrollPosition, GUILayout.ExpandHeight(true));
for (int i = 0; i < lvls.COUNT; i++)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button(i.ToString(), "Box", GUILayout.ExpandWidth(true)))
{
_index = i;
}
EditorGUILayout.EndHorizontal();
}
GUILayout.EndScrollView();
EditorGUILayout.EndVertical();
}
public void LoadLevels()
{
for (int currLevel = 1; currLevel <= LevelsCount; currLevel++)
{
Levels.Add(new Level(currLevel));
}
}
private void addDefaultLevels(Action <LevelVM> onRemove)
{
Levels.Add(new LevelVM(onRemove)
{
Color = Colors.Black,
Name = "DEBUG",
Show = true
});
Levels.Add(new LevelVM(onRemove)
{
Color = Colors.Black,
Name = "INFO",
Show = true
});
Levels.Add(new LevelVM(onRemove)
{
Color = Colors.Black,
Name = "WARN",
Show = true
});
Levels.Add(new LevelVM(onRemove)
{
Color = Colors.DarkRed,
Name = "ERROR",
Show = true
});
}
private void CreateTestLevel()
{
const int xSize = 5;
const int ySize = 6;
const int xObstacleIndex = 2;
const int yObstacleIndex = 2;
var cells = new CellType[xSize, ySize];
for (var x = 0; x < xSize; x++)
{
for (var y = 0; y < ySize; y++)
{
var cellType = y == ySize - 1
? CellType.SpawnPoint
: x == xObstacleIndex && y == yObstacleIndex
? CellType.Obstacle
: CellType.Default;
cells[x, y] = cellType;
}
}
var firstTarget = new Dto.Item(Items.First(), 10);
var targets = new List <Dto.Item> {
firstTarget
};
var limitedMovesLevel = new LevelData(1, cells, LoseConditionType.LimitedMoves, 15, targets);
var limitedTimeLevel = new LevelData(2, cells, LoseConditionType.LimitedTime, 30, targets);
Levels.Add(limitedMovesLevel);
Levels.Add(limitedTimeLevel);
}
/// <summary>
/// Initializes the <see cref="OpenLevel"/> instance, this could include loading the world from a local folder or generating a new world.
/// </summary>
/// <param name="openLevel">The <see cref="OpenLevel"/> instance to register and initialize</param>
public void LoadLevel(OpenLevel openLevel)
{
openLevel.Initialize();
if (Config.GetProperty("CalculateLights", false) && openLevel.WorldProvider is WrappedWorldProvider wawp &&
wawp.WorldProvider is AnvilWorldProvider anvilWorldProvider)
{
anvilWorldProvider.Locked = true;
SkyLightCalculations.Calculate(openLevel);
RecalculateBlockLight(openLevel, anvilWorldProvider);
anvilWorldProvider.Locked = false;
}
if (_levels.TryAdd(openLevel.LevelId, openLevel))
{
Levels.Add(openLevel);
LevelInitEvent initEvent = new LevelInitEvent(openLevel);
Api.EventDispatcher.DispatchEvent(initEvent);
//OnLevelCreated?.Invoke(openLevel);
Log.InfoFormat("Level loaded: {0}", openLevel.LevelId);
}
else
{
Log.Warn($"Failed to add level: {openLevel.LevelId}");
}
}
private void Button_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
// if there is no user signature
if (ink.InkPresenter.StrokeContainer.GetStrokes().Count == 0)
{
border.BorderBrush = new SolidColorBrush(Colors.Red);
}
else
{
// initialize random seed
GameState.R = new System.Random(ink.InkPresenter.StrokeContainer.GetStrokes().Sum(x => x.StrokeDuration.HasValue ? (int)x.StrokeDuration.Value.TotalMilliseconds : 0));
GameState.PlayerId = Guid.NewGuid().ToString();
if (diffEasy.IsChecked.Value)
{
GameState.Difficulty = Difficulty.Easy;
}
if (diffMedium.IsChecked.Value)
{
GameState.Difficulty = Difficulty.Medium;
}
if (diffHard.IsChecked.Value)
{
GameState.Difficulty = Difficulty.Hard;
}
Levels.Add();
var root = Window.Current.Content as Frame;
root.Navigate(typeof(Views.GamePage), null, new DrillInNavigationTransitionInfo());
SavePlayerSignature();
}
}
public Level GenerateNextLevel()
{
var random = new Random();
var level = new Level();
var levelid = CurrentLevel == null ? 1 : CurrentLevel.Id + 1;
level.Name = "Level " + levelid;
level.Id = levelid;
var amountOfSpawners = level.Id / 2 + 1;
for (int i = 0; i < amountOfSpawners; i++)
{
var amountOfEnemies = random.Next(5, 15) * level.Id * random.Next(1, 4);
var spawner = SpawnerFactory.Instance.CreateSpawnerWIthRandomPositionAndRandomEnemies(amountOfEnemies);
spawner.SpawnRate = 2000 - random.Next(10, 80);
level.AddSpawner(spawner);
}
level.Initialize();
Levels.Add(level);
return(level);
}
public void AddLevel()
{
var nextDescriptor = m_descriptorGenerator.GetNextLevel();
MaxLevel = nextDescriptor.Index;
Levels.Add(nextDescriptor);
}
public void CreateNewLevel()
{
Levels.Add(new Level(GenerateUniqueLevelName())
{
Settings = this.Settings.Copy()
});
}
public BackgroundTile(Image image, string name)
{
var dirToStore = Path.Combine(SettingsBase.ConfigDir, "mapmakertilecache");
Directory.CreateDirectory(dirToStore);
//Error checking
if (image.Width != image.Height)
{
throw new Exception("Background tiles must have an identical width and height");
}
//Generate LOD
foreach (var levelDecl in TileLODLevels)
{
var img = new Bitmap(levelDecl.SizePx, levelDecl.SizePx);
var gd = Graphics.FromImage(img);
gd.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceOver;
gd.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
gd.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
gd.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
gd.DrawImage(image, 0, 0, levelDecl.SizePx, levelDecl.SizePx);
img.Save(
Path.Combine(dirToStore, $"tile_{name}_{levelDecl.SizePx}px.png"),
System.Drawing.Imaging.ImageFormat.Png);
Levels.Add(levelDecl.SizePx, new LODLevel
{
Image = img,
TempFileName = Path.Combine(dirToStore, $"tile_{name}_{levelDecl.SizePx}px.png")
});
gd.Dispose();
}
}
private void LoadFromObjectStore(IObjectStore data)
{
Name = data.GetString("name");
ShortLog.Debug("Loading Class: " + Name);
SkillPoints = data.GetInteger("skillpoints");
HitDice = DiceStrings.ParseSides(data.GetString("hitdice"));
BaseAttackBonusRate = data.GetFloat("baseattackbonus");
FortitudeSaveRate = data.GetFloat("fortitude");
ReflexSaveRate = data.GetFloat("reflex");
WillSaveRate = data.GetFloat("will");
ClassDevelopmentAge = data.GetEnum <ClassDevelopmentAge>("developedage");
CustomBuildStep = data.GetStringOptional("custom-build-step");
//Load Levels
var levels = data.GetObjectListOptional("levels");
if (levels != null)
{
foreach (var l in levels)
{
var level = new Level(l);
Levels.Add(level);
}
}
var dice = data.GetStringOptional("startingwealth");
if (dice != null)
{
StartingWealthDice = DiceStrings.ParseDice(dice);
}
this.HitDicePerLevel = new DiceClassLevelModifier(new Cup(new Die(HitDice)), StatNames.HitDice, this.Name, 1);
}
private void InitialLevels()
{
var verticesLeft = new HashSet <TVertex>(VisitedGraph.Vertices);
// Initial 0th level
Levels.Add(new HashSet <TVertex>(VisitedGraph.Vertices.Where(v => _compoundGraph.GetParent(v) == default(TVertex))));
verticesLeft.RemoveAll(Levels[0]);
// Other layers
for (int i = 1; verticesLeft.Count > 0; ++i)
{
var nextLevel = new HashSet <TVertex>();
foreach (TVertex parent in Levels[i - 1])
{
if (_compoundGraph.GetChildrenCount(parent) <= 0)
{
continue;
}
foreach (TVertex children in _compoundGraph.GetChildrenVertices(parent))
{
nextLevel.Add(children);
}
}
Levels.Add(nextLevel);
verticesLeft.RemoveAll(nextLevel);
}
}
public void AddLevel(Level level)
{
if (level == null)
{
return;
}
Levels.Add(level);
}
internal void AddLevel(RadzenTreeLevel level)
{
if (!Levels.Contains(level))
{
Levels.Add(level);
StateHasChanged();
}
}
void GetLevels()
{
Levels.Clear();
for (int i = 0; i <= MaxLevel; i++)
{
Levels.Add(m_descriptorGenerator.GetNextLevel());
}
}
public void AddLevel(ILevel level)
{
if (!LevelAlreadyExists(level))
{
level.ordinalNumber = Levels.Count;
Levels.Add(level);
}
}
public void Update(IEnumerable <LevelDto> collection)
{
Levels.Clear();
foreach (var model in collection)
{
Levels.Add(model);
}
}
public Level AddLevel()
{
var level = new Level(this);
Levels.Add(level);
return(level);
}
public void FillLevels()
{
Levels.Add(new Level {
Id = 1, Name = "Beginner - 1000 words"
});
Levels.Add(new Level {
Id = 2, Name = "Intermediate - 5000 words"
});
}
public void LoadLevel(int levelNumber)
{
var level = LocalStorage.LoadLevel(levelNumber);
if (level != null)
{
Levels.Add(level);
}
}
/// <summary>
/// Loads a scene using a url
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public async Task <Level> LoadLevel(string url)
{
var scene = await LoadScene(url).ConfigureAwait(false);
var level = new Level(scene);
Levels.Add(level.Scene, level);
return(level);
}
/// <summary>
/// Adds the level to the level list.
/// </summary>
/// <param name="level">Name of the level.</param>
public static void AddLevel(Level level)
{
if (Levels.Contains(level))
{
return;
}
Levels.Add(level);
}
public ElementPipeline(ObjToNode objFromNode)
{
lock (Levels)
if (!Levels.Contains(objFromNode.Level + 1))
{
Levels.Add(objFromNode.Level + 1);
}
Element = objFromNode.GetElement;
//TimestampSignature = objFromNode.TimestampSignature;
}
private void OnAddLevelExecute()
{
var level = new TileLevel();
var lastLevel = Levels.Last();
level.Color = ControlPaint.Dark(lastLevel.Color);
Levels.Add(level);
level.PropertyChanged += Item_PropertyChanged;
level.TotalTimeH = lastLevel.TotalTimeH + 1;
}
/// <summary>
/// Adds a worldBlockChangedr's list of worlds.
/// </summary>
public void AddLevel(Level level)
{
level.World.BlockChanged += HandleOnBlockChanged;
level.World.SpawnEntity += (sender, args) =>
EntityManager.SpawnEntity(sender as World, args.Entity);
level.World.DestroyEntity += (sender, args) =>
EntityManager.DespawnEntity(sender as World, args.Entity);
WeatherManagers.Add(new WeatherManager(level.World, this));
Levels.Add(level);
}
private void OnResetLevelsExecute()
{
Levels.Clear();
var defLevels = TileLevel.Defaults();
foreach (var item in defLevels)
{
Levels.Add(item);
item.PropertyChanged += Item_PropertyChanged;
}
}
public void GenerateMap()
{
while (true)
{
Levels.Clear();
// Generate levels
Levels.Add(new Level(new Vector2(50, Globals.ScreenSize.Y / 2), Difficulty.Easy));
Levels[0].EnterLevel.Opacity = 0.5f;
for (int i = 0; i < 30; i++)
{
Vector2 position = new Vector2(Globals.Randomizer.Next(100, Globals.ScreenSize.X - 100), Globals.Randomizer.Next(100, Globals.ScreenSize.Y - 100));
Levels.Add(new Level(position, position.X < Globals.ScreenSize.X / 3 ? Difficulty.Easy : position.X < Globals.ScreenSize.X * (2f / 3f) ? Difficulty.Medium : Difficulty.Hard));
}
// Remove overlapping levels
for (int i = 0; i < Levels.Count(); i++)
{
for (int j = Levels.Count() - 1; j >= 1; j--)
{
if (Levels[i] != Levels[j] && Levels[i].Distance(Levels[j].EnterLevel.Position) < 20)
{
Levels.RemoveAt(j);
}
}
}
// Check if possible map
List <Level> reachable = new List <Level>();
reachable.Add(Levels[0]);
for (int i = 0; i < reachable.Count(); i++)
{
foreach (Level level in Levels.Where(item => !reachable.Any(item2 => item == item2) && item.Distance(reachable[i].EnterLevel.Position) < 150))
{
reachable.Add(level);
}
}
if (reachable.Count() / Levels.Count() > 0.95f)
{
// Map succeded test, set first level to player startposition
Levels[0].PlayerOnStar = true;
Levels[0].Complete = true;
Levels[0].PlayerPosition = new Vector2(Levels[0].EnterLevel.Position.X + (float)Math.Cos(Levels[0].PlayerDirection) * 20, Levels[0].EnterLevel.Position.Y + (float)Math.Sin(Levels[0].PlayerDirection) * 20);
playerPosition = 0;
Levels.Add(new Level(Vector2.Zero, Difficulty.Boss));
nearestLevels = FindNearestLevels(Levels[playerPosition]);
break;
}
else
{
continue;
}
}
}
private void cmdTestLevel_Click(object sender, EventArgs e)
{
string exeDir = Path.GetDirectoryName(Application.ExecutablePath);
string filePath = Path.Combine(exeDir, "uwol.sna");
string destPath = Path.Combine(exeDir, "tmp.sna");
File.Copy(filePath, destPath, true);
//string filePath = Path.Combine(exeDir, "game\\data\\rooms.dat");
CodeGenerators.ICodeGenerator generator;
generator = new ZXbinCodeGenerator();
FileStream fileStream = new FileStream(destPath, FileMode.Open, FileAccess.ReadWrite);
byte[] original = new byte[fileStream.Length];
fileStream.Read(original, 0, (int)fileStream.Length);
fileStream.Position = FIRST_BYTE_IN_Z80;
Levels currentLevelList = new Levels();
currentLevelList.Add(currentLevel);
generator.CreateCode(currentLevelList, fileStream);
fileStream.Close();
currentLevelList.Clear();
currentLevelList = null;
launch(destPath);
}
