Example #1
0
        /// <summary>
        /// Gets incremental incline data for a point and a neighboring point.
        /// </summary>
        /// <param name="mapMetaData">Map meta data.</param>
        /// <param name="startPoint">Start point, using mapmetadata indices.</param>
        /// <param name="endPoint">End point, using mapmetadata indices.</param>
        /// <param name="incline">Incline (out).</param>
        /// <param name="decline">Decline (out).</param>
        /// <param name="distance">Distance (out).</param>
        void getIncrementalInclines(MapMetaData mapMetaData, Point startPoint, Point endPoint, out float incline, out float decline, out float distance)
        {
            Vector3 startVector = mapMetaData.getWorldPos(startPoint);
            Vector3 endVector   = mapMetaData.getWorldPos(endPoint);

            MapTerrainDataCell startCell = mapMetaData.GetCellAt(startPoint);
            MapTerrainDataCell endCell   = mapMetaData.GetCellAt(endPoint);

            float horzDistance = Mathf.Abs(startVector.x - endVector.x) + Mathf.Abs(startVector.z - endVector.z);

            distance = horzDistance;

            float vertDistance = endCell.cachedHeight - startCell.cachedHeight;

            if (vertDistance > 0)
            {
                decline = 0.0f;
                incline = vertDistance / horzDistance;
            }
            else
            {
                incline = 0.0f;
                decline = -(vertDistance / horzDistance);
            }
        }
        public static bool SaveMapMetaData(MapMetaData metaData)
        {
            if (metaData == null)
            {
                return(false);
            }

            try
            {
                CreateMetaDataFolder();

                string fileName   = metaData.GetJsonFileName();
                string pathToFile = Path.Combine(FullPathToMetaFolder, fileName);


                string jsonToSave = JsonConvert.SerializeObject(metaData, Formatting.Indented);

                File.WriteAllText(pathToFile, jsonToSave);
                return(true);
            }
            catch (Exception e)
            {
                Logger.Error(e, "failed to save map meta data");
                return(false);
            }
        }
Example #3
0
        private void LoadMapMetaData()
        {
            var taglist =
                VariousFunctions.GZip.Decompress(VariousFunctions.GetTaglistFile(GameId, SandboxHeader.MapID));

            SandboxMapMetaData = JsonConvert.DeserializeObject <MapMetaData>(VariousFunctions.ByteArrayToString(taglist, VariousFunctions.EncodingType.ASCII));
        }
        public static BoolWithMessage DeleteMapFiles(MapMetaData metaData)
        {
            if (metaData == null)
            {
                return(BoolWithMessage.False($"meta data is null"));
            }

            if (metaData.FilePaths?.Count == 0)
            {
                return(BoolWithMessage.False($"List of files to delete is unknown for {metaData.MapName}. You must manually delete the map files from the following folder: {metaData.MapFileDirectory}"));
            }

            try
            {
                BoolWithMessage result = FileUtils.DeleteFiles(metaData.FilePaths);

                if (result.Result == false)
                {
                    return(result);
                }

                // lastly delete meta data file
                string pathToMetaData = Path.Combine(MetaDataManager.FullPathToMetaFolder, metaData.GetJsonFileName());
                if (File.Exists(pathToMetaData))
                {
                    File.Delete(pathToMetaData);
                }

                return(BoolWithMessage.True($"{metaData.MapName} has been deleted!"));
            }
            catch (Exception e)
            {
                return(BoolWithMessage.False($"Failed to delete files: {e.Message}"));
            }
        }
    public IEnumerator HandleReadInMapMetaData()
    {
        string sStream = AsynchronousClient.Instance.Send("RequestMapMetaData:0");

        yield return(sStream);

        string[] sMaps = sStream.Split("#".ToCharArray());

        foreach (string sMapStream in sMaps)
        {
            if (sMapStream != "")
            {
                string[] sMapMetaData = sMapStream.Split(",".ToCharArray());


                MapMetaData cMapMetaData = GameObject.Find("_MapManager").AddComponent <MapMetaData>();

                GameObject.Find("_MapManager").GetComponent <MapManager>().MapMetaDatas.Add(cMapMetaData);

                cMapMetaData.sName      = sMapMetaData[0];
                cMapMetaData.sExpansion = sMapMetaData[1];
                cMapMetaData.sPlayers   = sMapMetaData[2];
                int.TryParse(sMapMetaData[2], out cMapMetaData.iNoOfPlayers);
                cMapMetaData.sMapType = sMapMetaData[3];
            }
        }
    }
Example #6
0
        /// <summary>
        /// Map assets loading task
        /// </summary>
        /// <param name="map">Map to be loaded</param>
        /// <param name="mapMetaData">Map meta data to be loaded</param>
        private async Task LoadMapAssets(AssetModel map, MapMetaData mapMetaData)
        {
            var loading = true;

            try
            {
                var callback = new Action <bool, string, string>((isDone, sceneName, mapBundlePath) =>
                {
                    var scene = SceneManager.GetSceneByName(sceneName);
                    SceneManager.SetActiveScene(scene);
                    CurrentMapMetaData = mapMetaData;

                    if (Loader.Instance.SimConfig != null)
                    {
                        Loader.Instance.SimConfig.MapName = CurrentMapMetaData.name;
                    }

                    CurrentMapBounds = CalculateMapBounds(scene);
                    LaneSnapping.Initialize();
                    loadedSceneName = sceneName;
                    PlayerPrefs.SetString(MapPersistenceKey, CurrentMapMetaData.name);
                    loading = false;
                    MapChanged?.Invoke(CurrentMapMetaData);
                });
                Loader.LoadMap(map.AssetGuid, map.Name, LoadSceneMode.Additive, callback);
                while (loading)
                {
                    await Task.Delay(100);
                }
            }
            catch (Exception ex)
            {
                ScenarioManager.Instance.logPanel.EnqueueError(ex.Message);
            }
        }
Example #7
0
        private void StartNewGameRoutine()
        {
            //begin mod
            var m_MapName  = this.Find <UITextField>("MapName");
            var m_FileList = this.Find <UIListBox>("MapList");
            //end mod
            SimulationMetaData ngs = new SimulationMetaData()
            {
                m_CityName = m_MapName.text, m_gameInstanceIdentifier = Guid.NewGuid().ToString(), m_invertTraffic = !this.Find <UICheckBox>("InvertTraffic").isChecked ? SimulationMetaData.MetaBool.False : SimulationMetaData.MetaBool.True, m_disableAchievements = Singleton <PluginManager> .instance.enabledModCount <= 0 ? SimulationMetaData.MetaBool.False : SimulationMetaData.MetaBool.True, m_currentDateTime = DateTime.Now, m_newGameAppVersion = 159507472, m_updateMode = SimulationManager.UpdateMode.NewGameFromMap
            };

            //begin mod
            ngs.m_environment = m_forceEnvironment;
            //end mod

            MapMetaData listingMetaData = this.GetListingMetaData(m_FileList.selectedIndex);

            if (listingMetaData.mapThemeRef != null)
            {
                Package.Asset assetByName = PackageManager.FindAssetByName(listingMetaData.mapThemeRef);
                if (assetByName != (Package.Asset)null)
                {
                    ngs.m_MapThemeMetaData = assetByName.Instantiate <MapThemeMetaData>();
                    ngs.m_MapThemeMetaData.SetSelfRef(assetByName);
                }
            }
            Singleton <LoadingManager> .instance.LoadLevel(this.GetListingData(m_FileList.selectedIndex), "Game", "InGame", ngs);

            UIView.library.Hide(this.GetType().Name, 1);
        }
 public void PreprocessMain(ReplayGamestate gamestate, MapMetaData mapmeta, EncounterDetectionData nedData)
 {
     //foreach (var round in gamestate.match.rounds)
     //    foreach (var tick in round.ticks)
     //        foreach (var tevent in tick.tickevents)
     //            HashGridcells(tevent);
 }
        public static MapMetaData CreateMapMetaData(string sourceMapFolder, bool findMapFiles)
        {
            MapMetaData metaData = new MapMetaData();

            metaData.IsHiddenByUser = false;
            metaData.CustomName     = "";

            MapListItem validMap = GetFirstMapInFolder(sourceMapFolder, isValid: true);

            if (validMap == null)
            {
                return(null);
            }

            metaData.MapName          = validMap.MapName;
            metaData.MapFileDirectory = ReplaceSourceMapPathWithPathToContent(sourceMapFolder, validMap.DirectoryPath);

            if (findMapFiles)
            {
                metaData.FilePaths = FileUtils.GetAllFilesInDirectory(sourceMapFolder);

                // modify file paths to match the target folder Session "Content" folder
                for (int i = 0; i < metaData.FilePaths.Count; i++)
                {
                    metaData.FilePaths[i] = ReplaceSourceMapPathWithPathToContent(sourceMapFolder, metaData.FilePaths[i]);
                }
            }
            else
            {
                metaData.FilePaths = new List <string>();
            }

            return(metaData);
        }
Example #10
0
        public InclineMeshData BuildMeshData(MapMetaData mapMetaData)
        {
            DateTime startTime = System.DateTime.Now;

            Debug.Log("started making incline mesh at " + startTime);

            int numInclineNodesX = Mathf.CeilToInt(mapMetaData.mapTerrainDataCells.GetLength(0) / (float)downsampleFactor);
            int numInclineNodesZ = Mathf.CeilToInt(mapMetaData.mapTerrainDataCells.GetLength(1) / (float)downsampleFactor);

            InclineMeshData meshData = new InclineMeshData(numInclineNodesX, numInclineNodesZ);

            meshData.downsampleFactor = downsampleFactor;
            meshData.mapMetaData      = mapMetaData;

            for (int x = 0; x < numInclineNodesX; ++x)
            {
                for (int z = 0; z < numInclineNodesZ; ++z)
                {
                    InclineIndexPoint inclinePoint = new InclineIndexPoint(x, z);
                    processNode(meshData, mapMetaData, inclinePoint);
                }
            }
            DateTime endTime = System.DateTime.Now;
            TimeSpan elapsed = endTime - startTime;

            Debug.Log("finished making incline mesh at " + endTime);
            Debug.Log("Elapsed Time: " + elapsed);

            return(meshData);
        }
 static bool Prefix(MapMetaData __instance, ref MapTerrainDataCell __result, Point index, MapTerrainDataCell[,] ___mapTerrainDataCells)
 {
     try {
         __result = ___mapTerrainDataCells[index.Z, index.X];
     } catch (IndexOutOfRangeException) {
         __result = InvalidCell;
     }
     return(false);
 }
Example #12
0
        static bool Prefix(MapMetaDataExporter __instance, MapMetaData existingMapMetaData, string encounterLayerGuid, DataManager dataManager)
        {
            Main.Logger.Log($"[MapMetaDataExporterPatch Prefix] Patching LoadMapMetaDataV2");
            if (MissionControl.Instance.IsCustomContractType)
            {
                return(false);
            }

            return(true);
        }
Example #13
0
 public void Load(EndianStream stream, MapMetaData mapMetaData)
 {
     Offset             = stream.Position;
     Ident              = stream.ReadInt32();
     Tag                = mapMetaData.GetTag(Ident);
     RunTimeMinimium    = stream.ReadByte();
     RunTimeMaximium    = stream.ReadByte();
     CountOnMap         = stream.ReadByte();
     DesignTimeMaximium = stream.ReadByte();
     Cost               = stream.ReadFloat();
 }
        public static bool HasPathToMapFilesStored(MapListItem map)
        {
            MapMetaData metaData = LoadMapMetaData(map);

            if (metaData != null)
            {
                return(metaData.FilePaths?.Count > 0);
            }

            return(false);
        }
        internal static string GetOriginalImportLocation(MapListItem map)
        {
            MapMetaData metaData = LoadMapMetaData(map);

            if (metaData == null)
            {
                return("");
            }

            return(metaData.OriginalImportPath);
        }
        public static MapMetaData CreateMapMetaData(MapListItem map)
        {
            MapMetaData metaData = new MapMetaData();

            metaData.MapName          = map.MapName;
            metaData.MapFileDirectory = map.DirectoryPath;
            metaData.FilePaths        = new List <string>();
            metaData.IsHiddenByUser   = map.IsHiddenByUser;
            metaData.CustomName       = map.CustomName;

            return(metaData);
        }
        /// <summary>
        /// Gets the meta .json for the map if it exists and updates
        /// the custom name and IsHiddenByUser property
        /// </summary>
        public static void SetCustomPropertiesForMap(MapListItem map, bool createIfNotExists = false)
        {
            if (map.IsDefaultMap)
            {
                return;
            }

            MapMetaData savedMetaData = LoadMapMetaData(map);

            if (savedMetaData == null)
            {
                if (createIfNotExists)
                {
                    savedMetaData = CreateMapMetaData(map);
                    SaveMapMetaData(savedMetaData);
                }
                else
                {
                    return;
                }
            }

            // grab image from asset store if exists and path not set yet
            bool hasChanged = false;

            if (!string.IsNullOrWhiteSpace(savedMetaData.PathToImage) && !File.Exists(savedMetaData.PathToImage))
            {
                // remove image path if file does not exist
                savedMetaData.PathToImage = "";
                hasChanged = true;
            }

            if (string.IsNullOrWhiteSpace(savedMetaData.PathToImage) && !string.IsNullOrEmpty(savedMetaData.AssetNameWithoutExtension))
            {
                string pathToStoreThumbnail = Path.Combine(AssetStoreViewModel.AbsolutePathToThumbnails, savedMetaData.AssetNameWithoutExtension);

                if (File.Exists(pathToStoreThumbnail))
                {
                    savedMetaData.PathToImage = pathToStoreThumbnail;
                    hasChanged = true;
                }
            }

            if (hasChanged)
            {
                SaveMapMetaData(savedMetaData);
            }

            map.IsHiddenByUser = savedMetaData.IsHiddenByUser;
            map.CustomName     = savedMetaData.CustomName;
            map.PathToImage    = savedMetaData.PathToImage;
        }
Example #18
0
        /// <summary>
        /// Downloads selected map asynchronously and updates the loading information
        /// </summary>
        /// <param name="map">Map to download</param>
        /// <param name="loadingProcess">Loading process to update with progress</param>
        /// <returns>Task</returns>
        private async Task DownloadMap(MapMetaData map, LoadingPanel.LoadingProcess loadingProcess)
        {
            mapBeingDownloaded = map.assetGuid;
            var progressUpdate = new Progress <Tuple <string, float> >(p =>
            {
                loadingProcess?.Update($"Downloading {p.Item1} {p.Item2:F}%.");
            });

            map.assetModel =
                await DownloadManager.GetAsset(BundleConfig.BundleTypes.Environment, map.assetGuid, map.name, progressUpdate);

            mapBeingDownloaded = null;
        }
Example #19
0
        float getDistanceBetweenTwoInclinePoints(InclineMeshData meshData, MapMetaData mapMetaData)
        {
            InclineIndexPoint inclinePoint1 = new InclineIndexPoint(1, 1);
            InclineIndexPoint inclinePoint2 = new InclineIndexPoint(1, 2);

            Point mapPoint1 = meshData.InclineIndicesToMapIndices(inclinePoint1);
            Point mapPoint2 = meshData.InclineIndicesToMapIndices(inclinePoint2);

            Vector3 worldVec1 = mapMetaData.getWorldPos(mapPoint1);
            Vector3 worldVec2 = mapMetaData.getWorldPos(mapPoint2);

            return((worldVec2 - worldVec1).magnitude);
        }
Example #20
0
    public static void LoadMapData(this EncounterLayerData layerData, EncounterLayerIdentifier encounterLayerIdentifier, DataManager dataManager)
    {
        EncounterLayerParent component       = MissionControl.MissionControl.Instance.EncounterLayerParent;
        MapMetaDataExporter  mapMetaExporter = component.GetComponent <MapMetaDataExporter>();

        AccessTools.Method(typeof(MapMetaDataExporter), "LoadMapMetaDataOnly").Invoke(mapMetaExporter, new object[] { UnityGameInstance.BattleTechGame.Combat.MapMetaData, dataManager });

        MapMetaData     mapMetaData     = mapMetaExporter.mapMetaData;
        InclineMeshData inclineMeshData = mapMetaExporter.inclineMeshData;

        string encounterLayerIdentifierPath = encounterLayerIdentifier.path;
        string encounterLayerDataName       = MapMetaDataExporter.GetEncounterLayerDataName(encounterLayerIdentifier.name);

        MissionControl.Main.LogDebug("[LoadMapData] Borrowing Map Data form Layer Data " + encounterLayerDataName);

        encounterLayerIdentifierPath = dataManager.ResourceLocator.EntryByID(encounterLayerDataName, BattleTechResourceType.LayerData, false).FilePath;
        byte[]             data        = File.ReadAllBytes(encounterLayerIdentifierPath);
        EncounterLayerData layerByGuid = layerData;

        Serializer.Deserialize <EncounterLayerData>(data, SerializationTarget.Exported, TargetMaskOperation.HAS_ANY, layerByGuid);
        layerByGuid.ReattachReferences();
        using (SerializationStream serializationStream = new SerializationStream(File.ReadAllBytes(encounterLayerIdentifierPath.Replace(".bin", "_RaycastInfo.bin")))) {
            layerByGuid.LoadRaycastInfo(serializationStream);
        }
        int length  = mapMetaData.mapTerrainDataCells.GetLength(1);
        int length2 = mapMetaData.mapTerrainDataCells.GetLength(0);

        for (int i = 0; i < length; i++)
        {
            for (int j = 0; j < length2; j++)
            {
                mapMetaData.mapTerrainDataCells[i, j].MapEncounterLayerDataCell = layerByGuid.mapEncounterLayerDataCells[i, j];
                mapMetaData.mapTerrainDataCells[i, j].UpdateCachedValues();
            }
        }
        string inclineMeshPathFromEncounterLayerDataPath = encounterLayerIdentifierPath.Replace(".bin", "_InclineMesh.IMS");

        inclineMeshData = new InclineMeshData();
        if (inclineMeshData.LoadFromPath(inclineMeshPathFromEncounterLayerDataPath))
        {
            inclineMeshData.mapMetaData = mapMetaData;
            layerByGuid.inclineMeshData = inclineMeshData;
        }
        else
        {
            layerByGuid.inclineMeshData = null;
        }

        mapMetaExporter.mapTags = new TagSet(mapMetaData.mapTags);
        MissionControl.Main.LogDebug("[LoadMapData] Load Complete");
    }
Example #21
0
        public CacheNode(Vector3 worldPosition, MapMetaData mapMetaData)
        {
            this.CellIndex = mapMetaData.GetIndex(worldPosition);
            this.cells     = new MapTerrainDataCell[9];
            for (int i = 0; i < 9; i++)
            {
                this.cells[i] = mapMetaData.GetCellAt(this.CellIndex.X + xDiff[i], this.CellIndex.Z + zDiff[i]);
            }
            this.UpdateLocalGrade();
            this.UpdateSteepness();
            this.UpdateIsPassableTerrain();

            this.NeighborLinks = new CacheNodeLink[8];
        }
Example #22
0
        /// <summary>
        /// Downloads selected map asynchronously and updates the loading information
        /// </summary>
        /// <param name="map">Map to download</param>
        /// <param name="loadingProcess">Loading process to update with progress</param>
        /// <returns>Task</returns>
        private async Task DownloadMap(MapMetaData map, LoadingPanel.LoadingProcess loadingProcess)
        {
            ScenarioManager.Instance.ReportAssetDownload(map.assetGuid);
            var progressUpdate = new Progress <Tuple <string, float> >(p =>
            {
                loadingProcess?.Update($"Downloading {p.Item1} {p.Item2:F}%.");
            });

            map.assetModel =
                await DownloadManager.GetAsset(BundleConfig.BundleTypes.Environment, map.assetGuid, map.name,
                                               progressUpdate);

            ScenarioManager.Instance.ReportAssetFinishedDownload(map.assetGuid);
        }
Example #23
0
        public void UpdateIsPassableTerrain()
        {
            switch (MapMetaData.GetPriorityTerrainMaskFlags(this.cells[0]))
            {
            case (TerrainMaskFlags.DeepWater):
            case (TerrainMaskFlags.Impassable):
            case (TerrainMaskFlags.MapBoundary):
                this.IsImpassibleTerrain = true;
                break;

            default:
                this.IsImpassibleTerrain = false;
                break;
            }
        }
        /// <summary>
        /// Updates the meta .json files for the maps with the new
        /// custom names and if it is hidden.
        /// </summary>
        public static bool WriteCustomMapPropertiesToFile(MapListItem map)
        {
            MapMetaData metaDataToSave = LoadMapMetaData(map);

            if (metaDataToSave == null)
            {
                // metadata is missing from so re-create it
                metaDataToSave = CreateMapMetaData(map);
            }

            metaDataToSave.IsHiddenByUser = map.IsHiddenByUser;
            metaDataToSave.CustomName     = map.CustomName;

            return(SaveMapMetaData(metaDataToSave));
        }
Example #25
0
        //Constructor
        public TiledMapPanel(PlayScene parent, PlayParameters parameters) : base(parent)
        {
            tileTextures     = new Dictionary <string, Sprite>();
            tileSetsMetaData = new Dictionary <string, TileSetMetaData>();
            mapMetaData      = Maploader.Instance.LoadMapMetaData(parameters.mapFileName);
            foreach (TileSets entry in mapMetaData.tilesets)
            {
                TileSetMetaData metaData = Maploader.Instance.LoadTileSetMetaData(entry.source);

                tileTextures.Add(entry.source, new Sprite(metaData.name, "assets/images/" + metaData.image, 0, 254, 0));
                tileTextures[entry.source].SubRect.h = mapMetaData.tileheight;
                tileTextures[entry.source].SubRect.w = mapMetaData.tilewidth;
                tileTextures[entry.source].Pos.h     = mapMetaData.tileheight;
                tileTextures[entry.source].Pos.w     = mapMetaData.tilewidth;

                tileSetsMetaData.Add(entry.source, metaData);
            }
        }
Example #26
0
        /// <summary>
        /// Thread: Main
        /// Invoked when a level has completed the loading process.
        /// </summary>
        /// <param name="mode">Defines what kind of level was just loaded.</param>*
        public override void OnLevelLoaded(LoadMode mode)
        {
            if (mode != LoadMode.NewGame)
                return;
            MapMetaData data = new MapMetaData();

            Log.Message(String.Format("MapName: {0}", data.mapName));
            loadMode = mode;
            try
            {
                UIView v = UIView.GetAView();
                uiComponent = (UIComponent)v.AddUIComponent(typeof(ConfigurationPanel));
            }
            catch (Exception ex)
            {
                Log.Error("Adding UI Error: " + ex.ToString());
            }
        }
        public static List <MapMetaData> GetAllMetaDataForMaps()
        {
            List <MapMetaData> maps = new List <MapMetaData>();

            CreateMetaDataFolder();

            foreach (string file in Directory.GetFiles(FullPathToMetaFolder, "*_meta.json"))
            {
                MapMetaData foundMetaData = LoadMapMetaData(file);

                if (foundMetaData != null)
                {
                    maps.Add(foundMetaData);
                }
            }

            return(maps);
        }
Example #28
0
        /// <summary>
        /// Deletes the selected asset files from Session folders
        /// </summary>
        public void RemoveSelectedAsset()
        {
            AssetViewModel  assetToRemove = SelectedAsset;
            BoolWithMessage deleteResult  = BoolWithMessage.False("");

            if (assetToRemove.AssetCategory == AssetCategory.Maps.Value)
            {
                MapMetaData mapToDelete = MetaDataManager.GetAllMetaDataForMaps()?.Where(m => m.AssetName == assetToRemove.Asset.ID).FirstOrDefault();

                if (mapToDelete == null)
                {
                    UserMessage = "Failed to find meta data to delete map files ...";
                    return;
                }

                deleteResult = MetaDataManager.DeleteMapFiles(mapToDelete);
            }
            else
            {
                TextureMetaData textureToDelete = MetaDataManager.GetTextureMetaDataByName(assetToRemove.Asset.ID);

                if (textureToDelete == null)
                {
                    UserMessage = $"Failed to find meta data to delete texture files for {assetToRemove.Asset.ID}...";
                    return;
                }

                deleteResult = MetaDataManager.DeleteTextureFiles(textureToDelete);
            }


            UserMessage = deleteResult.Message;

            if (deleteResult.Result)
            {
                RefreshPreviewForSelected();

                // refresh list if filtering by installed or uninstalled
                if (SelectedInstallStatus != defaultInstallStatusValue)
                {
                    RefreshFilteredAssetList();
                }
            }
        }
Example #29
0
        /// <summary>
        /// Thread: Main
        /// Invoked when a level has completed the loading process.
        /// </summary>
        /// <param name="mode">Defines what kind of level was just loaded.</param>*
        public override void OnLevelLoaded(LoadMode mode)
        {
            if (mode != LoadMode.NewGame)
            {
                return;
            }
            MapMetaData data = new MapMetaData();

            Log.Message(String.Format("MapName: {0}", data.mapName));
            loadMode = mode;
            try
            {
                UIView v = UIView.GetAView();
                uiComponent = (UIComponent)v.AddUIComponent(typeof(ConfigurationPanel));
            }
            catch (Exception ex)
            {
                Log.Error("Adding UI Error: " + ex.ToString());
            }
        }
        /// <summary>
        /// Gets the meta .json for the map if it exists and updates
        /// the custom name and IsHiddenByUser property
        /// </summary>
        public static void SetCustomPropertiesForMap(MapListItem map, bool createIfNotExists = false)
        {
            MapMetaData savedMetaData = LoadMapMetaData(map);

            if (savedMetaData == null)
            {
                if (createIfNotExists)
                {
                    savedMetaData = CreateMapMetaData(map);
                    SaveMapMetaData(savedMetaData);
                }
                else
                {
                    return;
                }
            }

            map.IsHiddenByUser = savedMetaData.IsHiddenByUser;
            map.CustomName     = savedMetaData.CustomName;
        }
        public void Test_CreateMapMetaData_Returns_Correct_FilePaths()
        {
            SessionPath.ToSession = TestPaths.ToSessionTestFolder;
            string pathToMapImporting = Path.Combine(TestPaths.ToTestFilesFolder, "Mock_Map_Files", "cool_valid_map");

            MapMetaData expectedResult = new MapMetaData()
            {
                FilePaths = new List <string>()
                {
                    Path.Combine(SessionPath.ToContent, "coolmap.uexp"), Path.Combine(SessionPath.ToContent, "coolmap.umap"),
                    Path.Combine(SessionPath.ToContent, "coolmap_BuiltData.uexp"), Path.Combine(SessionPath.ToContent, "coolmap_BuiltData.uasset"),
                    Path.Combine(SessionPath.ToContent, "coolmap_BuiltData.ubulk")
                }
            };

            MapMetaData actualResult = MetaDataManager.CreateMapMetaData(pathToMapImporting, true);

            actualResult.FilePaths.TrueForAll(s => expectedResult.FilePaths.Contains(s));
            expectedResult.FilePaths.TrueForAll(s => actualResult.FilePaths.Contains(s));
        }
Example #32
0
 public void Load(EndianStream stream, MapMetaData mapMetaData)
 {
     Offset = stream.Position;
     Ident = stream.ReadInt32();
     Tag = mapMetaData.GetTag(Ident);
     RunTimeMinimium = stream.ReadByte();
     RunTimeMaximium = stream.ReadByte();
     CountOnMap = stream.ReadByte();
     DesignTimeMaximium = stream.ReadByte();
     Cost = stream.ReadFloat();
 }
Example #33
0
            public TagEntry(EndianStream stream, MapMetaData mapMetaData)
            {
                Load(stream, mapMetaData);

                PlacedObjects = new List<ObjectChunk>();
            }
Example #34
0
        private void LoadMapMetaData()
        {
            var taglist =
                VariousFunctions.GZip.Decompress(VariousFunctions.GetTaglistFile(GameId, SandboxHeader.MapID));

            SandboxMapMetaData = JsonConvert.DeserializeObject<MapMetaData>(VariousFunctions.ByteArrayToString(taglist, VariousFunctions.EncodingType.ASCII));
        }
Example #35
0
 private static void CreateImageBitmap(MapMetaData imageMd, out WriteableBitmap writeableBitmap)
 {
     var format = MapPixelFormat(imageMd.PixelFormat);
     CreateImageBitmap(imageMd, out writeableBitmap, format);
 }
Example #36
0
        private static void CreateImageBitmap(MapMetaData imageMd, out WriteableBitmap writeableBitmap, System.Windows.Media.PixelFormat format)
        {
            var bmpWidth = (int)imageMd.FullXRes;
            var bmpHeight = (int)imageMd.FullYRes;

            writeableBitmap = new WriteableBitmap(bmpWidth, bmpHeight, 96.0, 96.0, format, null);
        }
Example #37
0
        private static void CopyWritableBitmap(MapMetaData imageMd, IntPtr data, WriteableBitmap b)
        {
            int dataSize = (int) imageMd.DataSize;

            var rect = new Int32Rect((int) imageMd.XOffset, (int) imageMd.YOffset,
                (int) imageMd.XRes, (int) imageMd.YRes);

            b.WritePixels(rect, data, dataSize, b.BackBufferStride);
        }