public Upgrade(string n, string d, int c, UpgradeAction ua)
{
Name = n;
Description = d;
Cost = c;
UpgradeAction = ua;
}
public void ExecuteAction(UpgradeAction action)
{
// If no building selected, ignore
if (!_selectedBuilding)
{
return;
}
switch (action)
{
case UpgradeAction.Upgrade:
if (_selectedBuilding.IsMaxLevel())
{
return;
}
_selectedBuilding.UpgradeBuilding();
break;
case UpgradeAction.Repair:
if (_selectedBuilding.IsMaxHealth())
{
return;
}
_selectedBuilding.Repair(true);
break;
case UpgradeAction.Sell:
if (_selectedBuilding is Base)
{
return;
}
_selectedBuilding.Sell();
break;
}
}
private VisualElement CreateActionIndicator(UpgradeAction action)
{
UpgradeAction.UpgradeDetails nextUpgrade;
try
{
nextUpgrade = action.upgradeDetails.First(u => !playerData.TechnologyData.HasTechnology(u.tech));
}
catch
{
var label = new Label(action.name.Replace("Upgrade", ""));
label.AddToClassList("action-button");
label.AddToClassList("action-button-researched");
var costDisplay = new Label("(purchased)");
costDisplay.AddToClassList("action-cost");
label.Add(costDisplay);
return(label);
}
return(CreateButton(
nextUpgrade.title.Replace("Upgrade", ""),
nextUpgrade.cost,
() => ProcessUpgradeAction(nextUpgrade),
newCost => UpdateActionCost(action, nextUpgrade, newCost),
false
));
}
static void ProcessYaml(ModData modData, Map map, MiniYaml yaml, int engineDate, UpgradeAction processYaml)
{
if (yaml == null)
return;
if (yaml.Value != null)
{
var files = FieldLoader.GetValue<string[]>("value", yaml.Value);
foreach (var filename in files)
{
var fileNodes = MiniYaml.FromStream(map.Open(filename), filename);
processYaml(modData, engineDate, ref fileNodes, null, 0);
// HACK: Obtain the writable save path using knowledge of the underlying filesystem workings
var packagePath = filename;
var package = map.Package;
if (filename.Contains("|"))
modData.DefaultFileSystem.TryGetPackageContaining(filename, out package, out packagePath);
((IReadWritePackage)package).Update(packagePath, Encoding.ASCII.GetBytes(fileNodes.WriteToString()));
}
}
processYaml(modData, engineDate, ref yaml.Nodes, null, 1);
}
public void Show(VisualElement container, UpgradeAction upgradeAction, Action updateContentsCallback)
{
var header = new Label(upgradeAction.group.ToString());
header.AddToClassList("object-header");
container.Add(header);
}
public void ShowNodeDetails(HexCell cell)
{
if (this.cell == cell)
{
return;
}
this.cell = cell;
upgrade = null;
upgradeDetails.tech = Technology.None;
UpdateContents();
}
public void ShowNodeDetails(UpgradeAction.UpgradeDetails upgradeDetails)
{
if (this.upgradeDetails.tech == upgradeDetails.tech)
{
return;
}
this.upgradeDetails = upgradeDetails;
cell = null;
upgrade = null;
UpdateContents();
}
public void ShowNodeDetails(ActionDefinition action)
{
if (upgrade == action)
{
return;
}
if (!(action is UpgradeAction upgradeAction))
{
return;
}
upgrade = upgradeAction;
cell = null;
upgradeDetails.tech = Technology.None;
UpdateContents();
}
private void UpdateActionCost(UpgradeAction action, UpgradeAction.UpgradeDetails upgrade, Currency cost)
{
for (int i = 0; i < action.upgradeDetails.Length; i++)
{
if (action.upgradeDetails[i].tech == upgrade.tech && action.upgradeDetails[i].title == upgrade.title)
{
editor.RecordUndo(action, "Upgrade action cost");
upgrade.cost = cost;
var allDetails = action.upgradeDetails;
allDetails[i] = upgrade;
action.upgradeDetails = allDetails;
EditorUtility.SetDirty(action);
UpdateActions();
}
}
}
static void ProcessYaml(Map map, MiniYaml yaml, int engineDate, UpgradeAction processYaml)
{
if (yaml == null)
return;
if (yaml.Value != null)
{
var files = FieldLoader.GetValue<string[]>("value", yaml.Value);
foreach (var filename in files)
{
var fileNodes = MiniYaml.FromStream(map.Package.GetStream(filename));
processYaml(engineDate, ref fileNodes, null, 0);
((IReadWritePackage)map.Package).Update(filename, Encoding.ASCII.GetBytes(fileNodes.WriteToString()));
}
}
processYaml(engineDate, ref yaml.Nodes, null, 1);
}
public void Setup(UpgradeAction action)
{
this.action = action;
subNodes ??= new List <UpgradeSubNode>();
for (int i = 0; i < action.upgradeDetails.Length; i++)
{
var subNode = GetSubNode(action.upgradeDetails[i]);
subNode.Setup(this, action.upgradeDetails[i], i);
subNode.OnEnter = OnEnteredSubNode;
subNode.OnLeave = OnLeftSubNode;
}
hash = GenerateHash(action);
Element = GetElement();
}
static void ProcessYaml(Map map, MiniYaml yaml, int engineDate, UpgradeAction processYaml)
{
if (yaml == null)
{
return;
}
if (yaml.Value != null)
{
var files = FieldLoader.GetValue <string[]>("value", yaml.Value);
foreach (var filename in files)
{
var fileNodes = MiniYaml.FromStream(map.Package.GetStream(filename));
processYaml(engineDate, ref fileNodes, null, 0);
((IReadWritePackage)map.Package).Update(filename, Encoding.ASCII.GetBytes(fileNodes.WriteToString()));
}
}
processYaml(engineDate, ref yaml.Nodes, null, 1);
}
private static bool RemoveTechRequirementFromUpgrade(UpgradeAction action, Technology dependentTech, Technology requiredTech)
{
for (int i = 0; i < action.upgradeDetails.Length; i++)
{
if (action.upgradeDetails[i].tech == dependentTech)
{
var details = action.upgradeDetails[i];
if (!details.requiredTech.Contains(requiredTech))
{
return(false);
}
Undo.RecordObject(action, "Remove tech requirement");
details.requiredTech.Remove(requiredTech);
action.upgradeDetails[i] = details;
EditorUtility.SetDirty(action);
return(true);
}
}
return(false);
}
public ValidatedUpgrade(Int16 id, UpgradeAction action, Technology tech)
{
ID = id;
this.action = action;
this.tech = tech;
}
void SetOnDestroy(UpgradeAction ua)
{
SetOnDestroy(ua.locationAction, ua.targets);
}
public ShipInstaller(UpgradeAction action) : base(action)
{
}
public void Run()
{
UpgradeAction?.Invoke();
}
void ProcessYaml(string type, IEnumerable<string> files, ModData modData, int engineDate, UpgradeAction processFile)
{
Console.WriteLine("Processing {0}:", type);
foreach (var filename in files)
{
Console.WriteLine("\t" + filename);
string name;
IReadOnlyPackage package;
if (!modData.ModFiles.TryGetPackageContaining(filename, out package, out name) || !(package is Folder))
{
Console.WriteLine("\t\tFile cannot be opened for writing! Ignoring...");
continue;
}
var yaml = MiniYaml.FromStream(package.GetStream(name), name);
processFile(modData, engineDate, ref yaml, null, 0);
// Generate the on-disk path
var path = Path.Combine(package.Name, name);
using (var file = new StreamWriter(path))
file.Write(yaml.WriteToString());
}
}
void SetOnCollision(UpgradeAction ua)
{
SetOnCollision(ua.targetAction, ua.targets);
}
void SetOnDestroy(UpgradeAction ua)
{
SetOnDestroy(ua.locationAction,ua.targets);
}
void SetOnCollision(UpgradeAction ua)
{
SetOnCollision(ua.targetAction, ua.targets);
}
protected virtual void ExtractQueryParameters()
{
string queryString = WebUtil.GetQueryString("package");
if (!string.IsNullOrEmpty(queryString))
{
string packagePath = queryString;
if (!string.IsNullOrEmpty(packagePath) && !packagePath.Contains(@"\"))
{
packagePath = UpdateHelper.GetPackagePath(queryString);
}
if (!string.IsNullOrEmpty(packagePath) && File.Exists(packagePath))
{
this.PackagePath = packagePath;
}
}
this.InstallMode = (WebUtil.GetQueryString("install") == "1") ? InstallMode.Install : InstallMode.Update;
this.UpgradeAction = (WebUtil.GetQueryString("upgrade") == "1") ? UpgradeAction.Upgrade : UpgradeAction.Preview;
string str3 = WebUtil.GetQueryString("history");
if (!string.IsNullOrEmpty(str3))
{
this.InstallationHistoryRoot = UpdateHelper.GetHistoryPath(HttpContext.Current.Server.UrlDecode(str3));
}
}
void SetBlastEffect(UpgradeAction ua)
{
onHitByBlast = ua.targetAction;
blastTargets = ua.targets;
}
public static int GenerateHash(UpgradeAction action) => Hash128.Compute("Upgrade" + action.name).GetHashCode();
void SetBlastEffect(UpgradeAction ua)
{
onHitByBlast = ua.targetAction;
blastTargets = ua.targets;
}
void ProcessYaml(string type, IEnumerable <string> files, ModData modData, int engineDate, UpgradeAction processFile)
{
Console.WriteLine("Processing {0}:", type);
foreach (var filename in files)
{
Console.WriteLine("\t" + filename);
string name;
IReadOnlyPackage package;
if (!modData.ModFiles.TryGetPackageContaining(filename, out package, out name) || !(package is Folder))
{
Console.WriteLine("\t\tFile cannot be opened for writing! Ignoring...");
continue;
}
var yaml = MiniYaml.FromStream(package.GetStream(name), name);
processFile(modData, engineDate, ref yaml, null, 0);
// Generate the on-disk path
var path = Path.Combine(package.Name, name);
using (var file = new StreamWriter(path))
file.Write(yaml.WriteToString());
}
}
public ShipInstaller(UpgradeAction action) : base(action)
{
}
static void ProcessYaml(ModData modData, Map map, MiniYaml yaml, int engineDate, UpgradeAction processYaml)
{
if (yaml == null)
{
return;
}
if (yaml.Value != null)
{
var files = FieldLoader.GetValue <string[]>("value", yaml.Value);
foreach (var filename in files)
{
var fileNodes = MiniYaml.FromStream(map.Open(filename), filename);
processYaml(modData, engineDate, ref fileNodes, null, 0);
// HACK: Obtain the writable save path using knowledge of the underlying filesystem workings
var packagePath = filename;
var package = map.Package;
if (filename.Contains("|"))
{
modData.DefaultFileSystem.TryGetPackageContaining(filename, out package, out packagePath);
}
((IReadWritePackage)package).Update(packagePath, Encoding.ASCII.GetBytes(fileNodes.WriteToString()));
}
}
processYaml(modData, engineDate, ref yaml.Nodes, null, 1);
}
public UpgradeGroupNode(UpgradeAction action)
{
Setup(action);
}
