string GetEntryFullPath(EntryData entry)
{
var downloadFolder = GetSourceProjectFolder(entry.SourceId);
var filename = entry.Hash + PlayerFile.SyncModelTypeToExtension(entry.EntryType);
return(Path.Combine(downloadFolder, filename));
}
public IActionResult OnGet(int?Id) //we receive this Id from View.cs
{
DatabaseConnect DBCon = new DatabaseConnect();
SqlConnection conn = new SqlConnection(DBCon.DatabaseString());
conn.Open();
using (SqlCommand command = new SqlCommand())
{
command.Connection = conn;
command.CommandText = @"SELECT * FROM FileTable WHERE Id = @Id";
command.Parameters.AddWithValue("@Id", Id);
var reader = command.ExecuteReader();
PlayerFileRec = new PlayerFile();
while (reader.Read())
{
PlayerFileRec.Id = reader.GetInt32(0);
PlayerFileRec.PlayerName = reader.GetString(1); //to display on the html page
PlayerFileRec.FileName = reader.GetString(2); //to display on the html page
}
Console.WriteLine("File name : " + PlayerFileRec.FileName);
}
return(Page());
}
public IActionResult OnPost()
{
var FileToUpload = Path.Combine(_env.WebRootPath, "Files", PlayerFile.FileName); //this variable consists of file path
Console.WriteLine("File Name : " + FileToUpload);
using (var FStream = new FileStream(FileToUpload, FileMode.Create))
{
PlayerFile.CopyTo(FStream); //copy the file into FStream variable
}
DatabaseConnect DbCon = new DatabaseConnect();
SqlConnection conn = new SqlConnection(DbCon.DatabaseString());
conn.Open();
using (SqlCommand command = new SqlCommand())
{
command.Connection = conn;
command.CommandText = @"INSERT FileTable (PlayerName, FileName) VALUES (@PlayerName, @FName)";
command.Parameters.AddWithValue("@PlayerName", PlayerFileRec.PlayerName);
command.Parameters.AddWithValue("@FName", PlayerFile.FileName);
Console.WriteLine("File name : " + PlayerFileRec.PlayerName);
Console.WriteLine("File name : " + PlayerFile.FileName);
command.ExecuteNonQuery();
}
return(RedirectToPage("/index"));
}
bool PopulateFiles()
{
files = PlayerFile.GetFiles();
if (files == null || files.Length == 0)
{
return(false);
}
if (fileButtons == null || files.Length > fileButtons.Length)
{
fileButtons = new Button[files.Length];
for (int i = 0; i < files.Length; i++)
{
fileButtons[i] = Instantiate(loadFileButtonPrefab, SavedGamesPanel.transform);
RectTransform rt = fileButtons[i].GetComponent <RectTransform>();
rt.anchorMax = new Vector2(rt.anchorMax.x, rt.anchorMax.y - loadButtonHeightOffset * i);
rt.anchorMin = new Vector2(rt.anchorMin.x, rt.anchorMin.y - loadButtonHeightOffset * i);
fileButtons[i].GetComponentInChildren <Text>().text = files[i].filename;
fileButtons[i].onClick.AddListener(() => LoadFile(i));
}
}
return(true);
}
string GetSyncModelFullPath(StreamKey streamKey, string hash)
{
var downloadFolder = GetSourceProjectFolder(streamKey.source);
var filename = hash + PlayerFile.PersistentKeyToExtension(streamKey.key);
return(Path.Combine(downloadFolder, filename));
}
public void OnGet()
{
DatabaseConnect DBCon = new DatabaseConnect();
SqlConnection conn = new SqlConnection(DBCon.DatabaseString());
conn.Open();
using (SqlCommand command = new SqlCommand())
{
command.Connection = conn;
command.CommandText = @"SELECT * FROM FileTable";
var reader = command.ExecuteReader();
FileRec = new List <PlayerFile>();
while (reader.Read())
{
PlayerFile rec = new PlayerFile();
rec.Id = reader.GetInt32(0); // we need this to send the Id to Delete page for another enquiry
rec.PlayerName = reader.GetString(1);
rec.FileName = reader.GetString(2);
FileRec.Add(rec);
}
}
}
async Task <ISyncModel> AcquireEntryAsync(EntryData entry, CancellationToken token)
{
var fullPath = Path.Combine(ProjectFolder, m_FileOrganization == FileOrganization.OneFolderPerSource ? entry.SourceId : "",
entry.Hash + PlayerFile.PersistentKeyToExtension(entry.IdInSource));
return(await PlayerFile.LoadSyncModelAsync(fullPath, entry.IdInSource, token));
}
public async Task <IEnumerable <SyncManifest> > GetSyncManifestsAsync()
{
var syncManifestPath = Directory.EnumerateFiles(m_DataFolder, "*.manifest").FirstOrDefault();
var syncManifest = await PlayerFile.LoadManifestAsync(syncManifestPath);
return(new [] { syncManifest });
}
public Task <ISyncModel> GetSyncModelAsync(StreamKey streamKey, string hash)
{
// TODO Refactoring.
// var fullPath = PlayerFile.GetFullPath(streamKey, hash);
var downloadFolder = GetSourceProjectFolder(streamKey.source);
var fullPath = GetSyncModelFullPath(streamKey, hash);
return(File.Exists(fullPath) ? PlayerFile.LoadSyncModelAsync(downloadFolder, streamKey.key, hash) : DownloadAndSave(streamKey, hash, fullPath));
}
/// <summary>
/// Read/Writes stats to/from <see cref="File"/> for each <see cref="Player"/> in the <see cref="List{T}"/>
/// </summary>
public void PlayerStatsFileManager(List <Player> playerList, PlayerFile FileOperation = PlayerFile.Read)
{
if (playerList != null && playerList.Count > 0)
{
PlayerStatsFileManager(playerList.Select(p => p.SteamId).ToList(), FileOperation);
}
else
{
PlayerStatsFileManager(FileOperation);
}
}
/// <summary>
/// Read/Writes stats to/from <see cref="File"/> for each UserID in the <see cref="List{T}"/>
/// </summary>
public void PlayerStatsFileManager(List <string> UserIDList, PlayerFile FileOperation = PlayerFile.Read)
{
if (UserIDList != null && UserIDList.Count > 0)
{
PlayerStatsFileManager(UserIDList.ToArray(), FileOperation);
}
else
{
PlayerStatsFileManager(new string[0], FileOperation);
}
}
/// <summary>
/// Gets a raw <see cref="NbtTree"/> of data for the given player.
/// </summary>
/// <param name="name">The name of the player to fetch.</param>
/// <returns>An <see cref="NbtTree"/> containing the given player's raw data.</returns>
/// <exception cref="NbtIOException">Thrown when the manager cannot read in an NBT data stream.</exception>
public NbtTree GetPlayerTree(string name)
{
PlayerFile pf = GetPlayerFile(name);
Stream nbtstr = pf.GetDataInputStream();
if (nbtstr == null)
{
throw new NbtIOException("Failed to initialize NBT data stream for input.");
}
return(new NbtTree(nbtstr));
}
/// <summary>
/// Saves a raw <see cref="NbtTree"/> representing a player to the given player's file.
/// </summary>
/// <param name="name">The name of the player to write data to.</param>
/// <param name="tree">The player's data as an <see cref="NbtTree"/>.</param>
/// <exception cref="NbtIOException">Thrown when the manager cannot initialize an NBT data stream for output.</exception>
public void SetPlayerTree(string name, NbtTree tree)
{
PlayerFile pf = GetPlayerFile(name);
Stream zipstr = pf.GetDataOutputStream();
if (zipstr == null)
{
throw new NbtIOException("Failed to initialize NBT data stream for output.");
}
tree.WriteTo(zipstr);
zipstr.Close();
}
// Undocumented magic method to support nested prefab dependencies. Temporary solution until we get Asset Database V2
static string[] GatherDependenciesFromSourceFile(string assetPath)
{
var syncPrefab = PlayerFile.Load <SyncPrefab>(assetPath);
var paths = new string[syncPrefab.Instances.Count];
var assetName = SanitizeName(syncPrefab.Name);
for (var i = 0; i < syncPrefab.Instances.Count; ++i)
{
paths[i] = GetReferencedAssetPath(assetName, assetPath, syncPrefab.Instances[i].ObjectId.Value);
}
return(paths);
}
/// <summary>
/// Read/Writes stats to/from <see cref="File"/> for each UserID in the <see cref="Array"/>
/// </summary>
public void PlayerStatsFileManager(string[] UserIDArray, PlayerFile FileOperation = PlayerFile.Read)
{
if (!Config.GetBoolValue("admintoolbox_playerfiles", true))
{
return;
}
if (Directory.Exists(MainPath))
{
if (!Directory.Exists(MainPath))
{
Directory.CreateDirectory(MainPath);
}
if (!Directory.Exists(PlayerStatsPath))
{
Directory.CreateDirectory(PlayerStatsPath);
}
ProcessingCollection = true;
if (UserIDArray == null || UserIDArray.Length < 1)
{
UserIDArray = AdminToolbox.ATPlayerDict.Keys.ToArray();
}
foreach (string id in UserIDArray)
{
if (string.IsNullOrEmpty(id))
{
return;
}
if (!AdminToolbox.ATPlayerDict.ContainsKey(id))
{
AddMissingPlayerVariables(Server.GetPlayers(id));
continue;
}
switch (FileOperation)
{
case PlayerFile.Write:
WriteToFile(id);
continue;
case PlayerFile.Read:
default:
ReadFromFile(id);
continue;
}
}
ProcessingCollection = false;
}
}
async Task <ISyncModel> DownloadAndSave(StreamKey streamKey, string hash, string fullPath)
{
var client = m_Listener.client;
var syncModel = await client.GetSyncModelAsync(streamKey.key, streamKey.source, hash);
if (syncModel != null)
{
var directory = Path.GetDirectoryName(fullPath);
Directory.CreateDirectory(directory);
await PlayerFile.SaveAsync(syncModel, fullPath);
}
return(syncModel);
}
async Task DownloadAndSave(EntryData entry, string fullPath, CancellationToken token)
{
// Todo: add cancellationToken
var syncModel = await m_Client.GetSyncModelAsync(new PersistentKey(entry.EntryType, entry.IdInSource), entry.SourceId, entry.Hash);
token.ThrowIfCancellationRequested();
if (syncModel != null)
{
var directory = Path.GetDirectoryName(fullPath);
Directory.CreateDirectory(directory);
await PlayerFile.SaveAsync(syncModel, fullPath);
}
}
public static void AddExtraPairs(PlayerFile __instance, ref SaveFile saveFile)
{
if (HP2SR.AllPairsEnabled.Value && Game.Data.GirlPairs.GetAll().Count < 27)
{
Datamining.ExperimentalAllPairsMod(false);
if (HP2SR.SpecialPairsEnabled.Value)
{
Datamining.ExperimentalAllPairsMod(true);
}
}
if ((!HP2SR.AllPairsEnabled.Value && saveFile.girlPairs.Count >= 27) || (!HP2SR.SpecialPairsEnabled.Value && saveFile.girlPairs.Count >= 69))
{
//fix an allpairs save file before it gets read
if (Game.Data.GirlPairs.Get(saveFile.girlPairId) == null)
{
saveFile.girlPairId = UnityEngine.Random.Range(1, 25);
}
for (int i = saveFile.girlPairs.Count - 1; i >= 0; i--)
{
if (Game.Data.GirlPairs.Get(saveFile.girlPairs[i].girlPairId) == null)
{
saveFile.girlPairs.RemoveAt(i);
}
}
for (int i = saveFile.metGirlPairs.Count - 1; i >= 0; i--)
{
if (Game.Data.GirlPairs.Get(saveFile.metGirlPairs[i]) == null)
{
saveFile.metGirlPairs.RemoveAt(i);
}
}
for (int i = saveFile.completedGirlPairs.Count - 1; i >= 0; i--)
{
if (Game.Data.GirlPairs.Get(saveFile.completedGirlPairs[i]) == null)
{
saveFile.completedGirlPairs.RemoveAt(i);
}
}
for (int i = saveFile.finderSlots.Count - 1; i >= 0; i--)
{
if (Game.Data.GirlPairs.Get(saveFile.finderSlots[i].girlPairId) == null)
{
saveFile.finderSlots[i].girlPairId = 0;
}
}
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
var syncPrefab = PlayerFile.Load <SyncPrefab>(ctx.assetPath);
Init(syncPrefab.Name);
var root = SyncPrefabImporter.Import(syncPrefab, this);
var names = new List <string>();
SetUniqueNameForRoots(root, ref names); // TODO Find a deterministic way to avoid name collisions.
RemapMaterials(root);
ctx.AddObjectToAsset("root", root.gameObject);
ctx.SetMainObject(root.gameObject);
}
public static TagNodeCompound GetPlayerData()
{
if (playerData == null)
{
string path = Path.Combine(savePath, "playerdata");
string[] files = Directory.GetFiles(path);
if (files.Length == 0)
{
throw new Exception("no player data");
}
playerFile = new PlayerFile(files[0]);
playerData = new NbtTree();
playerData.ReadFrom(playerFile.GetDataInputStream());
}
return(playerData.Root);
}
public static PlayerFile LoadFromFile(string fileName)
{
if (File.Exists(Application.persistentDataPath + "/" + fileName))
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream = new FileStream(Application.persistentDataPath + "/testSave.ygs", FileMode.Create);
SerializablePlayerFile serializablePlayerFile = (SerializablePlayerFile)binaryFormatter.Deserialize(fileStream);
fileStream.Close();
PlayerFile playerFile = serializablePlayerFile.ConvertToPlayerFile();
return(playerFile);
}
else
{
return(null);
}
}
public override void OnImportAsset(AssetImportContext ctx)
{
var syncTexture = PlayerFile.Load <SyncTexture>(ctx.assetPath);
var syncedData = new SyncedData <SyncTexture>(StreamKey.FromSyncId <SyncTexture>(ReflectScriptedImporter.EditorSourceId, syncTexture.Id), syncTexture);
var textureImporter = new SyncTextureImporter();
var texture = textureImporter.Import(syncedData, null);
texture.name = Path.GetFileNameWithoutExtension(syncTexture.Name);
ctx.AddObjectToAsset("texture", texture);
var root = ScriptableObject.CreateInstance <ReflectScriptableObject>();
ctx.AddObjectToAsset("root", root, AssetPreview.GetMiniThumbnail(texture));
ctx.SetMainObject(root);
}
async Task <IEnumerable <SyncManifest> > GetSyncManifestsAsync()
{
var result = new List <SyncManifest>();
foreach (var manifestFile in Directory.EnumerateFiles(ProjectFolder, "*.manifest", SearchOption.AllDirectories))
{
if (manifestFile == null)
{
continue;
}
var syncManifest = await PlayerFile.LoadManifestAsync(manifestFile);
result.Add(syncManifest);
}
return(result);
}
public void Reset()
{
_names.Clear();
_curPlayer = null;
string[] files = Directory.GetFiles(_pm._playerPath);
foreach (string file in files)
{
string basename = Path.GetFileName(file);
if (!ParseFileName(basename))
{
continue;
}
_names.Enqueue(PlayerFile.NameFromFilename(basename));
}
}
internal static SyncPrefab GenerateSyncPrefabFromManifest(string name, string rootFolder, SyncManifest manifest)
{
var prefab = new SyncPrefab { Name = name };
var content = manifest.Content;
foreach (var pair in content)
{
if (pair.Key.IsKeyFor<SyncObjectInstance>())
{
// Load SynObjectInstance from disk
var instancePath = Path.Combine(rootFolder, pair.Value.ModelPath);
var objectInstance = PlayerFile.Load<SyncObjectInstance>(instancePath);
objectInstance.Name = Path.GetFileNameWithoutExtension(objectInstance.Name);
prefab.Instances.Add(objectInstance);
}
}
return prefab;
}
public static PlayerFile CreateTestFile()
{
int year = 5;
Seasons season = Seasons.Summer;
int day = 89;
Times time = Times.EarlyMorning;
int timeSegment = 0;
Dictionary <string, WeatherConditions> weather = new Dictionary <string, WeatherConditions>();
string currentInstanceJSONFileName = "00_TEST/Dummy Room/dummy-room_1.json";
Vector3Int playerPosition = new Vector3Int(0, 0, 1);
List <Quest> questProgression = new List <Quest>();
List <PlayerUnit> playerUnits = new List <PlayerUnit>();
List <UnitSetup> unitSetups = new List <UnitSetup>();
string leadUnitJSONFileName = "Sample/Sample Unit/unit.json";
PlayerFile playerFile = new PlayerFile(year, season, day, time, timeSegment, weather, currentInstanceJSONFileName, playerPosition,
playerUnits, questProgression, unitSetups, leadUnitJSONFileName);
return(playerFile);
}
public static PlayerFile CreateNewFile()
{
int year = 1;
Seasons season = Seasons.Spring;
int day = 30;
Times time = Times.Night;
int timeSegment = 0;
Dictionary <string, WeatherConditions> weather = new Dictionary <string, WeatherConditions>();
string currentInstanceJSONFileName = "02_Magicadia/Aristocrat Tree District/Silverlight Forest/silverlight-forest_1.json";
Vector3Int playerPosition = new Vector3Int(0, 0, 1);
List <Quest> questProgression = new List <Quest>();
List <PlayerUnit> playerUnits = new List <PlayerUnit>();
List <UnitSetup> unitSetups = new List <UnitSetup>();
string leadUnitJSONFileName = "Sample/Sample Unit/unit.json";
PlayerFile playerFile = new PlayerFile(year, season, day, time, timeSegment, weather, currentInstanceJSONFileName, playerPosition,
playerUnits, questProgression, unitSetups, leadUnitJSONFileName);
return(playerFile);
}
public override void OnImportAsset(AssetImportContext ctx)
{
var syncMaterial = PlayerFile.Load <SyncMaterial>(ctx.assetPath);
Init(syncMaterial.Name);
var syncedData = new SyncedData <SyncMaterial>(StreamKey.FromSyncId <SyncMaterial>(EditorSourceId, syncMaterial.Id), syncMaterial);
var materialImporter = new SyncMaterialImporter();
var material = materialImporter.Import(syncedData, this);
material.name = Path.GetFileNameWithoutExtension(syncMaterial.Name);
ctx.AddObjectToAsset("material", material);
var root = ScriptableObject.CreateInstance <ReflectScriptableObject>();
ctx.AddObjectToAsset("root", root, AssetPreview.GetMiniThumbnail(material));
ctx.SetMainObject(root);
}
async Task <IEnumerable <SyncManifest> > LoadStreamSourcesAsync(UnityProject project)
{
var folder = m_Storage.GetProjectFolder(project);
var result = new List <SyncManifest>();
foreach (var manifestFile in Directory.EnumerateFiles(folder, "*.manifest", SearchOption.AllDirectories))
{
if (manifestFile == null)
{
continue;
}
var syncManifest = await PlayerFile.LoadManifestAsync(manifestFile);
result.Add(syncManifest);
}
return(result);
}
public override void OnImportAsset(AssetImportContext ctx)
{
var syncMesh = PlayerFile.Load <SyncMesh>(ctx.assetPath);
var syncedData = new SyncedData <SyncMesh>(StreamKey.FromSyncId <SyncMesh>(ReflectScriptedImporter.EditorSourceId, syncMesh.Id), syncMesh);
var meshImporter = new SyncMeshImporter();
var mesh = meshImporter.Import(syncedData, null);
if (m_GenerateLightmapUVs)
{
Unwrapping.GenerateSecondaryUVSet(mesh);
}
mesh.name = Path.GetFileNameWithoutExtension(syncMesh.Name);
ctx.AddObjectToAsset("mesh", mesh);
var root = ScriptableObject.CreateInstance <ReflectScriptableObject>();
ctx.AddObjectToAsset("root", root, AssetPreview.GetMiniThumbnail(mesh));
ctx.SetMainObject(root);
}
