punkfuncgames/idle-module

IdleModule Reference

Package: com.punkfuncgames.idle | Define: PUNKFUNC_IDLE Location: Packages/com.punkfuncgames.idle/Runtime/PunkFuncGames.Idle/ Namespace: PunkFuncGames.Idle

Services

IProductionService — Per-second currency generation

• ReadOnlyReactiveProperty<BigDouble> TotalProductionRate(string currencyId)
• BigDouble GetProductionRate(string currencyId)
• RegisterProducer(string producerId, string currencyId, BigDouble baseProduction)
• SetProducerLevel(string producerId, int level)
• SetProducerMultiplier(string producerId, BigDouble multiplier)
• UnregisterProducer(string producerId)
• IEnumerable<string> GetAllProducerIds()
• string GetProducerCurrencyId(string producerId)

Implementation: ProductionService : IProductionService, ITickable, IDisposable

• Dependencies: IWalletService, IPublisher<ProductionChangedEvent>
• Ticks every 0.1s, auto-adds currency to wallet, caches rates

IUpgradeService — Purchasable upgrades with cost curves

• Observable<(string upgradeId, int level)> OnUpgradePurchased
• RegisterUpgrade(IUpgradeDefinition definition)
• bool CanAfford(string upgradeId)
• bool TryPurchase(string upgradeId, int count = 1)
• int GetLevel(string upgradeId)
• BigDouble GetCost(string upgradeId, int count = 1)
• BigDouble GetEffect(string upgradeId)
• int GetMaxAffordable(string upgradeId) — capped at 1000
• bool IsMaxLevel(string upgradeId) / bool IsUnlocked(string upgradeId)

IUpgradeDefinition — Blueprint interface:

• string Id, string CurrencyId, int MaxLevel (0=unlimited)
• BigDouble GetCost(int level), BigDouble GetEffect(int level), bool IsUnlocked()

Implementation: UpgradeService : IUpgradeService, IStartable, IDisposable

• Dependencies: IWalletService, ISaveService, IPublisher<UpgradePurchasedEvent>

IPrestigeService — Rebirth mechanics

• int PrestigeCount, BigDouble PrestigeCurrency, BigDouble PendingPrestigeCurrency
• Observable<PrestigeEvent> OnPrestige
• BigDouble CalculatePrestigeReward()
• bool CanPrestige()
• UniTask<PrestigeResult> PerformPrestigeAsync(ct)

Implementation: Minimum 1M gold, formula: floor(sqrt(totalValue / 1000) * (1 + prestigeCount * 0.1))

IOfflineProgressService — Earnings while away

• TimeSpan MaxOfflineTime (24h default), bool HasPendingProgress
• Observable<OfflineProgressResult> OnOfflineProgressCalculated
• OfflineProgressResult CalculateOfflineProgress()
• ApplyOfflineProgress(), DismissOfflineProgress(), SaveCurrentTime()

Implementation: Auto-calculates on startup if elapsed > 60s

IBoostService — Temporary multipliers

• ActivateBoost(string boostId, BigDouble multiplier, TimeSpan duration, string targetId)
• bool IsBoostActive(string boostId), TimeSpan GetRemainingTime(string boostId)
• IEnumerable<ActiveBoost> GetActiveBoosts()
• Observable<string> OnBoostExpired

IMultiplierService — Stacked multipliers from any source

• AddMultiplier(string sourceId, string targetId, BigDouble value)
• RemoveMultiplier(string sourceId, string targetId)
• BigDouble GetTotalMultiplier(string targetId) — multiplicative: m1 * m2 * m3
• IReadOnlyDictionary<string, BigDouble> GetMultiplierBreakdown(string targetId)
• Observable<(string targetId, BigDouble newTotal)> OnMultiplierChanged

ITimeService — Time with anti-cheat

• DateTime GetCurrentTime(), DateTime GetSessionStartTime(), TimeSpan GetSessionDuration()
• bool IsTimeTampered, Observable<bool> OnTimeTamperDetected
• ValidateTime(), TimeSpan GetElapsedSince(DateTime pastTime)
• Uses Steam server time if STEAMWORKS_NET, detects tamper if drift > 60s

IAutomationService — Auto-buy/click/prestige

• RegisterAutomation(string id, AutomationType type, float intervalSeconds, Func<bool> unlockCheck)
• SetEnabled(string id, bool enabled)
• bool IsUnlocked(string id), bool IsEnabled(string id)
• Observable<string> OnAutomationTriggered

AutomationType enum: AutoBuy, AutoClick, AutoPrestige

Events (all readonly structs, UTC timestamps)

| Event | Key Fields | |-------|------------| | ProductionChangedEvent | CurrencyId, OldRate, NewRate | | UpgradePurchasedEvent | UpgradeId, NewLevel, PreviousLevel, Cost | | GeneratorPurchasedEvent | GeneratorId, Count, TotalCost | | PrestigeEvent | PrestigeCount, PrestigeCurrencyEarned, ResetCurrencies | | OfflineProgressEvent | ElapsedTime, CappedTime, TotalEarnings | | BoostActivatedEvent | BoostId, Multiplier, Duration | | BoostExpiredEvent | BoostId | | AutomationTriggeredEvent | AutomationId, TargetId |

Models

ActiveBoost — BoostId, TargetId, Multiplier, RemainingTime, TotalDuration OfflineProgressResult — RawElapsed, CappedElapsed, Earnings dict, LastSaveTime, WasCapped PrestigeResult — Success, Earned, NewPrestigeCount

Utility

NumberFormatter (static):

• Format(BigDouble, NumberFormatStyle, decimals) — Suffix (K/M/B/T/aa-zz), Scientific, Engineering
• FormatTime(TimeSpan, showSeconds), FormatPerSecond(BigDouble, decimals)

Installer

IdleInstaller.Install(builder, options);
// Registers: TimeService, ProductionService, OfflineProgressService, AutomationService,
//            BoostService, MultiplierService, PrestigeService, UpgradeService
// + all 8 event brokers

Usage Pattern

public sealed class MyGameController : IStartable, ITickable, IDisposable
{
    private readonly IProductionService _production;
    private readonly IUpgradeService _upgrades;
    private readonly IMultiplierService _multipliers;
    private readonly CompositeDisposable _disposables = new();

    public MyGameController(IProductionService production, IUpgradeService upgrades,
                            IMultiplierService multipliers) { /* assign fields */ }

    public void Start()
    {
        _production.RegisterProducer("Mine", "Gold", new BigDouble(1));
        _upgrades.RegisterUpgrade(new MineUpgrade());
        _upgrades.OnUpgradePurchased
            .Subscribe(evt => _production.SetProducerLevel("Mine", evt.level))
            .AddTo(_disposables);
    }

    public void Tick()
    {
        BigDouble mult = _multipliers.GetTotalMultiplier("GoldProduction");
        foreach (string id in _production.GetAllProducerIds())
            _production.SetProducerMultiplier(id, mult);
    }

    public void Dispose() => _disposables.Dispose();
}