private void loadAssest(ModData currentMod)
{
if (currentMod != null)
{
var fileSystem = new VirtualFileSystem();
foreach (var asset in currentMod.Manifest.Asset.Assets)
{
string assetFullPath = Path.Combine(Environment.CurrentDirectory, "Mods/" + currentMod.ID, asset);
fileSystem.Add(new FolderFileSystem(assetFullPath));
foreach (var file in fileSystem.GetFiles())
{
if (file.EndsWith(".RFH", StringComparison.OrdinalIgnoreCase))
{
fileSystem.Add(new RfhFileSystem(new Rfh(fileSystem.Read(file) !, fileSystem.Read(file.Substring(0, file.Length - 1) + "D") !)));
}
else if (file.EndsWith(".BAG", StringComparison.OrdinalIgnoreCase))
{
fileSystem.Add(new BagFileSystem(new Bag(fileSystem.Read(file) !)));
}
}
}
assetManager = new AssetManager(fileSystem);
}
}
public bool Initialize()
{
Logger.Info("Initializing theater of type {0}", _theaterType);
if (!_config.SetActiveTheater(_theaterType))
{
return(false);
}
Active = this;
// load palettes and additional mix files for this theater
_palettes = new PaletteCollection(_vfs);
_palettes.IsoPalette = new Palette(_vfs.Open <PalFile>(ModConfig.ActiveTheater.IsoPaletteName));
_palettes.OvlPalette = new Palette(_vfs.Open <PalFile>(ModConfig.ActiveTheater.OverlayPaletteName));
_palettes.UnitPalette = new Palette(_vfs.Open <PalFile>(ModConfig.ActiveTheater.UnitPaletteName), ModConfig.ActiveTheater.UnitPaletteName, true);
foreach (string mix in ModConfig.ActiveTheater.Mixes)
{
_vfs.Add(mix, CacheMethod.Cache); // we wish for these to be cached as they're gonna be hit often
}
_palettes.AnimPalette = new Palette(_vfs.Open <PalFile>("anim.pal"));
_animations = new ObjectCollection(CollectionType.Animation, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("Animations"), _palettes);
_tileTypes = new TileCollection(_theaterType, _config, _vfs, _rules, _art, ModConfig.ActiveTheater);
_buildingTypes = new ObjectCollection(CollectionType.Building, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("BuildingTypes"), _palettes);
_aircraftTypes = new ObjectCollection(CollectionType.Aircraft, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("AircraftTypes"), _palettes);
_infantryTypes = new ObjectCollection(CollectionType.Infantry, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("InfantryTypes"), _palettes);
_overlayTypes = new ObjectCollection(CollectionType.Overlay, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("OverlayTypes"), _palettes);
_terrainTypes = new ObjectCollection(CollectionType.Terrain, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("TerrainTypes"), _palettes);
_smudgeTypes = new ObjectCollection(CollectionType.Smudge, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("SmudgeTypes"), _palettes);
_vehicleTypes = new ObjectCollection(CollectionType.Vehicle, _theaterType, _config, _vfs, _rules, _art,
_rules.GetSection("VehicleTypes"), _palettes);
_tileTypes.InitTilesets();
_tileTypes.InitAnimations(_animations);
return(true);
}
private void starButton4_ClickButton(object sender, EventArgs e)
{
var res = BrowseSave.ShowDialog();
if (res != DialogResult.OK)
{
return;
}
VirtualFileSystem nfs = new VirtualFileSystem();
foreach (var f in Files)
{
nfs.Add(f.FullPath);
}
var com = CompressCheck.CheckState == CheckState.Checked ? true : false;
nfs.Save(BrowseSave.FileName, com);
}
protected override void OnLoad()
{
GL.ClearColor(0, 0, 0, 1);
GL.Enable(EnableCap.DepthTest);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
var fileSystem = new VirtualFileSystem();
fileSystem.Add(new FolderFileSystem("C:/Westwood/Emperor"));
foreach (var file in fileSystem.GetFiles())
{
if (file.EndsWith(".RFH", StringComparison.OrdinalIgnoreCase))
{
fileSystem.Add(new RfhFileSystem(new Rfh(fileSystem.Read(file) !, fileSystem.Read(file.Substring(0, file.Length - 1) + "D") !)));
}
else if (file.EndsWith(".BAG", StringComparison.OrdinalIgnoreCase))
{
fileSystem.Add(new BagFileSystem(new Bag(fileSystem.Read(file) !)));
}
}
this.assetManager = new AssetManager(fileSystem);
this.models = new List <string>();
foreach (var file in fileSystem.GetFiles())
{
if (file.EndsWith(".XBF", StringComparison.OrdinalIgnoreCase))
{
this.models.Add(file);
}
}
this.camera = new PerspectiveCamera
{
Size = new Vector2(this.Size.X, this.Size.Y), Direction = new Vector3(0, -1, 1).Normalized(), Position = new Vector3(0, 1, -1) * 128
};
}
public EngineResult Execute()
{
try {
_logger.Info("Initializing virtual filesystem");
var mapStream = File.Open(_settings.InputFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
VirtualFile vmapFile;
var mixMap = new MixFile(mapStream, _settings.InputFile, 0, mapStream.Length, false, false);
if (mixMap.IsValid()) // input max is a mix
{
var mapArchive = new MixFile(mapStream, Path.GetFileName(_settings.InputFile), true);
// grab the largest file in the archive
var mixEntry = mapArchive.Index.OrderByDescending(me => me.Value.Length).First();
vmapFile = mapArchive.OpenFile(mixEntry.Key);
}
else
{
vmapFile = new VirtualFile(mapStream, Path.GetFileName(_settings.InputFile), true);
}
var mapFile = new MapFile(vmapFile, Path.GetFileName(_settings.InputFile));
ModConfig modConfig = null;
if (!string.IsNullOrEmpty(_settings.ModConfig))
{
if (File.Exists(_settings.ModConfig))
{
try {
using (FileStream f = File.OpenRead(_settings.ModConfig))
modConfig = ModConfig.Deserialize(f);
}
catch (IOException) {
_logger.Fatal("IOException while loading mod config");
}
catch (XmlException) {
_logger.Fatal("XmlException while loading mod config");
}
catch (SerializationException) {
_logger.Fatal("Serialization exception while loading mod config");
}
}
else
{
_logger.Fatal("Invalid mod config file specified");
}
}
if (_settings.Engine == EngineType.AutoDetect)
{
_settings.Engine = EngineDetector.DetectEngineType(mapFile);
_logger.Info("Engine autodetect result: {0}", _settings.Engine);
}
// Engine type is now definitive, load mod config
if (modConfig == null)
{
modConfig = ModConfig.GetDefaultConfig(_settings.Engine);
}
var map = new Map.Map {
IgnoreLighting = _settings.IgnoreLighting,
StartPosMarking = _settings.StartPositionMarking,
StartMarkerSize = _settings.MarkerStartSize,
MarkOreFields = _settings.MarkOreFields
};
using (var vfs = new VirtualFileSystem()) {
// first add the dirs, then load the extra mixes, then scan the dirs
foreach (string modDir in modConfig.Directories)
{
vfs.Add(modDir);
}
// add mixdir to VFS (if it's not included in the mod config)
if (!modConfig.Directories.Any())
{
string mixDir =
VirtualFileSystem.DetermineMixDir(_settings.MixFilesDirectory, _settings.Engine);
vfs.Add(mixDir);
}
foreach (string mixFile in modConfig.ExtraMixes)
{
vfs.Add(mixFile);
}
vfs.LoadMixes(_settings.Engine);
if (!map.Initialize(mapFile, modConfig, vfs))
{
_logger.Error("Could not successfully load this map. Try specifying the engine type manually.");
return(EngineResult.LoadRulesFailed);
}
if (!map.LoadTheater())
{
_logger.Error("Could not successfully load all required components for this map. Aborting.");
return(EngineResult.LoadTheaterFailed);
}
if (_settings.MarkStartPos && _settings.StartPositionMarking == StartPositionMarking.Tiled)
{
map.MarkTiledStartPositions();
}
if (_settings.MarkOreFields)
{
map.MarkOreAndGems();
}
if ((_settings.GeneratePreviewPack || _settings.FixupTiles || _settings.FixOverlays ||
_settings.CompressTiles) && _settings.Backup)
{
if (mapFile.BaseStream is MixFile)
{
_logger.Error("Cannot generate a map file backup into an archive (.mmx/.yro/.mix)!");
}
else
{
try {
string timestamp = DateTime.Now.ToString("yyyyMMddHHmmss");
string fileInput = Path.Combine(Path.GetDirectoryName(_settings.InputFile),
Path.GetFileName(_settings.InputFile));
fileInput = fileInput.TrimEnd(Path.DirectorySeparatorChar,
Path.AltDirectorySeparatorChar);
string fileInputNoExtn = Path.Combine(Path.GetDirectoryName(_settings.InputFile),
Path.GetFileNameWithoutExtension(_settings.InputFile));
fileInputNoExtn = fileInputNoExtn.TrimEnd(Path.DirectorySeparatorChar,
Path.AltDirectorySeparatorChar);
string fileBackup = fileInputNoExtn + "_" + timestamp + ".bkp";
File.Copy(fileInput, fileBackup, true);
_logger.Info("Creating map backup: " + fileBackup);
}
catch (Exception) {
_logger.Error("Unable to generate a map file backup!");
}
}
}
if (_settings.FixupTiles)
{
map.FixupTileLayer();
}
map.Draw();
if (_settings.MarkIceGrowth)
{
map.MarkIceGrowth();
}
if (_settings.TunnelPaths)
{
map.PlotTunnels(_settings.TunnelPosition);
}
if (_settings.MarkStartPos && (_settings.StartPositionMarking == StartPositionMarking.Squared ||
_settings.StartPositionMarking == StartPositionMarking.Circled ||
_settings.StartPositionMarking == StartPositionMarking.Diamond ||
_settings.StartPositionMarking == StartPositionMarking.Ellipsed ||
_settings.StartPositionMarking == StartPositionMarking.Starred))
{
map.DrawStartPositions();
}
if (_settings.OutputFile == "")
{
_settings.OutputFile = DetermineMapName(mapFile, _settings.Engine, vfs);
}
if (_settings.OutputDir == "")
{
_settings.OutputDir = Path.GetDirectoryName(_settings.InputFile);
}
if (_settings.DiagnosticWindow)
{
using (var form = new DebugDrawingSurfaceWindow(map.GetDrawingSurface(), map.GetTiles(),
map.GetTheater(), map)) {
form.RequestTileEvaluate += map.DebugDrawTile;
form.ShowDialog();
}
}
} // VFS resources can now be released
// free up as much memory as possible before saving the large images
Rectangle saveRect = map.GetSizePixels(_settings.SizeMode);
DrawingSurface ds = map.GetDrawingSurface();
saveRect.Intersect(new Rectangle(0, 0, ds.Width, ds.Height));
// if we don't need this data anymore, we can try to save some memory
if (!_settings.GeneratePreviewPack)
{
ds.FreeNonBitmap();
map.FreeUseless();
GC.Collect();
}
if (_settings.SaveJPEG)
{
ds.SaveJPEG(Path.Combine(_settings.OutputDir, _settings.OutputFile + ".jpg"),
_settings.JPEGCompression, saveRect);
}
if (_settings.SavePNG)
{
ds.SavePNG(Path.Combine(_settings.OutputDir, _settings.OutputFile + ".png"),
_settings.PNGQuality, saveRect);
}
Regex reThumb = new Regex(@"(\+|)?\((\d+),(\d+)\)");
var match = reThumb.Match(_settings.ThumbnailConfig);
if (match.Success)
{
Size dimensions = new Size(
int.Parse(match.Groups[2].Captures[0].Value),
int.Parse(match.Groups[3].Captures[0].Value));
var cutRect = map.GetSizePixels(_settings.SizeMode);
if (match.Groups[1].Captures[0].Value == "+")
{
// + means maintain aspect ratio
if (dimensions.Width > 0 && dimensions.Height > 0)
{
float scaleHeight = (float)dimensions.Height / (float)cutRect.Height;
float scaleWidth = (float)dimensions.Width / (float)cutRect.Width;
float scale = Math.Min(scaleHeight, scaleWidth);
dimensions.Width = Math.Max((int)(cutRect.Width * scale), 1);
dimensions.Height = Math.Max((int)(cutRect.Height * scale), 1);
}
else
{
double aspectRatio = cutRect.Width / (double)cutRect.Height;
if (dimensions.Width / (double)dimensions.Height > aspectRatio)
{
dimensions.Height = (int)(dimensions.Width / aspectRatio);
}
else
{
dimensions.Width = (int)(dimensions.Height * aspectRatio);
}
}
}
_logger.Info("Saving thumbnail with dimensions {0}x{1}", dimensions.Width, dimensions.Height);
if (!_settings.SavePNGThumbnails)
{
ds.SaveThumb(dimensions, cutRect,
Path.Combine(_settings.OutputDir, "thumb_" + _settings.OutputFile + ".jpg"));
}
else
{
ds.SaveThumb(dimensions, cutRect,
Path.Combine(_settings.OutputDir, "thumb_" + _settings.OutputFile + ".png"), true);
}
}
if (_settings.GeneratePreviewPack || _settings.FixupTiles || _settings.FixOverlays ||
_settings.CompressTiles)
{
if (mapFile.BaseStream is MixFile)
{
_logger.Error(
"Cannot fix tile layer or inject thumbnail into an archive (.mmx/.yro/.mix)!");
}
else
{
if (_settings.GeneratePreviewPack)
{
map.GeneratePreviewPack(_settings.PreviewMarkers, _settings.SizeMode, mapFile,
_settings.FixPreviewDimensions);
}
if (_settings.FixOverlays)
{
map.FixupOverlays(); // fixing is done earlier, it now creates overlay and its data pack
}
// Keep this last in tiles manipulation
if (_settings.CompressTiles)
{
map.CompressIsoMapPack5();
}
_logger.Info("Saving map to " + _settings.InputFile);
mapFile.Save(_settings.InputFile);
}
}
}
catch (Exception exc) {
_logger.Error(string.Format("An unknown fatal exception occurred: {0}", exc), exc);
#if DEBUG
throw;
#endif
return(EngineResult.Exception);
}
return(EngineResult.RenderedOk);
}
private void starButton2_ClickButton(object sender, EventArgs e)
{
Random r = new Random(int.Parse(SeedBox.Text));
int uw = 2048;
int uh = 2048;
int pg = (uw + uh) / 120;
int numgal = r.Next(pg / 2, pg);
var uniscene = new SceneGraph();
uniscene.Root.Name = "Universe Root";
int bs = r.Next(100, 200);
var ul = new GraphLight();
ul.Name = "Universe Light 1";
ul.Range = 3000;
ul.Diffuse = new OpenTK.Vector3(3, 3, 3);
uniscene.Add(ul);
for (int i = 0; i < bs; i++)
{
int x = r.Next(-uw / 2, uw / 2);
int y = r.Next(-uh / 2, uh / 2);
var sn = new GraphNode();
sn.X = x;
sn.Y = y;
sn.Rot = r.Next(0, 360);
sn.Z = 0.1f + (float)r.NextDouble() * 1.2f;
sn.Name = "BgStar" + i.ToString();
sn.ImgFrame = BgStarImg[r.Next(0, BgStarImg.Length - 1)];
uniscene.Root.Nodes.Add(sn);
sn.Root = uniscene.Root;
sn.Graph = uniscene;
}
for (int i = 0; i < numgal; i++)
{
int x = r.Next(-uw / 2, uw / 2);
int y = r.Next(-uh / 2, uh / 2);
var gn = new GraphNode();
gn.X = x;
gn.Y = y;
gn.Z = 0.3f + (float)r.NextDouble() * 1.5f;
gn.Rot = r.Next(0, 360);
gn.Name = "Galaxy:" + i;
gn.ImgFrame = GalImg[r.Next(0, GalImg.Length - 1)];
uniscene.Root.Nodes.Add(gn);
gn.Root = uniscene.Root;
gn.Graph = uniscene;
}
if (new FileInfo("Data/Uni/UniGraph.graph").Exists)
{
File.Delete("Data/Uni/UniGraph.graph");
}
var ufs = new VirtualFileSystem();
ufs.Add(uniscene);
ufs.Save("Data/Uni/UniGraph", true);
Console.WriteLine("Wrote unifs");
//uniscene.Save("Data/Uni/UniGraph.graph");
Console.WriteLine("Universed created and saved.");
}
