private void InitializeUpgradeHandlers()
{
QuickLogger.Debug($"UpgradeManager adding new UpgradeHandlers from external mods");
// First, register upgrades from other mods.
foreach (KeyValuePair <CreateUpgradeHandler, string> pair in HandlerCreators)
{
CreateUpgradeHandler upgradeHandlerCreator = pair.Key;
string assemblyName = pair.Value;
UpgradeHandler upgrade = upgradeHandlerCreator.Invoke(Cyclops);
if (upgrade == null)
{
QuickLogger.Warning($"UpgradeHandler from '{assemblyName}' was null");
}
else if (!KnownsUpgradeModules.ContainsKey(upgrade.TechType))
{
upgrade.RegisterSelf(KnownsUpgradeModules);
}
else
{
QuickLogger.Warning($"Duplicate UpgradeHandler for '{upgrade.TechType.AsString()}' from '{assemblyName}' was blocked");
}
}
// Next, if no external mod has provided an UpgradeHandler for the vanilla upgrades, they will be added here.
// This is to allow other mods to provide new functionality to the original upgrades.
QuickLogger.Debug($"UpgradeManager adding default UpgradeHandlers for unmanaged vanilla upgrades");
for (int i = 0; i < vanillaUpgrades.OriginalUpgradeIDs.Count; i++)
{
TechType upgradeID = vanillaUpgrades.OriginalUpgradeIDs[i];
if (!KnownsUpgradeModules.ContainsKey(upgradeID))
{
UpgradeHandler vanillaUpgrade = vanillaUpgrades.CreateUpgradeHandler(upgradeID, Cyclops);
vanillaUpgrade.RegisterSelf(KnownsUpgradeModules);
}
}
upgradeHandlers = new UpgradeHandler[KnownsUpgradeModules.Count];
int u = 0;
foreach (UpgradeHandler upgrade in KnownsUpgradeModules.Values)
{
upgradeHandlers[u++] = upgrade;
}
QuickLogger.Debug("Attaching events to Engine Room Upgrade Console");
if (engineRoomUpgradeConsole == null)
{
engineRoomUpgradeConsole = Cyclops.upgradeConsole.modules;
}
AttachEquipmentEvents(ref engineRoomUpgradeConsole);
initialized = true;
TooLateToRegister = true;
}
// Use this for initialization
void Start()
{
upgradeHandler = UpgradeHandler.instance;
formatter = NumberFormatter.instance;
costDisplay.text = formatter.FormatNumber(Cost);
multiplierDisplay.text = GetMultiplier().ToString("N1") + "x coins from clicks";
}
private void SetupPowerManagerUpgrades(PowerManager powerManager, int maxModules)
{
RegisterOneTimeUseHandlerCreator(() =>
{
QuickLogger.Debug("UpgradeHandler Registered: Engine Upgrades Collection");
var efficiencyUpgrades = new TieredUpgradesHandlerCollection <int>(0);
QuickLogger.Debug("UpgradeHandler Registered: Engine Upgrade Mk1");
TieredUpgradeHandler <int> engine1 = efficiencyUpgrades.CreateTier(TechType.PowerUpgradeModule, 1);
QuickLogger.Debug("UpgradeHandler Registered: Engine Upgrade Mk2");
TieredUpgradeHandler <int> engine2 = efficiencyUpgrades.CreateTier(CyclopsModule.PowerUpgradeMk2ID, 2);
QuickLogger.Debug("UpgradeHandler Registered: Engine Upgrade Mk3");
TieredUpgradeHandler <int> engine3 = efficiencyUpgrades.CreateTier(CyclopsModule.PowerUpgradeMk3ID, 3);
powerManager.EngineEfficientyUpgrades = efficiencyUpgrades;
return(efficiencyUpgrades);
});
RegisterOneTimeUseHandlerCreator(() =>
{
QuickLogger.Debug("UpgradeHandler Registered: SpeedBooster Upgrade");
var speed = new UpgradeHandler(CyclopsModule.SpeedBoosterModuleID)
{
MaxCount = maxModules,
OnFirstTimeMaxCountReached = () =>
{
ErrorMessage.AddMessage(CyclopsSpeedBooster.MaxRatingAchived);
}
};
powerManager.SpeedBoosters = speed;
return(speed);
});
}
// Start is called before the first frame update
void Start()
{
player = Player.instance;
coinDrop = CoinDrop.instance;
clicker = Clicker.instance;
upgradeHandler = UpgradeHandler.instance;
}
void Start()
{
player = Player.instance;
upgradeHandler = UpgradeHandler.instance;
tierHandler = TierHandler.instance;
LoadGameData();
}
public void HandleUpgrades()
{
if (!initialized)
{
InitializeUpgradeHandlers();
}
QuickLogger.Debug($"UpgradeManager clearing cyclops upgrades");
// Turn off all upgrades and clear all values
for (int i = 0; i < upgradeHandlers.Length; i++)
{
UpgradeHandler upgradeType = upgradeHandlers[i];
if (upgradeType.HasUpgrade)
{
QuickLogger.Debug($"UpgradeManager clearing {upgradeType.TechType.AsString()}");
}
upgradeType.UpgradesCleared(); // UpgradeHandler event
}
bool foundUpgrades = false;
// Go through all slots and check what upgrades are available
QuickLogger.Debug($"UpgradeManager checking upgrade slots");
foreach (UpgradeSlot upgradeSlot in this.UpgradeSlots)
{
TechType techTypeInSlot = upgradeSlot.GetTechTypeInSlot();
if (techTypeInSlot == TechType.None)
{
continue;
}
foundUpgrades = true;
if (KnownsUpgradeModules.TryGetValue(techTypeInSlot, out UpgradeHandler handler))
{
QuickLogger.Debug($"UpgradeManager counting cyclops upgrade '{techTypeInSlot.AsString()}'");
handler.UpgradeCounted(upgradeSlot); // UpgradeHandler event
}
else
{
QuickLogger.Warning($"UpgradeManager encountered unmanaged cyclops upgrade '{techTypeInSlot.AsString()}'");
}
}
for (int i = 0; i < upgradeHandlers.Length; i++)
{
upgradeHandlers[i].UpgradesFinished(); // UpgradeHandler event
}
// If any upgrades were found, play the sound to alert the player
if (foundUpgrades)
{
Cyclops.slotModSFX?.Play();
PdaOverlayManager.RemapItems();
}
}
// Start is called before the first frame update
void Start()
{
purchaseHandler = PurchaseHandler.instance;
upgradeHandler = UpgradeHandler.instance;
tooltip = Tooltip.instance;
formatter = NumberFormatter.instance;
upgradeHandler.UnlockUpgrades(1);
}
// Start is called before the first frame update
void Start()
{
player = Player.instance;
auto = Autoclicker.instance;
clicker = Clicker.instance;
options = Options.instance;
multi = Multiplier.instance;
upgradeHandler = UpgradeHandler.instance;
}
// Start is called before the first frame update
void Start()
{
player = Player.instance;
multi = Multiplier.instance;
autoclicker = Autoclicker.instance;
progressBar = ProgressBarHandler.instance;
rectTransform = GetComponent <RectTransform>();
tooltipText = transform.GetChild(0).GetComponent <Text>();
upgradeHandler = UpgradeHandler.instance;
}
// Start is called before the first frame update
void Start()
{
player = Player.instance;
clicker = Clicker.instance;
multi = Multiplier.instance;
platinum = DiamondUpgrades.instance;
drop = CoinDrop.instance;
upgradeHandler = UpgradeHandler.instance;
tierHandler = TierHandler.instance;
}
// Start is called before the first frame update
void Start()
{
tooltip = Tooltip.instance;
bar = NavigationBar.instance;
autoclicker = Autoclicker.instance;
multiplier = Multiplier.instance;
upgradeHandler = UpgradeHandler.instance;
button = GetComponent <Button>();
button.onClick.AddListener(Toggle);
}
public void SetReferences () {
player = Player.instance;
multi = Multiplier.instance;
autoclicker = Autoclicker.instance;
progressBar = ProgressBarHandler.instance;
upgradeHandler = UpgradeHandler.instance;
clicker = Clicker.instance;
purchaseHandler = PurchaseHandler.instance;
numberFormatter = NumberFormatter.instance;
tooltip = Tooltip.instance;
image = GetComponent<Image>();
}
private void Start()
{
upgradeHandler = GameObject.Find("UpgradeHandler").GetComponent <UpgradeHandler>();
infoText = GameObject.Find("InfoText").GetComponent <Text>();
playerHandler = GameObject.Find("PlayerHandler").GetComponent <PlayerHandler>();
button = GetComponent <Button>();
button.onClick.AddListener(OnClick);
if (cell == null)
{
return;
}
cellScript = cell.GetComponent <Cell>();
}
private void Awake()
{
if (instance == null)
{
instance = this;
data = new PlayerData();
DontDestroyOnLoad(gameObject);
}
else
{
Destroy(gameObject);
}
}
private static void BuildUpgradeHandlers(UpgradeServiceAccessor serviceAccessor, IServiceContainer serviceContainer)
{
// Getting user handlers
var userHandlers =
from handler in serviceContainer.GetAll <IUpgradeHandler>()
let assembly = handler.Assembly ?? handler.GetType().Assembly
where handler.IsEnabled
group handler by assembly;
// Adding user handlers
var handlers = new Dictionary <Assembly, IUpgradeHandler>();
foreach (var group in userHandlers)
{
var candidates = group.ToList();
if (candidates.Count > 1)
{
throw new DomainBuilderException(
string.Format(Strings.ExMoreThanOneEnabledXIsProvidedForAssemblyY, typeof(IUpgradeHandler).GetShortName(), @group.Key));
}
handlers.Add(group.Key, candidates[0]);
}
// Adding default handlers
var assembliesWithUserHandlers = handlers.Select(pair => pair.Key);
var assembliesWithoutUserHandler =
serviceAccessor.Configuration.Types.PersistentTypes
.Select(type => type.Assembly)
.Distinct()
.Except(assembliesWithUserHandlers);
foreach (var assembly in assembliesWithoutUserHandler)
{
var handler = new UpgradeHandler(assembly);
handlers.Add(assembly, handler);
}
// Building a list of handlers sorted by dependencies of their assemblies
var dependencies = handlers.Keys.ToDictionary(
assembly => assembly,
assembly => new HashSet <string>(assembly.GetReferencedAssemblies().Select(assemblyName => assemblyName.ToString())));
var sortedHandlers = handlers
.SortTopologically((a0, a1) => dependencies[a1.Key].Contains(a0.Key.GetName().ToString()))
.Select(pair => pair.Value);
// Storing the result
serviceAccessor.UpgradeHandlers =
new ReadOnlyDictionary <Assembly, IUpgradeHandler>(handlers);
serviceAccessor.OrderedUpgradeHandlers =
new ReadOnlyList <IUpgradeHandler>(sortedHandlers.ToList());
}
public void Generatehandlers()
{
//if(UpgradeManagers.Count > 1)
//{
// return;
//}
foreach (var Key in UpgradeKeys)
{
var uh = new UpgradeHandler();
uh.upgradedunit = Key;
upgradeHandlers.Add(uh);
Debug.Log(Key + " handler has been added to the game" + upgradeHandlers.Count.ToString() + upgradeHandlers[0].upgradedunit);
}
}
public void UpgradeHandlerGetsActivated()
{
UpgradeHandler upgradeHandler = new UpgradeHandler();
var codec = NewCodec(upgradeHandler);
EmbeddedChannel ch = new EmbeddedChannel(codec, NewMultiplexer(upgradeHandler));
codec.OnHttpClientUpgrade();
Assert.False(upgradeHandler._stateOnActive.LocalSideOpen());
Assert.True(upgradeHandler._stateOnActive.RemoteSideOpen());
Assert.NotNull(codec.Connection.Stream(Http2CodecUtil.HttpUpgradeStreamId).GetProperty <object>(codec._streamKey));
Assert.Equal(Http2CodecUtil.HttpUpgradeStreamId, upgradeHandler._streamId);
Assert.True(ch.FinishAndReleaseAll());
Assert.True(upgradeHandler._channelInactiveCalled);
}
protected virtual void OnUpgrade(LinkedListNode <ICacheItem> item)
{
lock (this)
{
if (item.List == mItemLink)
{
ICacheItem data = item.Value;
mItemLink.Remove(item);
mItemTable.Remove(data.Key);
if (UpgradeHandler != null)
{
UpgradeHandler.Upgrade(data, this);
}
}
}
}
private void RegisterUpgradeHandlers()
{
// Register upgrades from other mods
foreach (HandlerCreator upgradeHandlerCreator in ReusableUpgradeHandlers)
{
UpgradeHandler upgrade = upgradeHandlerCreator.Invoke();
upgrade.RegisterSelf(KnownsUpgradeModules);
}
foreach (HandlerCreator upgradeHandlerCreator in OneTimeUseUpgradeHandlers)
{
UpgradeHandler upgrade = upgradeHandlerCreator.Invoke();
upgrade.RegisterSelf(KnownsUpgradeModules);
}
OneTimeUseUpgradeHandlers.Clear();
}
private IEnumerator GetMCUHandler()
{
SNLogger.Debug("CyclopsLaserCannonModule", $"GetMCUHandler coroutine started for this Cyclops: {This_Cyclops_Root.GetInstanceID()}");
while (upgradeHandler == null)
{
upgradeHandler = MCUServices.Find.CyclopsUpgradeHandler(subroot, CannonPrefab.TechTypeID);
SNLogger.Debug("CyclopsLaserCannonModule", $"MCU UpgradeHandler is not ready for this Cyclops: {This_Cyclops_Root.GetInstanceID()}");
yield return(null);
}
SNLogger.Debug("CyclopsLaserCannonModule", $"MCU UpgradeHandler is ready for this Cyclops: {This_Cyclops_Root.GetInstanceID()}");
upgradeHandler.OnFinishedUpgrades = OnFinishedUpgrades;
upgradeHandler.OnClearUpgrades = OnClearUpgrades;
OnFirstTimeCheckModuleIsExists();
SNLogger.Debug("CyclopsLaserCannonModule", $"GetMCUHandler coroutine stopped for this Cyclops: {This_Cyclops_Root.GetInstanceID()}");
yield break;
}
private void Start()
{
upgradeHandler = GetComponent <UpgradeHandler>();
sceneManagerFsm = GetComponent <PlayMakerFSM>();
}
public void HandleUpgrades()
{
if (!initialized)
{
InitializeUpgradeHandlers();
}
QuickLogger.Debug($"UpgradeManager clearing cyclops upgrades");
// Turn off all upgrades and clear all values
for (int i = 0; i < upgradeHandlers.Length; i++)
{
UpgradeHandler upgradeType = upgradeHandlers[i];
if (upgradeType.HasUpgrade)
{
QuickLogger.Debug($"UpgradeManager clearing {upgradeType.TechType.AsString()}");
}
upgradeType.UpgradesCleared(); // UpgradeHandler event
}
var foundUpgrades = new List <TechType>();
// Go through all slots and check what upgrades are available
QuickLogger.Debug($"UpgradeManager checking upgrade slots");
foreach (UpgradeSlot upgradeSlot in this.UpgradeSlots)
{
Equipment modules = upgradeSlot.Modules;
string slot = upgradeSlot.Slot;
TechType techTypeInSlot = modules.GetTechTypeInSlot(slot);
if (techTypeInSlot == TechType.None)
{
continue;
}
foundUpgrades.Add(techTypeInSlot);
if (KnownsUpgradeModules.TryGetValue(techTypeInSlot, out UpgradeHandler handler))
{
QuickLogger.Debug($"UpgradeManager counting cyclops upgrade '{techTypeInSlot.AsString()}'");
handler.UpgradeCounted(modules, slot); // UpgradeHandler event
}
else
{
QuickLogger.Warning($"UpgradeManager encountered unmanaged cyclops upgrade '{techTypeInSlot.AsString()}'");
}
}
for (int i = 0; i < upgradeHandlers.Length; i++)
{
upgradeHandlers[i].UpgradesFinished(); // UpgradeHandler event
}
// If any upgrades were found, play the sound to alert the player
if (foundUpgrades.Count > 0)
{
Cyclops.slotModSFX?.Play();
PdaOverlayManager.RemapItems();
}
Cyclops.BroadcastMessage("RefreshUpgradeConsoleIcons", foundUpgrades.ToArray(), SendMessageOptions.RequireReceiver);
}
private void Awake()
{
instance = this;
}
protected void Start()
{
upgradeHandler = GetComponent <UpgradeHandler>();
LoadEnemy(EnemyId);
}
private void Awake()
{
upgradeHandler = GetComponent <UpgradeHandler>();
LoadMainCharacter();
}
