public void DeleteFunction(UpgradeFunction function)
{
QuickLogger.Debug("Deleting Function", true);
function.DeActivateUpdate();
Upgrades.Remove(function);
OnUpgradeUpdate?.Invoke(null);
}
public Task <TransactionReceipt> UpgradeRequestAndWaitForReceiptAsync(string new_address, CancellationTokenSource cancellationToken = null)
{
var upgradeFunction = new UpgradeFunction();
upgradeFunction.New_address = new_address;
return(ContractHandler.SendRequestAndWaitForReceiptAsync(upgradeFunction, cancellationToken));
}
public Task <string> UpgradeRequestAsync(string new_address)
{
var upgradeFunction = new UpgradeFunction();
upgradeFunction.New_address = new_address;
return(ContractHandler.SendRequestAsync(upgradeFunction));
}
private UnityAction getIncreaseAction(UpgradeFunction function)
{
switch (function.increaseType)
{
case IncreaseType.grantPayout:
return(delegate() { grantWriterManager.increasePayout(function.increaseValue, function.increaseFunction); });
default:
return(null);
}
}
public bool HasUpgradeFunction(UpgradeFunctions upgradeEnum, out UpgradeFunction function)
{
function = null;
if (Upgrades.Any(x => x.UpgradeType == upgradeEnum))
{
function = Upgrades.FirstOrDefault(x => x.UpgradeType == upgradeEnum);
return(true);
}
return(false);
}
private UnityAction getTaskUnlock(UpgradeFunction function)
{
switch (function.taskType)
{
case TaskType.blackMarket:
return(taskManager.unlockBlackMarket);
case TaskType.requests:
return(taskManager.unlockRequests);
case TaskType.collosseum:
return(taskManager.unlockCollosseum);
default:
return(null);
}
}
private UnityAction getUnlockAction(UpgradeFunction function)
{
switch (function.unlockType)
{
case UnlockType.jar:
return(gameManager.createNewJar);
case UnlockType.jarProperty:
return(delegate() { propertyDB.discoverJarProperty(function.jarProperty); });
case UnlockType.task:
return(getTaskUnlock(function));
default:
return(null);
}
}
private void ImplementCommand(string functionString, out UpgradeFunction upgrade)
{
upgrade = null;
// check if we have a string to process
if (string.IsNullOrEmpty(functionString))
{
return;
}
//Check if the function name is valid
var validClass = ValidateClassType(functionString);
if (validClass)
{
//Check if the function name is valid
var functionName = GetFunctionName(functionString, out var fNameResult);
if (functionName)
{
var parameters = GetMethodParameters(functionString, out var paraResults);
if (parameters)
{
switch (fNameResult)
{
case "OresPerDay":
var check = Upgrades.Any(x =>
x.UpgradeType == UpgradeFunctions.OresPerDay);
if (check)
{
QuickLogger.Message("Function already implemented.", true);
return;
}
bool valid = OresPerDayUpgrade.IsValid(paraResults, out var orePerDay);
if (valid)
{
QuickLogger.Debug($"Function Valid: {functionString}", true);
var orePerDayUpgrade = new OresPerDayUpgrade
{
IsEnabled = true,
Mono = _mono,
OreCount = orePerDay,
Function = functionString
};
Upgrades.Add(orePerDayUpgrade);
OnUpgradeUpdate?.Invoke(orePerDayUpgrade);
_mono.OreGenerator.ApplyUpgrade(orePerDayUpgrade);
upgrade = orePerDayUpgrade;
}
else
{
QuickLogger.Debug($"Invalid Function: {functionString}", true);
}
break;
case "MaxOreCount":
var maxOreCountCheck = Upgrades.Any(x =>
x.UpgradeType == UpgradeFunctions.MaxOreCount);
if (maxOreCountCheck)
{
QuickLogger.Message("Function already implemented.", true);
return;
}
bool maxOreCountValid = MaxOreCountUpgrade.IsValid(paraResults, out var tuple);
if (maxOreCountValid)
{
QuickLogger.Debug($"Function Valid: {functionString}", true);
var maxOreCountUpgrade = new MaxOreCountUpgrade
{
IsEnabled = true,
Mono = _mono,
Amount = tuple.Item2,
TechType = tuple.Item1,
Function = functionString
};
Upgrades.Add(maxOreCountUpgrade);
OnUpgradeUpdate?.Invoke(maxOreCountUpgrade);
_mono.OreGenerator.ApplyUpgrade(maxOreCountUpgrade);
upgrade = maxOreCountUpgrade;
}
else
{
QuickLogger.Debug($"Invalid Function: {functionString}", true);
}
break;
case "MinOreCount":
var minOreCountCheck = Upgrades.Any(x =>
x.UpgradeType == UpgradeFunctions.MinOreCount);
if (minOreCountCheck)
{
QuickLogger.Message("Function already implemented.", true);
return;
}
bool minOreCountValid = MinOreCountUpgrade.IsValid(paraResults, out var minTuple);
if (minOreCountValid)
{
QuickLogger.Debug($"Function Valid: {functionString}", true);
var maxOreCountUpgrade = new MaxOreCountUpgrade
{
IsEnabled = true,
Mono = _mono,
Amount = minTuple.Item2,
TechType = minTuple.Item1,
Function = functionString
};
Upgrades.Add(maxOreCountUpgrade);
upgrade = maxOreCountUpgrade;
OnUpgradeUpdate?.Invoke(maxOreCountUpgrade);
}
else
{
QuickLogger.Debug($"Invalid Function: {functionString}", true);
}
break;
case "SilkTouch":
var silkTouchCheck = Upgrades.Any(x =>
x.UpgradeType == UpgradeFunctions.SilkTouch);
if (silkTouchCheck)
{
QuickLogger.Message("Function already implemented.", true);
return;
}
bool silkTouchCheckValid = SilkTouchUpgrade.IsValid(paraResults, out var silkTouchCheckTuple);
if (silkTouchCheckValid)
{
QuickLogger.Debug($"Function Valid: {functionString}", true);
var silkTouchUpgrade = new SilkTouchUpgrade
{
IsEnabled = true,
Mono = _mono,
Amount = silkTouchCheckTuple.Item2,
TechType = silkTouchCheckTuple.Item1,
Function = functionString
};
Upgrades.Add(silkTouchUpgrade);
upgrade = silkTouchUpgrade;
OnUpgradeUpdate?.Invoke(silkTouchUpgrade);
}
else
{
QuickLogger.Debug($"Invalid Function: {functionString}", true);
}
break;
case "AutoShutDownAt":
var autoShutdownAtCheck = Upgrades.Any(x =>
x.UpgradeType == UpgradeFunctions.AutoShutdownAt);
if (autoShutdownAtCheck)
{
QuickLogger.Message("Function already implemented.", true);
return;
}
bool autoShutdownAtValid = AutoShutDownAtUpgrade.IsValid(paraResults, out var autoShutdownAt);
if (autoShutdownAtValid)
{
QuickLogger.Debug($"Function Valid: {functionString}", true);
var autoShutDownAtUpgrade = new AutoShutDownAtUpgrade {
IsEnabled = true, Mono = _mono, Time = autoShutdownAt, Function = functionString
};
Upgrades.Add(autoShutDownAtUpgrade);
upgrade = autoShutDownAtUpgrade;
OnUpgradeUpdate?.Invoke(autoShutDownAtUpgrade);
}
else
{
QuickLogger.Debug($"Invalid Function: {functionString}", true);
}
break;
case "AutoStartUpAt":
var autoStartUpAtCheck = Upgrades.Any(x =>
x.UpgradeType == UpgradeFunctions.AutoStartUpAt);
if (autoStartUpAtCheck)
{
QuickLogger.Message("Function already implemented.", true);
return;
}
bool autoStartUpAtValid = AutoStartUpAtUpgrade.IsValid(paraResults, out var autoStartUpAt);
if (autoStartUpAtValid)
{
QuickLogger.Debug($"Function Valid: {functionString}", true);
var autoStartUpAtUpgrade = new AutoStartUpAtUpgrade {
IsEnabled = true, Mono = _mono, Time = autoStartUpAt, Function = functionString
};
Upgrades.Add(autoStartUpAtUpgrade);
upgrade = autoStartUpAtUpgrade;
OnUpgradeUpdate?.Invoke(autoStartUpAtUpgrade);
}
else
{
QuickLogger.Debug($"Invalid Function: {functionString}", true);
}
break;
}
}
}
}
}
private void OnUpgradeUpdate(UpgradeFunction obj)
{
QuickLogger.Debug("Refreshing the Upgrade Page", true);
UpdateDisplayValues();
_programmingGrid.DrawPage();
}
public Task <string> UpgradeRequestAsync(UpgradeFunction upgradeFunction)
{
return(ContractHandler.SendRequestAsync(upgradeFunction));
}
public Task <TransactionReceipt> UpgradeRequestAndWaitForReceiptAsync(UpgradeFunction upgradeFunction, CancellationTokenSource cancellationToken = null)
{
return(ContractHandler.SendRequestAndWaitForReceiptAsync(upgradeFunction, cancellationToken));
}
