mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-05-05 21:02:33 +12:00
1774 lines
78 KiB
C#
1774 lines
78 KiB
C#
//
|
|
// Copyright 2020 Electronic Arts Inc.
|
|
//
|
|
// The Command & Conquer Map Editor and corresponding source code is free
|
|
// software: you can redistribute it and/or modify it under the terms of
|
|
// the GNU General Public License as published by the Free Software Foundation,
|
|
// either version 3 of the License, or (at your option) any later version.
|
|
|
|
// The Command & Conquer Map Editor and corresponding source code is distributed
|
|
// in the hope that it will be useful, but with permitted additional restrictions
|
|
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
|
|
// distributed with this program. You should have received a copy of the
|
|
// GNU General Public License along with permitted additional restrictions
|
|
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
|
|
using MobiusEditor.Interface;
|
|
using MobiusEditor.Model;
|
|
using MobiusEditor.Utility;
|
|
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Drawing;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
|
|
namespace MobiusEditor.RedAlert
|
|
{
|
|
class GamePlugin : IGamePlugin
|
|
{
|
|
private static readonly IEnumerable<string> movieTypes = new string[]
|
|
{
|
|
"x",
|
|
"AAGUN",
|
|
"AFTRMATH",
|
|
"AIRFIELD",
|
|
"ALLIEND",
|
|
"ALLY1",
|
|
"ALLY10",
|
|
"ALLY10B",
|
|
"ALLY11",
|
|
"ALLY12",
|
|
"ALLY14",
|
|
"ALLY2",
|
|
"ALLY4",
|
|
"ALLY5",
|
|
"ALLY6",
|
|
"ALLY8",
|
|
"ALLY9",
|
|
"ALLYMORF",
|
|
"ANTEND",
|
|
"ANTINTRO",
|
|
"APCESCPE",
|
|
"ASSESS",
|
|
"AVERTED",
|
|
"BATTLE",
|
|
"BEACHEAD",
|
|
"BINOC",
|
|
"BMAP",
|
|
"BOMBRUN",
|
|
"BRDGTILT",
|
|
"COUNTDWN",
|
|
"CRONFAIL",
|
|
"CRONTEST",
|
|
"DESTROYR",
|
|
"DOUBLE",
|
|
"DPTHCHRG",
|
|
"DUD",
|
|
"ELEVATOR",
|
|
"ENGLISH",
|
|
"EXECUTE",
|
|
"FLARE",
|
|
"FROZEN",
|
|
"GRVESTNE",
|
|
"LANDING",
|
|
"MASASSLT",
|
|
"MCV",
|
|
"MCVBRDGE",
|
|
"MCV_LAND",
|
|
"MIG",
|
|
"MONTPASS",
|
|
"MOVINGIN",
|
|
"MTNKFACT",
|
|
"NUKESTOK",
|
|
"OILDRUM",
|
|
"ONTHPRWL",
|
|
"OVERRUN",
|
|
"PERISCOP",
|
|
"PROLOG",
|
|
"RADRRAID",
|
|
"REDINTRO",
|
|
"RETALIATION_ALLIED1",
|
|
"RETALIATION_ALLIED10",
|
|
"RETALIATION_ALLIED2",
|
|
"RETALIATION_ALLIED3",
|
|
"RETALIATION_ALLIED4",
|
|
"RETALIATION_ALLIED5",
|
|
"RETALIATION_ALLIED6",
|
|
"RETALIATION_ALLIED7",
|
|
"RETALIATION_ALLIED8",
|
|
"RETALIATION_ALLIED9",
|
|
"RETALIATION_ANTS",
|
|
"RETALIATION_SOVIET1",
|
|
"RETALIATION_SOVIET10",
|
|
"RETALIATION_SOVIET2",
|
|
"RETALIATION_SOVIET3",
|
|
"RETALIATION_SOVIET4",
|
|
"RETALIATION_SOVIET5",
|
|
"RETALIATION_SOVIET6",
|
|
"RETALIATION_SOVIET7",
|
|
"RETALIATION_SOVIET8",
|
|
"RETALIATION_SOVIET9",
|
|
"RETALIATION_WINA",
|
|
"RETALIATION_WINS",
|
|
"SEARCH",
|
|
"SFROZEN",
|
|
"SHIPSINK",
|
|
"SHIPYARD", // MISSING
|
|
"SHORBOM1",
|
|
"SHORBOM2",
|
|
"SHORBOMB",
|
|
"SITDUCK",
|
|
"SIZZLE", //MISSING
|
|
"SIZZLE2", //MISSING
|
|
"SLNTSRVC",
|
|
"SNOWBASE",
|
|
"SNOWBOMB",
|
|
"SNSTRAFE",
|
|
"SOVBATL",
|
|
"SOVCEMET",
|
|
"SOVFINAL",
|
|
"SOVIET1",
|
|
"SOVIET10",
|
|
"SOVIET11",
|
|
"SOVIET12",
|
|
"SOVIET13",
|
|
"SOVIET14",
|
|
"SOVIET2",
|
|
"SOVIET3",
|
|
"SOVIET4",
|
|
"SOVIET5",
|
|
"SOVIET6",
|
|
"SOVIET7",
|
|
"SOVIET8",
|
|
"SOVIET9",
|
|
"SOVMCV",
|
|
"SOVTSTAR",
|
|
"SPOTTER",
|
|
"SPY",
|
|
"STRAFE",
|
|
"TAKE_OFF",
|
|
"TANYA1",
|
|
"TANYA2",
|
|
"TESLA",
|
|
"TOOFAR",
|
|
"TRINITY",
|
|
"V2ROCKET",
|
|
};
|
|
|
|
private static readonly IEnumerable<ITechnoType> technoTypes;
|
|
|
|
public GameType GameType => GameType.RedAlert;
|
|
|
|
public Map Map { get; }
|
|
|
|
public Image MapImage { get; private set; }
|
|
|
|
public bool Dirty { get; set; }
|
|
|
|
private INISectionCollection extraSections;
|
|
|
|
static GamePlugin()
|
|
{
|
|
technoTypes = InfantryTypes.GetTypes().Cast<ITechnoType>().Concat(UnitTypes.GetTypes().Cast<ITechnoType>());
|
|
}
|
|
|
|
public GamePlugin(bool mapImage)
|
|
{
|
|
var playerWaypoints = Enumerable.Range(0, 8).Select(i => new Waypoint(string.Format("P{0}", i), WaypointFlag.PlayerStart));
|
|
var generalWaypoints = Enumerable.Range(8, 90).Select(i => new Waypoint(i.ToString()));
|
|
var specialWaypoints = new Waypoint[] { new Waypoint("Home"), new Waypoint("Reinf."), new Waypoint("Special") };
|
|
var waypoints = playerWaypoints.Concat(generalWaypoints).Concat(specialWaypoints);
|
|
|
|
var basicSection = new BasicSection();
|
|
basicSection.SetDefault();
|
|
|
|
var houseTypes = HouseTypes.GetTypes();
|
|
basicSection.Player = houseTypes.First().Name;
|
|
|
|
Map = new Map(basicSection, null, Constants.MaxSize, typeof(House),
|
|
houseTypes, TheaterTypes.GetTypes(), TemplateTypes.GetTypes(), TerrainTypes.GetTypes(),
|
|
OverlayTypes.GetTypes(), SmudgeTypes.GetTypes(), EventTypes.GetTypes(), ActionTypes.GetTypes(),
|
|
MissionTypes.GetTypes(), DirectionTypes.GetTypes(), InfantryTypes.GetTypes(), UnitTypes.GetTypes(),
|
|
BuildingTypes.GetTypes(), TeamMissionTypes.GetTypes(), waypoints, movieTypes)
|
|
{
|
|
TiberiumOrGoldValue = 35,
|
|
GemValue = 110
|
|
};
|
|
|
|
Map.BasicSection.PropertyChanged += BasicSection_PropertyChanged;
|
|
Map.MapSection.PropertyChanged += MapSection_PropertyChanged;
|
|
|
|
if (mapImage)
|
|
{
|
|
MapImage = new Bitmap(Map.Metrics.Width * Globals.TileWidth, Map.Metrics.Height * Globals.TileHeight);
|
|
}
|
|
}
|
|
|
|
public GamePlugin()
|
|
: this(true)
|
|
{
|
|
}
|
|
|
|
public void New(string theater)
|
|
{
|
|
Map.Theater = Map.TheaterTypes.Where(t => t.Equals(theater)).FirstOrDefault() ?? TheaterTypes.Temperate;
|
|
Map.TopLeft = new Point(1, 1);
|
|
Map.Size = Map.Metrics.Size - new Size(2, 2);
|
|
|
|
UpdateBasePlayerHouse();
|
|
|
|
Dirty = true;
|
|
}
|
|
|
|
public IEnumerable<string> Load(string path, FileType fileType)
|
|
{
|
|
var errors = new List<string>();
|
|
|
|
switch (fileType)
|
|
{
|
|
case FileType.INI:
|
|
case FileType.BIN:
|
|
{
|
|
var ini = new INI();
|
|
using (var reader = new StreamReader(path))
|
|
{
|
|
ini.Parse(reader);
|
|
}
|
|
errors.AddRange(LoadINI(ini));
|
|
}
|
|
break;
|
|
case FileType.MEG:
|
|
case FileType.PGM:
|
|
{
|
|
using (var megafile = new Megafile(path))
|
|
{
|
|
var mprFile = megafile.Where(p => Path.GetExtension(p).ToLower() == ".mpr").FirstOrDefault();
|
|
if (mprFile != null)
|
|
{
|
|
var ini = new INI();
|
|
using (var reader = new StreamReader(megafile.Open(mprFile)))
|
|
{
|
|
ini.Parse(reader);
|
|
}
|
|
errors.AddRange(LoadINI(ini));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
return errors;
|
|
}
|
|
|
|
private IEnumerable<string> LoadINI(INI ini)
|
|
{
|
|
var errors = new List<string>();
|
|
|
|
Map.BeginUpdate();
|
|
|
|
var basicSection = ini.Sections.Extract("Basic");
|
|
if (basicSection != null)
|
|
{
|
|
INI.ParseSection(new MapContext(Map, true), basicSection, Map.BasicSection);
|
|
}
|
|
|
|
Map.BasicSection.Player = Map.HouseTypes.Where(t => t.Equals(Map.BasicSection.Player)).FirstOrDefault()?.Name ?? Map.HouseTypes.First().Name;
|
|
Map.BasicSection.BasePlayer = HouseTypes.GetBasePlayer(Map.BasicSection.Player);
|
|
|
|
var mapSection = ini.Sections.Extract("Map");
|
|
if (mapSection != null)
|
|
{
|
|
INI.ParseSection(new MapContext(Map, true), mapSection, Map.MapSection);
|
|
}
|
|
|
|
var steamSection = ini.Sections.Extract("Steam");
|
|
if (steamSection != null)
|
|
{
|
|
INI.ParseSection(new MapContext(Map, true), steamSection, Map.SteamSection);
|
|
}
|
|
|
|
string indexToType(IList<string> list, string index)
|
|
{
|
|
return (int.TryParse(index, out int result) && (result >= 0) && (result < list.Count)) ? list[result] : list.First();
|
|
}
|
|
|
|
var teamTypesSection = ini.Sections.Extract("TeamTypes");
|
|
if (teamTypesSection != null)
|
|
{
|
|
foreach (var (Key, Value) in teamTypesSection)
|
|
{
|
|
try
|
|
{
|
|
var teamType = new TeamType { Name = Key };
|
|
|
|
var tokens = Value.Split(',').ToList();
|
|
teamType.House = Map.HouseTypes.Where(t => t.Equals(sbyte.Parse(tokens[0]))).FirstOrDefault(); tokens.RemoveAt(0);
|
|
|
|
var flags = int.Parse(tokens[0]); tokens.RemoveAt(0);
|
|
teamType.IsRoundAbout = (flags & 0x01) != 0;
|
|
teamType.IsSuicide = (flags & 0x02) != 0;
|
|
teamType.IsAutocreate = (flags & 0x04) != 0;
|
|
teamType.IsPrebuilt = (flags & 0x08) != 0;
|
|
teamType.IsReinforcable = (flags & 0x10) != 0;
|
|
|
|
teamType.RecruitPriority = int.Parse(tokens[0]); tokens.RemoveAt(0);
|
|
teamType.InitNum = byte.Parse(tokens[0]); tokens.RemoveAt(0);
|
|
teamType.MaxAllowed = byte.Parse(tokens[0]); tokens.RemoveAt(0);
|
|
teamType.Origin = int.Parse(tokens[0]) + 1; tokens.RemoveAt(0);
|
|
teamType.Trigger = tokens[0]; tokens.RemoveAt(0);
|
|
|
|
var numClasses = int.Parse(tokens[0]); tokens.RemoveAt(0);
|
|
for (int i = 0; i < Math.Min(Globals.MaxTeamClasses, numClasses); ++i)
|
|
{
|
|
var classTokens = tokens[0].Split(':'); tokens.RemoveAt(0);
|
|
if (classTokens.Length == 2)
|
|
{
|
|
var type = technoTypes.Where(t => t.Equals(classTokens[0])).FirstOrDefault();
|
|
var count = byte.Parse(classTokens[1]);
|
|
if (type != null)
|
|
{
|
|
teamType.Classes.Add(new TeamTypeClass { Type = type, Count = count });
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Team '{0}' references unknown class '{1}'", Key, classTokens[0]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Team '{0}' has wrong number of tokens for class index {1} (expecting 2)", Key, i));
|
|
}
|
|
}
|
|
|
|
var numMissions = int.Parse(tokens[0]); tokens.RemoveAt(0);
|
|
for (int i = 0; i < Math.Min(Globals.MaxTeamMissions, numMissions); ++i)
|
|
{
|
|
var missionTokens = tokens[0].Split(':'); tokens.RemoveAt(0);
|
|
if (missionTokens.Length == 2)
|
|
{
|
|
teamType.Missions.Add(new TeamTypeMission { Mission = indexToType(Map.TeamMissionTypes, missionTokens[0]), Argument = int.Parse(missionTokens[1]) });
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Team '{0}' has wrong number of tokens for mission index {1} (expecting 2)", Key, i));
|
|
}
|
|
}
|
|
|
|
Map.TeamTypes.Add(teamType);
|
|
}
|
|
catch (ArgumentOutOfRangeException) { }
|
|
}
|
|
}
|
|
|
|
var triggersSection = ini.Sections.Extract("Trigs");
|
|
if (triggersSection != null)
|
|
{
|
|
foreach (var (Key, Value) in triggersSection)
|
|
{
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length == 18)
|
|
{
|
|
var trigger = new Trigger { Name = Key };
|
|
|
|
trigger.PersistantType = (TriggerPersistantType)int.Parse(tokens[0]);
|
|
trigger.House = Map.HouseTypes.Where(t => t.Equals(sbyte.Parse(tokens[1]))).FirstOrDefault()?.Name ?? "None";
|
|
trigger.EventControl = (TriggerMultiStyleType)int.Parse(tokens[2]);
|
|
|
|
trigger.Event1.EventType = indexToType(Map.EventTypes, tokens[4]);
|
|
trigger.Event1.Team = tokens[5];
|
|
trigger.Event1.Data = long.Parse(tokens[6]);
|
|
|
|
trigger.Event2.EventType = indexToType(Map.EventTypes, tokens[7]);
|
|
trigger.Event2.Team = tokens[8];
|
|
trigger.Event2.Data = long.Parse(tokens[9]);
|
|
|
|
trigger.Action1.ActionType = indexToType(Map.ActionTypes, tokens[10]);
|
|
trigger.Action1.Team = tokens[11];
|
|
trigger.Action1.Trigger = tokens[12];
|
|
trigger.Action1.Data = long.Parse(tokens[13]);
|
|
|
|
trigger.Action2.ActionType = indexToType(Map.ActionTypes, tokens[14]);
|
|
trigger.Action2.Team = tokens[15];
|
|
trigger.Action2.Trigger = tokens[16];
|
|
trigger.Action2.Data = long.Parse(tokens[17]);
|
|
|
|
// Fix up data caused by union usage in the legacy game
|
|
Action<TriggerEvent> fixEvent = (TriggerEvent e) =>
|
|
{
|
|
switch (e.EventType)
|
|
{
|
|
case EventTypes.TEVENT_THIEVED:
|
|
case EventTypes.TEVENT_PLAYER_ENTERED:
|
|
case EventTypes.TEVENT_CROSS_HORIZONTAL:
|
|
case EventTypes.TEVENT_CROSS_VERTICAL:
|
|
case EventTypes.TEVENT_ENTERS_ZONE:
|
|
case EventTypes.TEVENT_HOUSE_DISCOVERED:
|
|
case EventTypes.TEVENT_BUILDINGS_DESTROYED:
|
|
case EventTypes.TEVENT_UNITS_DESTROYED:
|
|
case EventTypes.TEVENT_ALL_DESTROYED:
|
|
case EventTypes.TEVENT_LOW_POWER:
|
|
case EventTypes.TEVENT_BUILDING_EXISTS:
|
|
case EventTypes.TEVENT_BUILD:
|
|
case EventTypes.TEVENT_BUILD_UNIT:
|
|
case EventTypes.TEVENT_BUILD_INFANTRY:
|
|
case EventTypes.TEVENT_BUILD_AIRCRAFT:
|
|
e.Data &= 0xFF;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
};
|
|
|
|
Action<TriggerAction> fixAction = (TriggerAction a) =>
|
|
{
|
|
switch (a.ActionType)
|
|
{
|
|
case ActionTypes.TACTION_1_SPECIAL:
|
|
case ActionTypes.TACTION_FULL_SPECIAL:
|
|
case ActionTypes.TACTION_FIRE_SALE:
|
|
case ActionTypes.TACTION_WIN:
|
|
case ActionTypes.TACTION_LOSE:
|
|
case ActionTypes.TACTION_ALL_HUNT:
|
|
case ActionTypes.TACTION_BEGIN_PRODUCTION:
|
|
case ActionTypes.TACTION_AUTOCREATE:
|
|
case ActionTypes.TACTION_BASE_BUILDING:
|
|
case ActionTypes.TACTION_CREATE_TEAM:
|
|
case ActionTypes.TACTION_DESTROY_TEAM:
|
|
case ActionTypes.TACTION_REINFORCEMENTS:
|
|
case ActionTypes.TACTION_FORCE_TRIGGER:
|
|
case ActionTypes.TACTION_DESTROY_TRIGGER:
|
|
case ActionTypes.TACTION_DZ:
|
|
case ActionTypes.TACTION_REVEAL_SOME:
|
|
case ActionTypes.TACTION_REVEAL_ZONE:
|
|
case ActionTypes.TACTION_PLAY_MUSIC:
|
|
case ActionTypes.TACTION_PLAY_MOVIE:
|
|
case ActionTypes.TACTION_PLAY_SOUND:
|
|
case ActionTypes.TACTION_PLAY_SPEECH:
|
|
case ActionTypes.TACTION_PREFERRED_TARGET:
|
|
a.Data &= 0xFF;
|
|
break;
|
|
case ActionTypes.TACTION_TEXT_TRIGGER:
|
|
a.Data = Math.Max(1, Math.Min(209, a.Data));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
};
|
|
|
|
fixEvent(trigger.Event1);
|
|
fixEvent(trigger.Event2);
|
|
|
|
fixAction(trigger.Action1);
|
|
fixAction(trigger.Action2);
|
|
|
|
Map.Triggers.Add(trigger);
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Trigger '{0}' has too few tokens (expecting 18)", Key));
|
|
}
|
|
}
|
|
}
|
|
|
|
var mapPackSection = ini.Sections.Extract("MapPack");
|
|
if (mapPackSection != null)
|
|
{
|
|
Map.Templates.Clear();
|
|
|
|
var data = DecompressLCWSection(mapPackSection, 3);
|
|
using (var reader = new BinaryReader(new MemoryStream(data)))
|
|
{
|
|
for (var y = 0; y < Map.Metrics.Height; ++y)
|
|
{
|
|
for (var x = 0; x < Map.Metrics.Width; ++x)
|
|
{
|
|
var typeValue = reader.ReadUInt16();
|
|
var templateType = Map.TemplateTypes.Where(t => t.Equals(typeValue)).FirstOrDefault();
|
|
if ((templateType != null) && !templateType.Theaters.Contains(Map.Theater))
|
|
{
|
|
templateType = null;
|
|
}
|
|
Map.Templates[x, y] = (templateType != null) ? new Template { Type = templateType } : null;
|
|
}
|
|
}
|
|
|
|
for (var y = 0; y < Map.Metrics.Height; ++y)
|
|
{
|
|
for (var x = 0; x < Map.Metrics.Width; ++x)
|
|
{
|
|
var iconValue = reader.ReadByte();
|
|
var template = Map.Templates[x, y];
|
|
if (template != null)
|
|
{
|
|
if ((template.Type != TemplateTypes.Clear) && (iconValue >= template.Type.NumIcons))
|
|
{
|
|
Map.Templates[x, y] = null;
|
|
}
|
|
else
|
|
{
|
|
template.Icon = iconValue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var terrainSection = ini.Sections.Extract("Terrain");
|
|
if (terrainSection != null)
|
|
{
|
|
foreach (var (Key, Value) in terrainSection)
|
|
{
|
|
var cell = int.Parse(Key);
|
|
var name = Value.Split(',')[0];
|
|
var terrainType = Map.TerrainTypes.Where(t => t.Equals(name)).FirstOrDefault();
|
|
if (terrainType != null)
|
|
{
|
|
if (!Map.Technos.Add(cell, new Terrain
|
|
{
|
|
Type = terrainType,
|
|
Icon = terrainType.IsTransformable ? 22 : 0,
|
|
Trigger = Trigger.None
|
|
}))
|
|
{
|
|
var techno = Map.Technos[cell];
|
|
if (techno is Building building)
|
|
{
|
|
errors.Add(string.Format("Terrain '{0}' overlaps structure '{1}' in cell {2}, skipping", name, building.Type.Name, cell));
|
|
}
|
|
else if (techno is Overlay overlay)
|
|
{
|
|
errors.Add(string.Format("Terrain '{0}' overlaps overlay '{1}' in cell {2}, skipping", name, overlay.Type.Name, cell));
|
|
}
|
|
else if (techno is Terrain terrain)
|
|
{
|
|
errors.Add(string.Format("Terrain '{0}' overlaps terrain '{1}' in cell {2}, skipping", name, terrain.Type.Name, cell));
|
|
}
|
|
else if (techno is InfantryGroup infantry)
|
|
{
|
|
errors.Add(string.Format("Terrain '{0}' overlaps infantry in cell {1}, skipping", name, cell));
|
|
}
|
|
else if (techno is Unit unit)
|
|
{
|
|
errors.Add(string.Format("Terrain '{0}' overlaps unit '{1}' in cell {2}, skipping", name, unit.Type.Name, cell));
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Terrain '{0}' overlaps unknown techno in cell {1}, skipping", name, cell));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Terrain '{0}' references unknown terrain", name));
|
|
}
|
|
}
|
|
}
|
|
|
|
var overlayPackSection = ini.Sections.Extract("OverlayPack");
|
|
if (overlayPackSection != null)
|
|
{
|
|
Map.Overlay.Clear();
|
|
|
|
var data = DecompressLCWSection(overlayPackSection, 1);
|
|
using (var reader = new BinaryReader(new MemoryStream(data)))
|
|
{
|
|
for (var i = 0; i < Map.Metrics.Length; ++i)
|
|
{
|
|
var overlayId = reader.ReadSByte();
|
|
if (overlayId >= 0)
|
|
{
|
|
var overlayType = Map.OverlayTypes.Where(t => t.Equals(overlayId)).FirstOrDefault();
|
|
if (overlayType != null)
|
|
{
|
|
Map.Overlay[i] = new Overlay { Type = overlayType, Icon = 0 };
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Overlay ID {0} references unknown overlay", overlayId));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var smudgeSection = ini.Sections.Extract("Smudge");
|
|
if (smudgeSection != null)
|
|
{
|
|
foreach (var (Key, Value) in smudgeSection)
|
|
{
|
|
var cell = int.Parse(Key);
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length == 3)
|
|
{
|
|
var smudgeType = Map.SmudgeTypes.Where(t => t.Equals(tokens[0])).FirstOrDefault();
|
|
if (smudgeType != null)
|
|
{
|
|
if ((smudgeType.Flag & SmudgeTypeFlag.Bib) == SmudgeTypeFlag.None)
|
|
{
|
|
Map.Smudge[cell] = new Smudge
|
|
{
|
|
Type = smudgeType,
|
|
Icon = 0,
|
|
Data = int.Parse(tokens[2])
|
|
};
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Smudge '{0}' is a bib, skipped", tokens[0]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Smudge '{0}' references unknown smudge", tokens[0]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
var unitsSection = ini.Sections.Extract("Units");
|
|
if (unitsSection != null)
|
|
{
|
|
foreach (var (_, Value) in unitsSection)
|
|
{
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length == 7)
|
|
{
|
|
var unitType = Map.UnitTypes.Where(t => t.IsUnit && t.Equals(tokens[1])).FirstOrDefault();
|
|
if (unitType != null)
|
|
{
|
|
var direction = (byte)((int.Parse(tokens[4]) + 0x08) & ~0x0F);
|
|
|
|
var cell = int.Parse(tokens[3]);
|
|
if (!Map.Technos.Add(cell, new Unit()
|
|
{
|
|
Type = unitType,
|
|
House = Map.HouseTypes.Where(t => t.Equals(tokens[0])).FirstOrDefault(),
|
|
Strength = int.Parse(tokens[2]),
|
|
Direction = Map.DirectionTypes.Where(d => d.Equals(direction)).FirstOrDefault(),
|
|
Mission = tokens[5],
|
|
Trigger = tokens[6]
|
|
}))
|
|
{
|
|
var techno = Map.Technos[cell];
|
|
if (techno is Building building)
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' overlaps structure '{1}' in cell {2}, skipping", tokens[1], building.Type.Name, cell));
|
|
}
|
|
else if (techno is Overlay overlay)
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' overlaps overlay '{1}' in cell {2}, skipping", tokens[1], overlay.Type.Name, cell));
|
|
}
|
|
else if (techno is Terrain terrain)
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' overlaps terrain '{1}' in cell {2}, skipping", tokens[1], terrain.Type.Name, cell));
|
|
}
|
|
else if (techno is InfantryGroup infantry)
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' overlaps infantry in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
else if (techno is Unit unit)
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' overlaps unit '{1}' in cell {2}, skipping", tokens[1], unit.Type.Name, cell));
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' overlaps unknown techno in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' references unknown unit", tokens[1]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Unit '{0}' has wrong number of tokens (expecting 7)", tokens[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
var aircraftSections = ini.Sections.Extract("Aircraft");
|
|
if (aircraftSections != null)
|
|
{
|
|
foreach (var (_, Value) in aircraftSections)
|
|
{
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length == 6)
|
|
{
|
|
var aircraftType = Map.UnitTypes.Where(t => t.IsAircraft && t.Equals(tokens[1])).FirstOrDefault();
|
|
if (aircraftType != null)
|
|
{
|
|
var direction = (byte)((int.Parse(tokens[4]) + 0x08) & ~0x0F);
|
|
var cell = int.Parse(tokens[3]);
|
|
if (!Map.Technos.Add(cell, new Unit()
|
|
{
|
|
Type = aircraftType,
|
|
House = Map.HouseTypes.Where(t => t.Equals(tokens[0])).FirstOrDefault(),
|
|
Strength = int.Parse(tokens[2]),
|
|
Direction = Map.DirectionTypes.Where(d => d.Equals(direction)).FirstOrDefault(),
|
|
Mission = tokens[5]
|
|
}))
|
|
{
|
|
var techno = Map.Technos[cell];
|
|
if (techno is Building building)
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' overlaps structure '{1}' in cell {2}, skipping", tokens[1], building.Type.Name, cell));
|
|
}
|
|
else if (techno is Overlay overlay)
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' overlaps overlay '{1}' in cell {2}, skipping", tokens[1], overlay.Type.Name, cell));
|
|
}
|
|
else if (techno is Terrain terrain)
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' overlaps terrain '{1}' in cell {2}, skipping", tokens[1], terrain.Type.Name, cell));
|
|
}
|
|
else if (techno is InfantryGroup infantry)
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' overlaps infantry in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
else if (techno is Unit unit)
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' overlaps unit '{1}' in cell {2}, skipping", tokens[1], unit.Type.Name, cell));
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' overlaps unknown techno in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' references unknown aircraft", tokens[1]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Aircraft '{0}' has wrong number of tokens (expecting 6)", tokens[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
var shipsSection = ini.Sections.Extract("Ships");
|
|
if (shipsSection != null)
|
|
{
|
|
foreach (var (_, Value) in shipsSection)
|
|
{
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length == 7)
|
|
{
|
|
var vesselType = Map.UnitTypes.Where(t => t.IsVessel && t.Equals(tokens[1])).FirstOrDefault();
|
|
if (vesselType != null)
|
|
{
|
|
var direction = (byte)((int.Parse(tokens[4]) + 0x08) & ~0x0F);
|
|
|
|
var cell = int.Parse(tokens[3]);
|
|
if (!Map.Technos.Add(cell, new Unit()
|
|
{
|
|
Type = vesselType,
|
|
House = Map.HouseTypes.Where(t => t.Equals(tokens[0])).FirstOrDefault(),
|
|
Strength = int.Parse(tokens[2]),
|
|
Direction = Map.DirectionTypes.Where(d => d.Equals(direction)).FirstOrDefault(),
|
|
Mission = Map.MissionTypes.Where(t => t.Equals(tokens[5])).FirstOrDefault(),
|
|
Trigger = tokens[6]
|
|
}))
|
|
{
|
|
var techno = Map.Technos[cell];
|
|
if (techno is Building building)
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' overlaps structure '{1}' in cell {2}, skipping", tokens[1], building.Type.Name, cell));
|
|
}
|
|
else if (techno is Overlay overlay)
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' overlaps overlay '{1}' in cell {2}, skipping", tokens[1], overlay.Type.Name, cell));
|
|
}
|
|
else if (techno is Terrain terrain)
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' overlaps terrain '{1}' in cell {2}, skipping", tokens[1], terrain.Type.Name, cell));
|
|
}
|
|
else if (techno is InfantryGroup infantry)
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' overlaps infantry in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
else if (techno is Unit unit)
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' overlaps unit '{1}' in cell {2}, skipping", tokens[1], unit.Type.Name, cell));
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' overlaps unknown techno in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' references unknown ship", tokens[1]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Ship '{0}' has wrong number of tokens (expecting 7)", tokens[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
var infantrySections = ini.Sections.Extract("Infantry");
|
|
if (infantrySections != null)
|
|
{
|
|
foreach (var (_, Value) in infantrySections)
|
|
{
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length == 8)
|
|
{
|
|
var infantryType = Map.InfantryTypes.Where(t => t.Equals(tokens[1])).FirstOrDefault();
|
|
if (infantryType != null)
|
|
{
|
|
var cell = int.Parse(tokens[3]);
|
|
var infantryGroup = Map.Technos[cell] as InfantryGroup;
|
|
if ((infantryGroup == null) && (Map.Technos[cell] == null))
|
|
{
|
|
infantryGroup = new InfantryGroup();
|
|
Map.Technos.Add(cell, infantryGroup);
|
|
}
|
|
|
|
if (infantryGroup != null)
|
|
{
|
|
var stoppingPos = int.Parse(tokens[4]);
|
|
if (stoppingPos < Globals.NumInfantryStops)
|
|
{
|
|
var direction = (byte)((int.Parse(tokens[6]) + 0x08) & ~0x0F);
|
|
|
|
if (infantryGroup.Infantry[stoppingPos] == null)
|
|
{
|
|
infantryGroup.Infantry[stoppingPos] = new Infantry(infantryGroup)
|
|
{
|
|
Type = infantryType,
|
|
House = Map.HouseTypes.Where(t => t.Equals(tokens[0])).FirstOrDefault(),
|
|
Strength = int.Parse(tokens[2]),
|
|
Direction = Map.DirectionTypes.Where(d => d.Equals(direction)).FirstOrDefault(),
|
|
Mission = Map.MissionTypes.Where(t => t.Equals(tokens[5])).FirstOrDefault(),
|
|
Trigger = tokens[7]
|
|
};
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' overlaps another infantry at position {1} in cell {2}, skipping", tokens[1], stoppingPos, cell));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' has invalid position {1} in cell {2}, skipping", tokens[1], stoppingPos, cell));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var techno = Map.Technos[cell];
|
|
if (techno is Building building)
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' overlaps structure '{1}' in cell {2}, skipping", tokens[1], building.Type.Name, cell));
|
|
}
|
|
else if (techno is Overlay overlay)
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' overlaps overlay '{1}' in cell {2}, skipping", tokens[1], overlay.Type.Name, cell));
|
|
}
|
|
else if (techno is Terrain terrain)
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' overlaps terrain '{1}' in cell {2}, skipping", tokens[1], terrain.Type.Name, cell));
|
|
}
|
|
else if (techno is Unit unit)
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' overlaps unit '{1}' in cell {2}, skipping", tokens[1], unit.Type.Name, cell));
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' overlaps unknown techno in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' references unknown infantry", tokens[1]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Infantry '{0}' has wrong number of tokens (expecting 8)", tokens[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
var structuresSection = ini.Sections.Extract("Structures");
|
|
if (structuresSection != null)
|
|
{
|
|
foreach (var (_, Value) in structuresSection)
|
|
{
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length >= 6)
|
|
{
|
|
var buildingType = Map.BuildingTypes.Where(t => t.Equals(tokens[1])).FirstOrDefault();
|
|
if (buildingType != null)
|
|
{
|
|
var direction = (byte)((int.Parse(tokens[4]) + 0x08) & ~0x0F);
|
|
bool sellable = (tokens.Length >= 7) ? (int.Parse(tokens[6]) != 0) : false;
|
|
bool rebuild = (tokens.Length >= 8) ? (int.Parse(tokens[7]) != 0) : false;
|
|
|
|
var cell = int.Parse(tokens[3]);
|
|
if (!Map.Buildings.Add(cell, new Building()
|
|
{
|
|
Type = buildingType,
|
|
House = Map.HouseTypes.Where(t => t.Equals(tokens[0])).FirstOrDefault(),
|
|
Strength = int.Parse(tokens[2]),
|
|
Direction = Map.DirectionTypes.Where(d => d.Equals(direction)).FirstOrDefault(),
|
|
Trigger = tokens[5],
|
|
Sellable = sellable,
|
|
Rebuild = rebuild
|
|
}))
|
|
{
|
|
var techno = Map.Technos[cell];
|
|
if (techno is Building building)
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' overlaps structure '{1}' in cell {2}, skipping", tokens[1], building.Type.Name, cell));
|
|
}
|
|
else if (techno is Overlay overlay)
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' overlaps overlay '{1}' in cell {2}, skipping", tokens[1], overlay.Type.Name, cell));
|
|
}
|
|
else if (techno is Terrain terrain)
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' overlaps terrain '{1}' in cell {2}, skipping", tokens[1], terrain.Type.Name, cell));
|
|
}
|
|
else if (techno is InfantryGroup infantry)
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' overlaps infantry in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
else if (techno is Unit unit)
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' overlaps unit '{1}' in cell {2}, skipping", tokens[1], unit.Type.Name, cell));
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' overlaps unknown techno in cell {1}, skipping", tokens[1], cell));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' references unknown structure", tokens[1]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Structure '{0}' has wrong number of tokens (expecting 6)", tokens[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
var baseSection = ini.Sections.Extract("Base");
|
|
if (baseSection != null)
|
|
{
|
|
foreach (var (Key, Value) in baseSection)
|
|
{
|
|
if (Key.Equals("Player", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
Map.BasicSection.BasePlayer = Map.HouseTypes.Where(t => t.Equals(Value)).FirstOrDefault()?.Name ?? Map.HouseTypes.First().Name;
|
|
}
|
|
else if (int.TryParse(Key, out int priority))
|
|
{
|
|
var tokens = Value.Split(',');
|
|
if (tokens.Length == 2)
|
|
{
|
|
var buildingType = Map.BuildingTypes.Where(t => t.Equals(tokens[0])).FirstOrDefault();
|
|
if (buildingType != null)
|
|
{
|
|
var cell = int.Parse(tokens[1]);
|
|
Map.Metrics.GetLocation(cell, out Point location);
|
|
if (Map.Buildings.OfType<Building>().Where(x => x.Location == location).FirstOrDefault().Occupier is Building building)
|
|
{
|
|
building.BasePriority = priority;
|
|
}
|
|
else
|
|
{
|
|
Map.Buildings.Add(cell, new Building()
|
|
{
|
|
Type = buildingType,
|
|
Strength = 256,
|
|
Direction = DirectionTypes.North,
|
|
BasePriority = priority,
|
|
IsPrebuilt = false
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Base priority {0} references unknown structure '{1}'", priority, tokens[0]));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Base priority {0} has wrong number of tokens (expecting 2)", priority));
|
|
}
|
|
}
|
|
else if (!Key.Equals("Count", StringComparison.CurrentCultureIgnoreCase))
|
|
{
|
|
errors.Add(string.Format("Invalid base priority '{0}' (expecting integer)", Key));
|
|
}
|
|
}
|
|
}
|
|
|
|
var waypointsSection = ini.Sections.Extract("Waypoints");
|
|
if (waypointsSection != null)
|
|
{
|
|
foreach (var (Key, Value) in waypointsSection)
|
|
{
|
|
if (int.TryParse(Key, out int waypoint))
|
|
{
|
|
if (int.TryParse(Value, out int cell))
|
|
{
|
|
if ((waypoint >= 0) && (waypoint < Map.Waypoints.Length))
|
|
{
|
|
if (Map.Metrics.Contains(cell))
|
|
{
|
|
Map.Waypoints[waypoint].Cell = cell;
|
|
}
|
|
else
|
|
{
|
|
Map.Waypoints[waypoint].Cell = null;
|
|
if (cell != -1)
|
|
{
|
|
errors.Add(string.Format("Waypoint {0} cell value {1} out of range (expecting between {2} and {3})", waypoint, cell, 0, Map.Metrics.Length - 1));
|
|
}
|
|
}
|
|
}
|
|
else if (cell != -1)
|
|
{
|
|
errors.Add(string.Format("Waypoint {0} out of range (expecting between {1} and {2})", waypoint, 0, Map.Waypoints.Length - 1));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Waypoint {0} has invalid cell '{1}' (expecting integer)", waypoint, Value));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Invalid waypoint '{0}' (expecting integer)", Key));
|
|
}
|
|
}
|
|
}
|
|
|
|
var cellTriggersSection = ini.Sections.Extract("CellTriggers");
|
|
if (cellTriggersSection != null)
|
|
{
|
|
foreach (var (Key, Value) in cellTriggersSection)
|
|
{
|
|
if (int.TryParse(Key, out int cell))
|
|
{
|
|
if (Map.Metrics.Contains(cell))
|
|
{
|
|
Map.CellTriggers[cell] = new CellTrigger
|
|
{
|
|
Trigger = Value
|
|
};
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Cell trigger {0} outside map bounds", cell));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
errors.Add(string.Format("Invalid cell trigger '{0}' (expecting integer)", Key));
|
|
}
|
|
}
|
|
}
|
|
|
|
var briefingSection = ini.Sections.Extract("Briefing");
|
|
if (briefingSection != null)
|
|
{
|
|
if (briefingSection.Keys.Contains("Text"))
|
|
{
|
|
Map.BriefingSection.Briefing = briefingSection["Text"].Replace("@", Environment.NewLine);
|
|
}
|
|
else
|
|
{
|
|
Map.BriefingSection.Briefing = string.Join(" ", briefingSection.Keys.Select(k => k.Value)).Replace("@", Environment.NewLine);
|
|
}
|
|
}
|
|
|
|
foreach (var house in Map.Houses)
|
|
{
|
|
if (house.Type.ID < 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var houseSection = ini.Sections.Extract(house.Type.Name);
|
|
if (houseSection != null)
|
|
{
|
|
INI.ParseSection(new MapContext(Map, true), houseSection, house);
|
|
house.Enabled = true;
|
|
}
|
|
else
|
|
{
|
|
house.Enabled = false;
|
|
}
|
|
}
|
|
|
|
string indexToName<T>(IList<T> list, string index, string defaultValue) where T : INamedType
|
|
{
|
|
return (int.TryParse(index, out int result) && (result >= 0) && (result < list.Count)) ? list[result].Name : defaultValue;
|
|
}
|
|
|
|
foreach (var teamType in Map.TeamTypes)
|
|
{
|
|
teamType.Trigger = indexToName(Map.Triggers, teamType.Trigger, Trigger.None);
|
|
}
|
|
|
|
foreach (var trigger in Map.Triggers)
|
|
{
|
|
trigger.Event1.Team = indexToName(Map.TeamTypes, trigger.Event1.Team, TeamType.None);
|
|
trigger.Event2.Team = indexToName(Map.TeamTypes, trigger.Event2.Team, TeamType.None);
|
|
trigger.Action1.Team = indexToName(Map.TeamTypes, trigger.Action1.Team, TeamType.None);
|
|
trigger.Action1.Trigger = indexToName(Map.Triggers, trigger.Action1.Trigger, Trigger.None);
|
|
trigger.Action2.Team = indexToName(Map.TeamTypes, trigger.Action2.Team, TeamType.None);
|
|
trigger.Action2.Trigger = indexToName(Map.Triggers, trigger.Action2.Trigger, Trigger.None);
|
|
}
|
|
|
|
UpdateBasePlayerHouse();
|
|
|
|
extraSections = ini.Sections;
|
|
|
|
Map.EndUpdate();
|
|
|
|
return errors;
|
|
}
|
|
|
|
public bool Save(string path, FileType fileType)
|
|
{
|
|
if (!Validate())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch (fileType)
|
|
{
|
|
case FileType.INI:
|
|
case FileType.BIN:
|
|
{
|
|
var mprPath = Path.ChangeExtension(path, ".mpr");
|
|
var tgaPath = Path.ChangeExtension(path, ".tga");
|
|
var jsonPath = Path.ChangeExtension(path, ".json");
|
|
|
|
var ini = new INI();
|
|
using (var mprWriter = new StreamWriter(mprPath))
|
|
using (var tgaStream = new FileStream(tgaPath, FileMode.Create))
|
|
using (var jsonStream = new FileStream(jsonPath, FileMode.Create))
|
|
using (var jsonWriter = new JsonTextWriter(new StreamWriter(jsonStream)))
|
|
{
|
|
SaveINI(ini, fileType);
|
|
mprWriter.Write(ini.ToString());
|
|
SaveMapPreview(tgaStream);
|
|
SaveJSON(jsonWriter);
|
|
}
|
|
}
|
|
break;
|
|
case FileType.MEG:
|
|
case FileType.PGM:
|
|
{
|
|
using (var iniStream = new MemoryStream())
|
|
using (var tgaStream = new MemoryStream())
|
|
using (var jsonStream = new MemoryStream())
|
|
using (var jsonWriter = new JsonTextWriter(new StreamWriter(jsonStream)))
|
|
using (var megafileBuilder = new MegafileBuilder(@"", path))
|
|
{
|
|
var ini = new INI();
|
|
SaveINI(ini, fileType);
|
|
var iniWriter = new StreamWriter(iniStream);
|
|
iniWriter.Write(ini.ToString());
|
|
iniWriter.Flush();
|
|
iniStream.Position = 0;
|
|
|
|
SaveMapPreview(tgaStream);
|
|
tgaStream.Position = 0;
|
|
|
|
SaveJSON(jsonWriter);
|
|
jsonWriter.Flush();
|
|
jsonStream.Position = 0;
|
|
|
|
var mprFile = Path.ChangeExtension(Path.GetFileName(path), ".mpr").ToUpper();
|
|
var tgaFile = Path.ChangeExtension(Path.GetFileName(path), ".tga").ToUpper();
|
|
var jsonFile = Path.ChangeExtension(Path.GetFileName(path), ".json").ToUpper();
|
|
|
|
megafileBuilder.AddFile(mprFile, iniStream);
|
|
megafileBuilder.AddFile(tgaFile, tgaStream);
|
|
megafileBuilder.AddFile(jsonFile, jsonStream);
|
|
megafileBuilder.Write();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private void SaveINI(INI ini, FileType fileType)
|
|
{
|
|
if (extraSections != null)
|
|
{
|
|
ini.Sections.AddRange(extraSections);
|
|
}
|
|
|
|
INI.WriteSection(new MapContext(Map, false), ini.Sections.Add("Basic"), Map.BasicSection);
|
|
INI.WriteSection(new MapContext(Map, false), ini.Sections.Add("Map"), Map.MapSection);
|
|
|
|
if (fileType != FileType.PGM)
|
|
{
|
|
INI.WriteSection(new MapContext(Map, false), ini.Sections.Add("Steam"), Map.SteamSection);
|
|
}
|
|
|
|
ini["Basic"]["NewINIFormat"] = "3";
|
|
|
|
var smudgeSection = ini.Sections.Add("SMUDGE");
|
|
foreach (var (cell, smudge) in Map.Smudge.Where(item => (item.Value.Type.Flag & SmudgeTypeFlag.Bib) == SmudgeTypeFlag.None))
|
|
{
|
|
smudgeSection[cell.ToString()] = string.Format("{0},{1},{2}", smudge.Type.Name.ToUpper(), cell, smudge.Data);
|
|
}
|
|
|
|
var terrainSection = ini.Sections.Add("TERRAIN");
|
|
foreach (var (location, terrain) in Map.Technos.OfType<Terrain>())
|
|
{
|
|
Map.Metrics.GetCell(location, out int cell);
|
|
terrainSection[cell.ToString()] = terrain.Type.Name.ToUpper();
|
|
}
|
|
|
|
var cellTriggersSection = ini.Sections.Add("CellTriggers");
|
|
foreach (var (cell, cellTrigger) in Map.CellTriggers)
|
|
{
|
|
cellTriggersSection[cell.ToString()] = cellTrigger.Trigger;
|
|
}
|
|
|
|
int nameToIndex<T>(IList<T> list, string name)
|
|
{
|
|
var index = list.TakeWhile(x => !x.Equals(name)).Count();
|
|
return (index < list.Count) ? index : -1;
|
|
}
|
|
|
|
string nameToIndexString<T>(IList<T> list, string name) => nameToIndex(list, name).ToString();
|
|
|
|
var teamTypesSection = ini.Sections.Add("TeamTypes");
|
|
foreach (var teamType in Map.TeamTypes)
|
|
{
|
|
var classes = teamType.Classes
|
|
.Select(c => string.Format("{0}:{1}", c.Type.Name.ToUpper(), c.Count))
|
|
.ToArray();
|
|
var missions = teamType.Missions
|
|
.Select(m => string.Format("{0}:{1}", nameToIndexString(Map.TeamMissionTypes, m.Mission), m.Argument))
|
|
.ToArray();
|
|
|
|
int flags = 0;
|
|
if (teamType.IsRoundAbout) flags |= 0x01;
|
|
if (teamType.IsSuicide) flags |= 0x02;
|
|
if (teamType.IsAutocreate) flags |= 0x04;
|
|
if (teamType.IsPrebuilt) flags |= 0x08;
|
|
if (teamType.IsReinforcable) flags |= 0x10;
|
|
|
|
var tokens = new List<string>
|
|
{
|
|
teamType.House.ID.ToString(),
|
|
flags.ToString(),
|
|
teamType.RecruitPriority.ToString(),
|
|
teamType.InitNum.ToString(),
|
|
teamType.MaxAllowed.ToString(),
|
|
(teamType.Origin - 1).ToString(),
|
|
nameToIndexString(Map.Triggers, teamType.Trigger),
|
|
classes.Length.ToString(),
|
|
string.Join(",", classes),
|
|
missions.Length.ToString(),
|
|
string.Join(",", missions)
|
|
};
|
|
|
|
teamTypesSection[teamType.Name] = string.Join(",", tokens.Where(t => !string.IsNullOrEmpty(t)));
|
|
}
|
|
|
|
var infantrySection = ini.Sections.Add("INFANTRY");
|
|
var infantryIndex = 0;
|
|
foreach (var (location, infantryGroup) in Map.Technos.OfType<InfantryGroup>())
|
|
{
|
|
for (var i = 0; i < infantryGroup.Infantry.Length; ++i)
|
|
{
|
|
var infantry = infantryGroup.Infantry[i];
|
|
if (infantry == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var key = infantryIndex.ToString("D3");
|
|
infantryIndex++;
|
|
|
|
Map.Metrics.GetCell(location, out int cell);
|
|
infantrySection[key] = string.Format("{0},{1},{2},{3},{4},{5},{6},{7}",
|
|
infantry.House.Name,
|
|
infantry.Type.Name,
|
|
infantry.Strength,
|
|
cell,
|
|
i,
|
|
infantry.Mission,
|
|
infantry.Direction.ID,
|
|
infantry.Trigger
|
|
);
|
|
}
|
|
}
|
|
|
|
var structuresSection = ini.Sections.Add("STRUCTURES");
|
|
var structureIndex = 0;
|
|
foreach (var (location, building) in Map.Buildings.OfType<Building>().Where(x => x.Occupier.IsPrebuilt))
|
|
{
|
|
var key = structureIndex.ToString("D3");
|
|
structureIndex++;
|
|
|
|
Map.Metrics.GetCell(location, out int cell);
|
|
structuresSection[key] = string.Format("{0},{1},{2},{3},{4},{5},{6},{7}",
|
|
building.House.Name,
|
|
building.Type.Name,
|
|
building.Strength,
|
|
cell,
|
|
building.Direction.ID,
|
|
building.Trigger,
|
|
building.Sellable ? 1 : 0,
|
|
building.Rebuild ? 1 : 0
|
|
);
|
|
}
|
|
|
|
var baseSection = ini.Sections.Add("Base");
|
|
var baseBuildings = Map.Buildings.OfType<Building>().Where(x => x.Occupier.BasePriority >= 0).OrderBy(x => x.Occupier.BasePriority).ToArray();
|
|
baseSection["Player"] = Map.BasicSection.BasePlayer;
|
|
baseSection["Count"] = baseBuildings.Length.ToString();
|
|
var baseIndex = 0;
|
|
foreach (var (location, building) in baseBuildings)
|
|
{
|
|
var key = baseIndex.ToString("D3");
|
|
baseIndex++;
|
|
|
|
Map.Metrics.GetCell(location, out int cell);
|
|
baseSection[key] = string.Format("{0},{1}",
|
|
building.Type.Name.ToUpper(),
|
|
cell
|
|
);
|
|
}
|
|
|
|
var unitsSection = ini.Sections.Add("UNITS");
|
|
var unitIndex = 0;
|
|
foreach (var (location, unit) in Map.Technos.OfType<Unit>().Where(u => u.Occupier.Type.IsUnit))
|
|
{
|
|
var key = unitIndex.ToString("D3");
|
|
unitIndex++;
|
|
|
|
Map.Metrics.GetCell(location, out int cell);
|
|
unitsSection[key] = string.Format("{0},{1},{2},{3},{4},{5},{6}",
|
|
unit.House.Name,
|
|
unit.Type.Name,
|
|
unit.Strength,
|
|
cell,
|
|
unit.Direction.ID,
|
|
unit.Mission,
|
|
unit.Trigger
|
|
);
|
|
}
|
|
|
|
var aircraftSection = ini.Sections.Add("AIRCRAFT");
|
|
var aircraftIndex = 0;
|
|
foreach (var (location, aircraft) in Map.Technos.OfType<Unit>().Where(u => u.Occupier.Type.IsAircraft))
|
|
{
|
|
var key = aircraftIndex.ToString("D3");
|
|
aircraftIndex++;
|
|
|
|
Map.Metrics.GetCell(location, out int cell);
|
|
aircraftSection[key] = string.Format("{0},{1},{2},{3},{4},{5}",
|
|
aircraft.House.Name,
|
|
aircraft.Type.Name,
|
|
aircraft.Strength,
|
|
cell,
|
|
aircraft.Direction.ID,
|
|
aircraft.Mission
|
|
);
|
|
}
|
|
|
|
var shipsSection = ini.Sections.Add("SHIPS");
|
|
var shipsIndex = 0;
|
|
foreach (var (location, ship) in Map.Technos.OfType<Unit>().Where(u => u.Occupier.Type.IsVessel))
|
|
{
|
|
var key = shipsIndex.ToString("D3");
|
|
shipsIndex++;
|
|
|
|
Map.Metrics.GetCell(location, out int cell);
|
|
shipsSection[key] = string.Format("{0},{1},{2},{3},{4},{5},{6}",
|
|
ship.House.Name,
|
|
ship.Type.Name,
|
|
ship.Strength,
|
|
cell,
|
|
ship.Direction.ID,
|
|
ship.Mission,
|
|
ship.Trigger
|
|
);
|
|
}
|
|
|
|
var triggersSection = ini.Sections.Add("Trigs");
|
|
foreach (var trigger in Map.Triggers)
|
|
{
|
|
if (string.IsNullOrEmpty(trigger.Name))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var action2TypeIndex = nameToIndex(Map.ActionTypes, trigger.Action2.ActionType);
|
|
var actionControl = (action2TypeIndex > 0) ? TriggerMultiStyleType.And : TriggerMultiStyleType.Only;
|
|
|
|
var tokens = new List<string>
|
|
{
|
|
((int)trigger.PersistantType).ToString(),
|
|
!string.IsNullOrEmpty(trigger.House) ? (Map.HouseTypes.Where(h => h.Equals(trigger.House)).FirstOrDefault()?.ID.ToString() ?? "-1") : "-1",
|
|
((int)trigger.EventControl).ToString(),
|
|
((int)actionControl).ToString(),
|
|
nameToIndexString(Map.EventTypes, trigger.Event1.EventType),
|
|
nameToIndexString(Map.TeamTypes, trigger.Event1.Team),
|
|
trigger.Event1.Data.ToString(),
|
|
nameToIndexString(Map.EventTypes, trigger.Event2.EventType),
|
|
nameToIndexString(Map.TeamTypes, trigger.Event2.Team),
|
|
trigger.Event2.Data.ToString(),
|
|
nameToIndexString(Map.ActionTypes, trigger.Action1.ActionType),
|
|
nameToIndexString(Map.TeamTypes, trigger.Action1.Team),
|
|
nameToIndexString(Map.Triggers, trigger.Action1.Trigger),
|
|
trigger.Action1.Data.ToString(),
|
|
action2TypeIndex.ToString(),
|
|
nameToIndexString(Map.TeamTypes, trigger.Action2.Team),
|
|
nameToIndexString(Map.Triggers, trigger.Action2.Trigger),
|
|
trigger.Action2.Data.ToString()
|
|
};
|
|
|
|
triggersSection[trigger.Name] = string.Join(",", tokens);
|
|
}
|
|
|
|
var waypointsSection = ini.Sections.Add("Waypoints");
|
|
for (var i = 0; i < Map.Waypoints.Length; ++i)
|
|
{
|
|
var waypoint = Map.Waypoints[i];
|
|
if (waypoint.Cell.HasValue)
|
|
{
|
|
waypointsSection[i.ToString()] = waypoint.Cell.Value.ToString();
|
|
}
|
|
}
|
|
|
|
foreach (var house in Map.Houses)
|
|
{
|
|
if ((house.Type.ID < 0) || !house.Enabled)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
INI.WriteSection(new MapContext(Map, true), ini.Sections.Add(house.Type.Name), house);
|
|
}
|
|
|
|
ini.Sections.Remove("Briefing");
|
|
if (!string.IsNullOrEmpty(Map.BriefingSection.Briefing))
|
|
{
|
|
var briefingSection = ini.Sections.Add("Briefing");
|
|
briefingSection["Text"] = Map.BriefingSection.Briefing.Replace(Environment.NewLine, "@");
|
|
}
|
|
|
|
using (var stream = new MemoryStream())
|
|
{
|
|
using (var writer = new BinaryWriter(stream))
|
|
{
|
|
for (var y = 0; y < Map.Metrics.Height; ++y)
|
|
{
|
|
for (var x = 0; x < Map.Metrics.Width; ++x)
|
|
{
|
|
var template = Map.Templates[x, y];
|
|
if (template != null)
|
|
{
|
|
writer.Write(template.Type.ID);
|
|
}
|
|
else
|
|
{
|
|
writer.Write(ushort.MaxValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var y = 0; y < Map.Metrics.Height; ++y)
|
|
{
|
|
for (var x = 0; x < Map.Metrics.Width; ++x)
|
|
{
|
|
var template = Map.Templates[x, y];
|
|
if (template != null)
|
|
{
|
|
writer.Write((byte)template.Icon);
|
|
}
|
|
else
|
|
{
|
|
writer.Write(byte.MaxValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ini.Sections.Remove("MapPack");
|
|
CompressLCWSection(ini.Sections.Add("MapPack"), stream.ToArray());
|
|
}
|
|
|
|
using (var stream = new MemoryStream())
|
|
{
|
|
using (var writer = new BinaryWriter(stream))
|
|
{
|
|
for (var i = 0; i < Map.Metrics.Length; ++i)
|
|
{
|
|
var overlay = Map.Overlay[i];
|
|
if (overlay != null)
|
|
{
|
|
writer.Write(overlay.Type.ID);
|
|
}
|
|
else
|
|
{
|
|
writer.Write((sbyte)-1);
|
|
}
|
|
}
|
|
}
|
|
|
|
ini.Sections.Remove("OverlayPack");
|
|
CompressLCWSection(ini.Sections.Add("OverlayPack"), stream.ToArray());
|
|
}
|
|
}
|
|
|
|
private void SaveMapPreview(Stream stream)
|
|
{
|
|
Map.GenerateMapPreview().Save(stream);
|
|
}
|
|
|
|
private void SaveJSON(JsonTextWriter writer)
|
|
{
|
|
writer.WriteStartObject();
|
|
writer.WritePropertyName("MapTileX");
|
|
writer.WriteValue(Map.MapSection.X);
|
|
writer.WritePropertyName("MapTileY");
|
|
writer.WriteValue(Map.MapSection.Y);
|
|
writer.WritePropertyName("MapTileWidth");
|
|
writer.WriteValue(Map.MapSection.Width);
|
|
writer.WritePropertyName("MapTileHeight");
|
|
writer.WriteValue(Map.MapSection.Height);
|
|
writer.WritePropertyName("Theater");
|
|
writer.WriteValue(Map.MapSection.Theater.Name.ToUpper());
|
|
writer.WritePropertyName("Waypoints");
|
|
writer.WriteStartArray();
|
|
foreach (var waypoint in Map.Waypoints.Where(w => (w.Flag == WaypointFlag.PlayerStart) && w.Cell.HasValue))
|
|
{
|
|
writer.WriteValue(waypoint.Cell.Value);
|
|
}
|
|
writer.WriteEndArray();
|
|
writer.WriteEndObject();
|
|
}
|
|
|
|
private bool Validate()
|
|
{
|
|
StringBuilder sb = new StringBuilder("Error(s) during map validation:");
|
|
|
|
bool ok = true;
|
|
int numAircraft = Map.Technos.OfType<Unit>().Where(u => u.Occupier.Type.IsAircraft).Count();
|
|
int numBuildings = Map.Buildings.OfType<Building>().Where(x => x.Occupier.IsPrebuilt).Count();
|
|
int numInfantry = Map.Technos.OfType<InfantryGroup>().Sum(item => item.Occupier.Infantry.Count(i => i != null));
|
|
int numTerrain = Map.Technos.OfType<Terrain>().Count();
|
|
int numUnits = Map.Technos.OfType<Unit>().Where(u => u.Occupier.Type.IsUnit).Count();
|
|
int numVessels = Map.Technos.OfType<Unit>().Where(u => u.Occupier.Type.IsVessel).Count();
|
|
int numWaypoints = Map.Waypoints.Count(w => w.Cell.HasValue);
|
|
|
|
if (numAircraft > Constants.MaxAircraft)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of aircraft exceeded ({0} > {1})", numAircraft, Constants.MaxAircraft));
|
|
ok = false;
|
|
}
|
|
|
|
if (numBuildings > Constants.MaxBuildings)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of structures exceeded ({0} > {1})", numBuildings, Constants.MaxBuildings));
|
|
ok = false;
|
|
}
|
|
|
|
if (numInfantry > Constants.MaxInfantry)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of infantry exceeded ({0} > {1})", numInfantry, Constants.MaxInfantry));
|
|
ok = false;
|
|
}
|
|
|
|
if (numTerrain > Constants.MaxTerrain)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of terrain objects exceeded ({0} > {1})", numTerrain, Constants.MaxTerrain));
|
|
ok = false;
|
|
}
|
|
|
|
if (numUnits > Constants.MaxUnits)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of units exceeded ({0} > {1})", numUnits, Constants.MaxUnits));
|
|
ok = false;
|
|
}
|
|
|
|
if (numVessels > Constants.MaxVessels)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of ships exceeded ({0} > {1})", numVessels, Constants.MaxVessels));
|
|
ok = false;
|
|
}
|
|
|
|
if (Map.TeamTypes.Count > Constants.MaxTeams)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of team types exceeded ({0} > {1})", Map.TeamTypes.Count, Constants.MaxTeams));
|
|
ok = false;
|
|
}
|
|
|
|
if (Map.Triggers.Count > Constants.MaxTriggers)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Maximum number of triggers exceeded ({0} > {1})", Map.Triggers.Count, Constants.MaxTriggers));
|
|
ok = false;
|
|
}
|
|
|
|
if (!Map.BasicSection.SoloMission && (numWaypoints < 2))
|
|
{
|
|
sb.Append(Environment.NewLine + "Skirmish/Multiplayer maps need at least 2 waypoints for player starting locations.");
|
|
ok = false;
|
|
}
|
|
|
|
var homeWaypoint = Map.Waypoints.Where(w => w.Equals("Home")).FirstOrDefault();
|
|
if (Map.BasicSection.SoloMission && !homeWaypoint.Cell.HasValue)
|
|
{
|
|
sb.Append(Environment.NewLine + string.Format("Single-player maps need the Home waypoint to be placed.", Map.Triggers.Count, Constants.MaxTriggers));
|
|
ok = false;
|
|
}
|
|
|
|
if (!ok)
|
|
{
|
|
MessageBox.Show(sb.ToString(), "Validation Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
|
|
}
|
|
|
|
return ok;
|
|
}
|
|
|
|
private void BasicSection_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
switch (e.PropertyName)
|
|
{
|
|
case "BasePlayer":
|
|
{
|
|
UpdateBasePlayerHouse();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void MapSection_PropertyChanged(object sender, PropertyChangedEventArgs e)
|
|
{
|
|
switch (e.PropertyName)
|
|
{
|
|
case "Theater":
|
|
{
|
|
Map.InitTheater(GameType);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void UpdateBasePlayerHouse()
|
|
{
|
|
var basePlayer = Map.HouseTypes.Where(h => h.Equals(Map.BasicSection.BasePlayer)).FirstOrDefault() ?? Map.HouseTypes.First();
|
|
foreach (var (_, building) in Map.Buildings.OfType<Building>())
|
|
{
|
|
if (!building.IsPrebuilt)
|
|
{
|
|
building.House = basePlayer;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CompressLCWSection(INISection section, byte[] decompressedBytes)
|
|
{
|
|
using (var stream = new MemoryStream())
|
|
using (var writer = new BinaryWriter(stream))
|
|
{
|
|
foreach (var decompressedChunk in decompressedBytes.Split(8192))
|
|
{
|
|
var compressedChunk = WWCompression.LcwCompress(decompressedChunk);
|
|
writer.Write((ushort)compressedChunk.Length);
|
|
writer.Write((ushort)decompressedChunk.Length);
|
|
writer.Write(compressedChunk);
|
|
}
|
|
|
|
writer.Flush();
|
|
stream.Position = 0;
|
|
|
|
var values = Convert.ToBase64String(stream.ToArray()).Split(70).ToArray();
|
|
for (var i = 0; i < values.Length; ++i)
|
|
{
|
|
section[(i + 1).ToString()] = values[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
private byte[] DecompressLCWSection(INISection section, int bytesPerCell)
|
|
{
|
|
var sb = new StringBuilder();
|
|
foreach (var (key, value) in section)
|
|
{
|
|
sb.Append(value);
|
|
}
|
|
|
|
var compressedBytes = Convert.FromBase64String(sb.ToString());
|
|
int readPtr = 0;
|
|
int writePtr = 0;
|
|
var decompressedBytes = new byte[Map.Metrics.Width * Map.Metrics.Height * bytesPerCell];
|
|
|
|
while ((readPtr + 4) <= compressedBytes.Length)
|
|
{
|
|
uint uLength;
|
|
using (var reader = new BinaryReader(new MemoryStream(compressedBytes, readPtr, 4)))
|
|
{
|
|
uLength = reader.ReadUInt32();
|
|
}
|
|
var length = (int)(uLength & 0x0000FFFF);
|
|
readPtr += 4;
|
|
var dest = new byte[8192];
|
|
var readPtr2 = readPtr;
|
|
var decompressed = WWCompression.LcwDecompress(compressedBytes, ref readPtr2, dest, 0);
|
|
Array.Copy(dest, 0, decompressedBytes, writePtr, decompressed);
|
|
readPtr += length;
|
|
writePtr += decompressed;
|
|
}
|
|
return decompressedBytes;
|
|
}
|
|
|
|
#region IDisposable Support
|
|
private bool disposedValue = false;
|
|
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (!disposedValue)
|
|
{
|
|
if (disposing)
|
|
{
|
|
MapImage?.Dispose();
|
|
}
|
|
disposedValue = true;
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|