public MountResult MountFiles(MissionSourceInfo srcInfo)
{
// load map file into memory
MapFile mapf = new MapFile();
if (srcInfo.Map == null)
{
return(new MountResult(MountErrorType.MAP_UNDEFINED, Resource.Strings.MountError_MAP_UNDEFINED));
}
if (!File.Exists(srcInfo.Map))
{
return(new MountResult(MountErrorType.MAP_NOTFOUND, Resource.Strings.MountError_MAP_NOTFOUND.F(srcInfo.Map)));
}
try
{
mapf.ReadFromFile(srcInfo.Map);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.MAP_READ_ERROR, Resource.Strings.MountError_MAP_READ_ERROR, ex));
}
// load mis file into memory
MisFile misf = new MisFile();
if (srcInfo.Mis == null)
{
return(new MountResult(MountErrorType.MIS_UNDEFINED, Resource.Strings.MountError_MIS_UNDEFINED));
}
if (!File.Exists(srcInfo.Mis))
{
return(new MountResult(MountErrorType.MIS_NOTFOUND, Resource.Strings.MountError_MIS_NOTFOUND.F(srcInfo.Mis)));
}
try
{
misf.ReadFromFile(srcInfo.Mis);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.MIS_READ_ERROR, Resource.Strings.MountError_MIS_READ_ERROR, ex));
}
// load (optional) rules file into memory
MapRulesFile rulf = new MapRulesFile();
if (srcInfo.Rules != null)
{
if (!File.Exists(srcInfo.Rules))
{
return(new MountResult(MountErrorType.RULES_NOTFOUND, Resource.Strings.MountError_RULES_NOTFOUND.F(srcInfo.Rules)));
}
try
{
rulf.ReadFromFile(srcInfo.Rules);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.RULES_READ_ERROR, Resource.Strings.MountError_RULES_READ_ERROR, ex));
}
}
// load (optional) mod file into memory
if (srcInfo.Mod != null)
{
if (!File.Exists(srcInfo.Mod))
{
return(new MountResult(MountErrorType.MOD_NOTFOUND, Resource.Strings.MountError_MOD_NOTFOUND.F(srcInfo.Mod)));
}
ModFile modf = new ModFile();
try
{
modf.ReadFromFile(srcInfo.Mod);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.MOD_READ_ERROR, Resource.Strings.MountError_MOD_READ_ERROR, ex));
}
// apply mod
try
{
Mod mod = modf.CreateMod();
mod.Apply(ref mapf, ref misf);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.MOD_ERROR, Resource.Strings.MountError_MOD_ERROR, ex));
}
}
// define target paths
string mapPath = MAPFILE_FORMAT.F(MissionDir, RESERVED_MISSION_NAME);
string misPath = MISFILE_FORMAT.F(MissionDir, RESERVED_MISSION_NAME);
string rulPath = RULESFILE_FORMAT.F(MissionDir, RESERVED_MISSION_NAME);
// write map
try
{
mapf.WriteToFile(mapPath);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.MAP_WRITE_ERROR, Resource.Strings.MountError_MAP_WRITE_ERROR, ex));
}
// write mis
try
{
misf.WriteToFile(misPath);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.MIS_WRITE_ERROR, Resource.Strings.MountError_MIS_WRITE_ERROR, ex));
}
// write rules, if defined
if (srcInfo.Rules != null)
{
try
{
rulf.WriteToFile(rulPath);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.RULES_WRITE_ERROR, Resource.Strings.MountError_RULES_WRITE_ERROR, ex));
}
}
return(new MountResult(MountErrorType.SUCCESS));
}
public MountResult ImportMissions <T>(string directoryPath, out Registry <T, MissionSet[]> sortedMissions, Func <MissionSet, T> filter)
{
sortedMissions = new Registry <T, MissionSet[]>();
Registry <T, List <MissionSet> > temp = new Registry <T, List <MissionSet> >();
if (directoryPath == null || !Directory.Exists(directoryPath) || File.Exists(directoryPath))
{
return(new MountResult(MountErrorType.INVALID_DIRECTORY, Resource.Strings.MountError_INVALID_DIRECTORY.F(directoryPath)));
}
List <string> errorList = new List <string>();
foreach (string p in Directory.GetFiles(directoryPath, "*" + RULESFILE_EXT, SearchOption.AllDirectories))
{
try
{
string dir = Path.GetDirectoryName(p);
string name = Path.GetFileNameWithoutExtension(p);
string sMap = MAPFILE_FORMAT.F(dir, name);
string sMis = MISFILE_FORMAT.F(dir, name);
string sMod = MODFILE_FORMAT.F(dir, name);
// Ignore the set if either the map or the mis file does not exist
if (!File.Exists(sMap) || !File.Exists(sMis))
{
continue;
}
// The mod file is optional, exclude it if not present
if (!File.Exists(sMod))
{
sMod = null;
}
MissionSourceInfo srcInfo = new MissionSourceInfo(sMap, sMis, p, sMod);
// load rules file into memory (if some error occurs, ignore this set)
MapRulesFile rulf = new MapRulesFile();
try
{
rulf.ReadFromFile(p);
MissionInfo misInfo = rulf.RetrieveInfo();
MissionSet set = new MissionSet(misInfo, srcInfo);
T t = filter(set);
if (t != null)
{
if (temp.Contains(t))
{
temp[t].Add(set);
}
else
{
temp.Add(t, new List <MissionSet> {
set
});
}
}
}
catch
{
errorList.Add(p);
continue;
}
}
catch
{
errorList.Add(p);
continue;
}
}
foreach (T t in temp.GetKeys())
{
sortedMissions.Put(t, temp[t].ToArray());
}
if (errorList.Count > 0)
{
return(new MountResult(MountErrorType.PARTIAL_ERROR, Resource.Strings.MountError_PARTIAL_ERROR.F(errorList.Count)));
}
return(new MountResult(MountErrorType.SUCCESS));
}
