public void addWorld(WorldEntry world_entry, bool focus = false, bool mark_completed = false) { bool replace_stub = stubs.Count != 0; var game_node = replace_stub ? stubs.First.Value : this.game_scene.Instance() as GameButton; if (replace_stub) { stubs.RemoveFirst(); } game_node.initialize(world_entry); game_node.Connect("GamePressed", GetNode <LevelSelection>("../../.."), "_on_GamePressed"); if (!replace_stub) { addButton(game_node); } if (focus) { game_node.GrabFocus(); } if (mark_completed) { game_node.markCompleted(); } GamesCount++; }
private void CalculateEntityAreaData() { log.Info("Calculating area information for entities..."); var mapFiles = new Dictionary <ushort, MapFile>(); var entities = new HashSet <EntityModel>(); foreach (EntityModel model in DatabaseManager.Instance.WorldDatabase.GetEntitiesWithoutArea()) { entities.Add(model); if (!mapFiles.TryGetValue(model.World, out MapFile mapFile)) { WorldEntry entry = GameTableManager.Instance.World.GetEntry(model.World); mapFile = BaseMapManager.Instance.GetBaseMap(entry.AssetPath); mapFiles.Add(model.World, mapFile); } uint worldAreaId = mapFile.GetWorldAreaId(new Vector3(model.X, model.Y, model.Z)); model.Area = (ushort)worldAreaId; log.Info($"Calculated area {worldAreaId} for entity {model.Id}."); } DatabaseManager.Instance.WorldDatabase.UpdateEntities(entities); log.Info($"Calculated area information for {entities.Count} {(entities.Count == 1 ? "entity" : "entities")}."); }
protected override void Write(ContentWriter output, WorldEntry <T> value) { output.WriteRawObject <MapEntry <T> >(value as MapEntry <T>, mapEntryWriter); output.Write(value.MapContentName); }
public void addEntry(float x, float y, float z, GameObject gameObject) { WorldEntry entry = new WorldEntry(); entry.loc = new Vector3(x, y, z); entry.obj = gameObject; levelObjects.Add(entry); }
/// <summary> /// Generate a base map (.nfmap) file for a single world optionally specifying a single grid. /// </summary> public static void GenerateWorld(ushort worldId, byte?gridX = null, byte?gridY = null) { WorldEntry entry = GameTableManager.World.GetEntry(worldId); if (entry != null) { ProcessWorld(entry, gridX, gridY); } }
public void MergeLocal(WorldEntry info) { Size = info.Size; Difficulties = info.Difficulties; Categories = info.Categories; Path = info.Path; InstalledTime = info.InstalledTime; LastPlayedTime = info.LastPlayedTime; }
private WorldEntry findLocal(WorldEntry world_entry) { foreach (var entry in finished_entries) { if (entry.Name == world_entry.Name && entry.Author == world_entry.Author) { return(entry); } } return(null); }
public static void HandleCharacterSelect(WorldSession session, ClientCharacterSelect characterSelect) { Character character = session.Characters.SingleOrDefault(c => c.Id == characterSelect.CharacterId); if (character == null) { session.EnqueueMessageEncrypted(new ServerCharacterSelectFail { Result = CharacterSelectResult.Failed }); return; } session.Player = new Player(session, character); WorldEntry entry = GameTableManager.World.GetEntry(character.WorldId); if (entry == null) { throw new ArgumentOutOfRangeException(); } switch (entry.Type) { // housing map case 5: { // characters logging in to a housing map are returned to their own residence session.EnqueueEvent(new TaskGenericEvent <Residence>(ResidenceManager.GetResidence(session.Player.Name), residence => { if (residence == null) { residence = ResidenceManager.CreateResidence(session.Player); } ResidenceEntrance entrance = ResidenceManager.GetResidenceEntrance(residence); var mapInfo = new MapInfo(entrance.Entry, 0u, residence.Id); MapManager.AddToMap(session.Player, mapInfo, entrance.Position); })); break; } default: { var mapInfo = new MapInfo(entry); var vector3 = new Vector3(character.LocationX, character.LocationY, character.LocationZ); MapManager.AddToMap(session.Player, mapInfo, vector3); break; } } }
private IEnumerable <uint> GetTextIds(WorldLocation2Entry entry) { WorldZoneEntry worldZone = GameTableManager.Instance.WorldZone.GetEntry(entry.WorldZoneId); if (worldZone != null && worldZone.LocalizedTextIdName != 0) { yield return(worldZone.LocalizedTextIdName); } WorldEntry world = GameTableManager.Instance.World.GetEntry(entry.WorldId); if (world != null && world.LocalizedTextIdName != 0) { yield return(world.LocalizedTextIdName); } }
/// <summary> /// Generate a base map (.nfmap) file from supplied <see cref="WorldEntry"/>. /// </summary> private static void ProcessWorld(WorldEntry entry, byte?gridX = null, byte?gridY = null) { var mapFile = new WritableMapFile(Path.GetFileName(entry.AssetPath)); log.Info($"Processing {mapFile.Asset}..."); if (gridX.HasValue && gridY.HasValue) { string path = Path.Combine(entry.AssetPath, $"{mapFile.Asset}.{gridX:x2}{gridY:x2}.area"); IArchiveFileEntry grid = ArchiveManager.MainArchive.GetFileInfoByPath(path); if (grid != null) { ProcessGrid(mapFile, grid, gridX.Value, gridY.Value); } } else { string path = Path.Combine(entry.AssetPath, "*.*.area"); foreach (IArchiveFileEntry grid in ArchiveManager.MainArchive.IndexFile.GetFiles(path)) { Regex regex = new Regex(@"[\w]+\.([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})\.area"); Match match = regex.Match(grid.FileName); byte x = byte.Parse(match.Groups[1].Value, NumberStyles.HexNumber); byte y = byte.Parse(match.Groups[2].Value, NumberStyles.HexNumber); ProcessGrid(mapFile, grid, x, y); } } // FIXME: this happens for worlds with no terrain information, this is usually an instance where props are used as terrain if (!mapFile.Any()) { log.Info($"Map {mapFile.Asset} has no grid information, skipping"); return; } // Path.ChangeExtension(mapFile.Asset, "nfmap") // ChangeExtension doesn't behave correctly on linux string filePath = Path.Combine("map", $"{mapFile.Asset}.nfmap"); using (FileStream stream = File.Create(filePath)) using (var writer = new BinaryWriter(stream)) { mapFile.Write(writer); } }
public void updateWorld() { Vector3 pcPos = pc.transform.position; while (levelObjects.Count > 0) { WorldEntry entry = levelObjects [0]; if (entry.loc.x < pcPos.x + SPAWN_OFFSET) { Instantiate(entry.obj, entry.loc, Quaternion.identity); levelObjects.RemoveAt(0); } else { return; } } }
public void WorldUpdate() { Vector3 pcPos = pc.transform.position; while (levelObjects.Count > 0) { WorldEntry thisentry = levelObjects [0]; if (thisentry.loc.x < pcPos.x + spawningOffset) { Instantiate(thisentry.obj, thisentry.loc, Quaternion.identity); levelObjects.RemoveAt(0); } else { break; } } }
/// <summary> /// Enqueue <see cref="GridEntity"/> to be added to a map. /// </summary> public static void AddToMap(GridEntity entity, ushort worldId, Vector3 vector3) { WorldEntry entry = GameTableManager.World.GetEntry(worldId); if (entry == null) { throw new ArgumentException(); } if (maps.TryGetValue(worldId, out BaseMap map)) { map.EnqueueAdd(entity, vector3); } else { var newMap = new BaseMap(entry); newMap.EnqueueAdd(entity, vector3); maps.Add(worldId, newMap); } }
public bool checkEntry(WorldEntry entry) { if (category != null && !entry.Categories.Contains(category)) { return(false); } if (difficulty != null && !entry.Difficulties.Contains(difficulty)) { return(false); } if (size != null && !entry.Size.Equals(size)) { return(false); } if (text != null && !entry.Name.ToLower().Contains(text) && !entry.Author.ToLower().Contains(text)) { return(false); } return(true); }
private void PreCacheMapFiles() { log.Info("Caching map files..."); List <ushort> precachedBaseMaps = ConfigurationManager <WorldServerConfiguration> .Instance.Config.Map.PrecacheBaseMaps; if (precachedBaseMaps == null) { return; } foreach (ushort worldId in precachedBaseMaps) { WorldEntry entry = GameTableManager.Instance.World.GetEntry(worldId); if (entry == null) { throw new ConfigurationException($"Invalid world id {worldId} supplied for precached base maps!"); } LoadBaseMap(entry.AssetPath); } }
private WorldEntry generateRemoteWorld(Dictionary json_item) { WorldEntry world_info = new WorldEntry(); world_info.HasServerInfo = true; world_info.Name = HTTPUtil.jsonValue <string>(json_item, "name"); world_info.Author = HTTPUtil.jsonValue <string>(json_item, "author"); world_info.Description = HTTPUtil.jsonValue <string>(json_item, "description"); var base64_icon = HTTPUtil.jsonValue <string>(json_item, "icon"); world_info.Icon = base64_icon != null && base64_icon.Length > 0 ? GDKnyttAssetManager.loadTexture(decompress(Convert.FromBase64String(base64_icon))) : null; world_info.Link = HTTPUtil.jsonValue <string>(json_item, "link"); world_info.FileSize = HTTPUtil.jsonInt(json_item, "file_size"); world_info.Upvotes = HTTPUtil.jsonInt(json_item, "upvotes"); world_info.Downvotes = HTTPUtil.jsonInt(json_item, "downvotes"); world_info.Downloads = HTTPUtil.jsonInt(json_item, "downloads"); world_info.Complains = HTTPUtil.jsonInt(json_item, "complains"); world_info.Verified = HTTPUtil.jsonBool(json_item, "verified"); world_info.Approved = HTTPUtil.jsonBool(json_item, "approved"); return(world_info); }
public void initialize(WorldEntry info) { worldEntry = info; GetNode <AnimatedSprite>("AnimatedSprite").Visible = false; GetNode <Control>("MainContainer").Visible = true; GetNode <Control>("RatingControl").Visible = true; GetNode <TextureRect>("MainContainer/IconTexture").Texture = info.Icon; GetNode <TextureRect>("MainContainer/IconTexture").RectSize = new Vector2(30, 30); GetNode <Label>("MainContainer/TextContainer/NameLabel").Text = $"{info.Name} ({info.Author})"; GetNode <Label>("MainContainer/TextContainer/DescriptionLabel").Text = info.Description; progressRect = GetNode <ColorRect>("ProgressRect"); startProgressLength = progressRect.RectSize.x - progressRect.MarginLeft; varProgressLength = RectSize.x - startProgressLength - progressRect.MarginLeft * 2; var rating_control = GetNode <Control>("RatingControl"); if (!worldEntry.HasServerInfo) { rating_control.Visible = false; RectMinSize = new Vector2(RectMinSize.x, 45); } else { rating_control.Visible = true; RectMinSize = new Vector2(RectMinSize.x, 55); rating_control.GetNode <Label>("SizeLabel").Text = $"{(worldEntry.FileSize / 1024f / 1024f):0.#} MB"; rating_control.GetNode <Label>("UpvotesLabel").Text = $"+{worldEntry.Upvotes}"; rating_control.GetNode <Label>("DownvotesLabel").Text = $"-{worldEntry.Downvotes}"; rating_control.GetNode <Label>("DownloadsLabel").Text = $"{worldEntry.Downloads}"; rating_control.GetNode <Label>("VerifiedLabel").Text = worldEntry.Approved ? "Approved" : worldEntry.Verified ? "Autoverified" : "Not Verified"; rating_control.GetNode <Label>("VerifiedLabel").AddColorOverride("font_color", worldEntry.Approved || worldEntry.Verified ? new Color(0, 0.5f, 0) : new Color(0.5f, 0, 0)); } }
public void WorldStart() { // Sorting level by x position levelObjects.Sort((x, y) => x.loc.x.CompareTo(y.loc.x)); spawningOffset = 18; Vector3 pcpos = pc.transform.position; // Actual starting position pc.transform.position = new Vector3(pcpos.x, pcpos.y + 10, pcpos.z); // Testing starting position // pc.transform.position = new Vector3 (pcpos.x + 420, pcpos.y, pcpos.z); // Instantiate all the background panels, so that they'll be layered correctly foreach (WorldEntry bg in backgroundObjects) { Instantiate(bg.obj, bg.loc, Quaternion.identity); } // Instantiate everything that should be on screen or will be soon while (levelObjects.Count > 0) { WorldEntry thisentry = levelObjects [0]; if (thisentry.loc.x < spawningOffset) { Instantiate(thisentry.obj, thisentry.loc, Quaternion.identity); levelObjects.RemoveAt(0); } else { break; } } }
/// <summary> /// Remove the given fixed-combat entry from the current map or quest. /// </summary> public static void RemoveFixedCombat(MapEntry<FixedCombat> mapEntry) { // check the parameter if (mapEntry == null) { return; } // check the map for the item first if (TileEngine.Map != null) { int removedEntries = TileEngine.Map.FixedCombatEntries.RemoveAll( delegate(MapEntry<FixedCombat> entry) { return ((entry.ContentName == mapEntry.ContentName) && (entry.MapPosition == mapEntry.MapPosition)); }); if (removedEntries > 0) { WorldEntry<FixedCombat> worldEntry = new WorldEntry<FixedCombat>(); worldEntry.Content = mapEntry.Content; worldEntry.ContentName = mapEntry.ContentName; worldEntry.Count = mapEntry.Count; worldEntry.Direction = mapEntry.Direction; worldEntry.MapContentName = TileEngine.Map.AssetName; worldEntry.MapPosition = mapEntry.MapPosition; singleton.removedMapFixedCombats.Add(worldEntry); return; } } // look for the map entry within the quest if (singleton.quest != null) { int removedEntries = singleton.quest.FixedCombatEntries.RemoveAll( delegate(WorldEntry<FixedCombat> entry) { return ((entry.ContentName == mapEntry.ContentName) && (entry.MapPosition == mapEntry.MapPosition) && TileEngine.Map.AssetName.EndsWith(entry.MapContentName)); }); if (removedEntries > 0) { WorldEntry<FixedCombat> worldEntry = new WorldEntry<FixedCombat>(); worldEntry.Content = mapEntry.Content; worldEntry.ContentName = mapEntry.ContentName; worldEntry.Count = mapEntry.Count; worldEntry.Direction = mapEntry.Direction; worldEntry.MapContentName = TileEngine.Map.AssetName; worldEntry.MapPosition = mapEntry.MapPosition; singleton.removedQuestFixedCombats.Add(worldEntry); return; } } }
/// <summary> /// Remove the given player NPC entry from the current map or quest. /// </summary> public static void RemovePlayerNpc(MapEntry<Player> mapEntry) { // check the parameter if (mapEntry == null) { return; } // check the map for the item if (TileEngine.Map != null) { int removedEntries = TileEngine.Map.PlayerNpcEntries.RemoveAll( delegate(MapEntry<Player> entry) { return ((entry.ContentName == mapEntry.ContentName) && (entry.MapPosition == mapEntry.MapPosition)); }); if (removedEntries > 0) { WorldEntry<Player> worldEntry = new WorldEntry<Player>(); worldEntry.Content = mapEntry.Content; worldEntry.ContentName = mapEntry.ContentName; worldEntry.Count = mapEntry.Count; worldEntry.Direction = mapEntry.Direction; worldEntry.MapContentName = TileEngine.Map.AssetName; worldEntry.MapPosition = mapEntry.MapPosition; singleton.removedMapPlayerNpcs.Add(worldEntry); return; } } // quests don't have a list of player NPCs }
/// <summary> /// Generate a base map (.nfmap) file from supplied <see cref="WorldEntry"/>. /// </summary> private static void ProcessWorld(WorldEntry entry) { var mapFile = new WritableMapFile(Path.GetFileName(entry.AssetPath)); log.Info($"Processing {mapFile.Asset}..."); foreach (IArchiveFileEntry fileEntry in ArchiveManager.MainArchive.IndexFile.GetFiles(Path.Combine(entry.AssetPath, "*.*.area"))) { // skip any low quality grids if (fileEntry.FileName.Contains("_low", StringComparison.OrdinalIgnoreCase)) { continue; } Regex regex = new Regex(@"[\w]+\.([A-Fa-f0-9]{2})([A-Fa-f0-9]{2})\.area"); Match match = regex.Match(fileEntry.FileName); uint x = uint.Parse(match.Groups[1].Value, NumberStyles.HexNumber); uint y = uint.Parse(match.Groups[2].Value, NumberStyles.HexNumber); log.Info($"Processing {mapFile.Asset} grid {x},{y}..."); using (Stream stream = ArchiveManager.MainArchive.OpenFileStream(fileEntry)) { try { var mapFileGrid = new WritableMapFileGrid(x, y); var areaFile = new AreaFile(stream); foreach (IReadable areaChunk in areaFile.Chunks) { switch (areaChunk) { case Chnk chnk: { foreach (ChnkCell cell in chnk.Cells.Where(c => c != null)) { var mapFileCell = new WritableMapFileCell(cell); mapFileGrid.AddCell(mapFileCell); } break; } } } mapFile.SetGrid(x, y, mapFileGrid); } catch (Exception e) { log.Error(e); } } } if (!mapFile.Any()) { log.Info($"Map {mapFile.Asset} has no grid information, skipping"); return; } // Path.ChangeExtension(mapFile.Asset, "nfmap") // ChangeExtension doesn't behave correctly on linux string filePath = Path.Combine("map", $"{mapFile.Asset}.nfmap"); using (FileStream stream = File.Create(filePath)) using (var writer = new BinaryWriter(stream)) { mapFile.Write(writer); } }
public MapInfo(WorldEntry entry, uint instanceId = 0u, ulong residenceId = 0ul) { Entry = entry; InstanceId = instanceId; ResidenceId = residenceId; }
public BaseMap(WorldEntry entry) { Entry = entry; CacheEntitySpawns(); }
public static void HandleCharacterSelect(WorldSession session, ClientCharacterSelect characterSelect) { CharacterModel character = session.Characters.SingleOrDefault(c => c.Id == characterSelect.CharacterId); if (character == null) { session.EnqueueMessageEncrypted(new ServerCharacterSelectFail { Result = CharacterSelectResult.Failed }); return; } if (PlayerCleanupManager.HasPendingCleanup(session.Account)) { session.EnqueueMessageEncrypted(new ServerCharacterSelectFail { Result = CharacterSelectResult.FailedCharacterInWorld }); return; } session.Player = new Player(session, character); WorldEntry entry = GameTableManager.Instance.World.GetEntry(character.WorldId); if (entry == null) { throw new ArgumentOutOfRangeException(); } switch ((MapType)entry.Type) { case MapType.Residence: case MapType.Community: { // characters logging in to a housing map are returned to their own residence Residence residence = session.Player.ResidenceManager.Residence; residence ??= GlobalResidenceManager.Instance.CreateResidence(session.Player); ResidenceEntrance entrance = GlobalResidenceManager.Instance.GetResidenceEntrance(residence.PropertyInfoId); session.Player.Rotation = entrance.Rotation.ToEulerDegrees(); MapManager.Instance.AddToMap(session.Player, new MapPosition { Info = new MapInfo { Entry = entrance.Entry, InstanceId = residence.Parent?.Id ?? residence.Id }, Position = entrance.Position }); break; } default: { session.Player.Rotation = new Vector3(character.RotationX, character.RotationY, character.RotationZ); MapManager.Instance.AddToMap(session.Player, new MapPosition { Info = new MapInfo { Entry = entry }, Position = new Vector3(character.LocationX, character.LocationY, character.LocationZ) }); break; } } }
public Location(WorldEntry world, Vector3 position, Vector3 rotation) { World = world; Position = position; Rotation = rotation; }
public void Initialise(MapInfo info, Player player) { entry = info.Entry; }
public bool addWorld(WorldEntry entry) { this.Entries.Add(entry); return(checkEntry(entry)); }