/// <summary>
/// Reads a list of overrides from a content override description file.
/// </summary>
/// <param name="overridesFilePath">
/// The path to the content override description file.
/// </param>
/// <returns>
/// A dictionary mapping level filenames to lists of folder names.
/// </returns>
public static Dictionary<string, List<string>> GetOverridesFromFile(string overridesFilePath)
{
if (!File.Exists(overridesFilePath)) { throw new FileNotFoundException($"Tried to load a content overrides file, but it doesn't exist or the path is invalid. (Path: {overridesFilePath})"); }
Dictionary<string, List<string>> result = new Dictionary<string, List<string>>();
DataReader overrideReader = new DataReader(overridesFilePath);
var overrideSection = overrideReader.ReadFullSection("[Overrides]");
foreach (var overrideLevelEntry in overrideSection)
{
result.Add(overrideLevelEntry.Key, overrideLevelEntry.Value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).ToList());
}
return result;
}
/// <summary>
/// Initializes this class and loads the settings file.
/// </summary>
public static void Initialize()
{
string appDirectory = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
string settingsPath;
#if DEBUG
settingsPath = string.Concat(appDirectory, @"\..\..\..\GameSettings.txt");
#elif !DEBUG
settingsPath = string.Concat(appDirectory, @"\GameSettings.txt");
#endif
if (!File.Exists(settingsPath))
{
throw new FileNotFoundException(string.Format("The settings file at {0} could not be found.", settingsPath));
}
settingsReader = new DataReader(settingsPath);
}
/// <summary>
/// Loads a content package.
/// </summary>
/// <param name="settingsPath">
/// The path to the settings file for this package.
/// </param>
internal void Load(string settingsPath)
{
if (!isLoaded)
{
if (!File.Exists(settingsPath))
{
throw new FileNotFoundException(string.Format("The settings file at {0} does not exist.", settingsPath));
}
settingsFilePath = settingsPath;
Dictionary<string, string> settings = new DataReader(settingsPath).ReadFullSection("[ContentPackage]");
Name = settings["Name"];
Author = settings["Author"];
BaseFolderPath = string.Concat(new FileInfo(settingsPath).DirectoryName, @"\");
AssemblyPath = string.Concat(BaseFolderPath, settings["AssemblyPath"]);
// Sanity check - let's make sure the assembly path is right.
if (!File.Exists(AssemblyPath) || !AssemblyPath.EndsWith(".dll"))
{
throw new FileNotFoundException(string.Format("The assembly file at {0} does not exist. Please check the settings file at {1}.", AssemblyPath, settingsPath));
}
// Now load the assembly.
AssemblyManager.LoadAssembly(AssemblyPath);
isLoaded = true;
}
}
/// <summary>
/// Loads a ComplexGraphicsObject.
/// </summary>
/// <param name="filePath">The file path to the image.</param>
/// <param name="config">
/// A DataReader containing the configuration file for this object.
/// </param>
public void Load(string filePath, DataReader config)
{
if (!isLoaded)
{
FilePath = filePath;
configFilePath = config.FilePath;
if (!(config[0] == "[Complex]"))
{
throw new FormatException("ComplexGraphicsObject.Load(string, DataReader): Invalid or corrupt configuration file.");
}
var settings = config.ReadFullSection("[Complex]");
int totalGraphicsObjects;
string startingObject;
FrameSize = Vector2Extensions.Parse(settings["FrameSize"]);
if (!int.TryParse(settings["TotalGraphicsObjects"], out totalGraphicsObjects))
{
throw new FormatException(string.Format("ComplexGraphicsObject.Load(string, DataReader): Invalid number of graphics objects specified. Got {0}.", settings["TotalGraphicsObjects"]));
}
startingObject = settings["StartingObject"];
for (int i = 0; i < totalGraphicsObjects; i++)
{
string objectHeader = string.Concat("[Object", i, "]");
var objectData = config.ReadFullSection(objectHeader);
string name = objectData["Name"];
string type = objectData["Type"];
switch (type)
{
case "static":
StaticGraphicsObject staticObject = new StaticGraphicsObject();
staticObject.Load(objectData, this);
graphicsObjects.Add(name, staticObject);
break;
case "animated":
AnimatedGraphicsObject animatedObject = new AnimatedGraphicsObject();
animatedObject.Load(objectData, this);
graphicsObjects.Add(name, animatedObject);
break;
case "animated_runonce":
AnimatedGraphicsObject animatedRunOnceObject = new AnimatedGraphicsObject();
animatedRunOnceObject.Load(objectData, this);
animatedRunOnceObject.IsRunOnce = true;
graphicsObjects.Add(name, animatedRunOnceObject);
break;
default:
break;
}
}
CurrentObjectName = startingObject;
isLoaded = true;
}
}
/// <summary>
/// Loads an instance of IGraphicsObject from a given file path. If a
/// text file with the same name is in the same folder, that will be
/// used to determine what kind of graphics object it is. If no text
/// file is present, the object is assumed to be static. Otherwise, the
/// type (animated, complex) depends on what the first line of the file is.
/// </summary>
/// <param name="filePath">
/// The path to the image of the graphics object.
/// </param>
/// <returns>A loaded IGraphicsObject instance.</returns>
public static IGraphicsObject LoadGraphicsObject(string filePath)
{
if (!loadedObjects.ContainsKey(filePath))
{
// We'll assume we have the right path (considering graphics overrides).
string fileNameWithoutExt = Path.GetFileNameWithoutExtension(filePath);
string directoryName = new FileInfo(filePath).DirectoryName;
string configPath = Path.Combine(directoryName, string.Concat(fileNameWithoutExt, ".txt"));
if (!File.Exists(configPath))
{
// No configuration, so the object is probably static
var result = new StaticGraphicsObject();
result.Load(filePath);
loadedObjects.Add(filePath, result);
return result;
}
else
{
// A configuration! Let's read it to find out what it is.
DataReader config = new DataReader(configPath);
if (config[0] == "[Animated]" || config[0] == "[Animated_RunOnce]")
{
var result = new AnimatedGraphicsObject();
result.Load(filePath, config);
loadedObjects.Add(filePath, result);
return result;
}
else if (config[0] == "[Complex]")
{
var result = new ComplexGraphicsObject();
result.Load(filePath, config);
loadedObjects.Add(filePath, result);
return result;
}
}
}
else
{
return loadedObjects[filePath].Clone();
}
return null;
}
/// <summary>
/// Loads an instance of an AnimatedGraphicsObject.
/// </summary>
/// <param name="filePath">The file path to the image to use.</param>
/// <param name="config">
/// A DataReader containing the configuration for this file.
/// </param>
public void Load(string filePath, DataReader config)
{
if (!isLoaded)
{
this.filePath = filePath;
configFilePath = config.FilePath;
if (config[0] != "[Animated]" && config[0] != "[Animated_RunOnce]")
{
throw new InvalidDataException(string.Format("AnimatedGraphicsObject.Load(string, DataReader): Invalid or corrupt configuration data (expected header [Animated] or [Animated_RunOnce], got header {0})", config[0]));
}
Dictionary<string, string> data;
if (config[0] == "[Animated]")
{
data = config.ReadFullSection("[Animated]");
}
else
{
data = config.ReadFullSection("[Animated_RunOnce]");
IsRunOnce = true;
}
frameWidth = int.Parse(data["FrameWidth"]);
AnimationCycleLength = decimal.Parse(data["CycleLength"]);
isLoaded = true;
}
}