379 lines
14 KiB
JavaScript
379 lines
14 KiB
JavaScript
/**
|
|
* Galaxy Strike Online - Idle System
|
|
* Manages offline progression and idle mechanics
|
|
*/
|
|
|
|
class IdleSystem {
|
|
constructor(gameEngine) {
|
|
this.game = gameEngine;
|
|
|
|
// Idle settings
|
|
this.maxOfflineTime = 7 * 24 * 60 * 60 * 1000; // 7 days in milliseconds
|
|
this.lastActiveTime = Date.now();
|
|
this.accumulatedTime = 0; // Track time for resource generation
|
|
|
|
// Idle production rates (online rates)
|
|
this.productionRates = {
|
|
credits: 0.1, // 1 credit every 10 seconds (0.1 per second)
|
|
experience: 0, // no auto experience - only from dungeons
|
|
energy: 1/300 // 1 energy every 5 minutes (1/300 per second)
|
|
};
|
|
|
|
// Offline rates (different from online rates)
|
|
this.offlineProductionRates = {
|
|
credits: 1/60, // 1 credit every 1 minute (1/60 per second)
|
|
experience: 0, // no experience offline - only from dungeons
|
|
energy: 1/300 // 1 energy every 5 minutes (same as online)
|
|
};
|
|
|
|
// Offline rewards
|
|
this.offlineRewards = {
|
|
credits: 0,
|
|
experience: 0,
|
|
energy: 0,
|
|
items: []
|
|
};
|
|
|
|
// Idle bonuses
|
|
this.bonuses = {
|
|
premium: 1.0,
|
|
guild: 1.0,
|
|
research: 1.0
|
|
};
|
|
|
|
// Idle achievements
|
|
this.achievements = {
|
|
totalOfflineTime: 0,
|
|
maxOfflineSession: 0,
|
|
totalIdleCredits: 0,
|
|
totalIdleExperience: 0
|
|
};
|
|
}
|
|
|
|
async initialize() {
|
|
// Calculate offline progress if returning
|
|
this.calculateOfflineProgress();
|
|
}
|
|
|
|
calculateOfflineProgress(offlineTime = null) {
|
|
const currentTime = Date.now();
|
|
const actualOfflineTime = offlineTime || (currentTime - this.lastActiveTime);
|
|
|
|
// Cap offline time to maximum
|
|
const cappedOfflineTime = Math.min(actualOfflineTime, this.maxOfflineTime);
|
|
|
|
if (cappedOfflineTime < 60000) { // Less than 1 minute
|
|
return;
|
|
}
|
|
|
|
// Calculate production
|
|
const totalBonus = this.getTotalBonus();
|
|
const productionSeconds = cappedOfflineTime / 1000;
|
|
|
|
this.offlineRewards = {
|
|
credits: Math.floor(this.productionRates.credits * productionSeconds * totalBonus),
|
|
experience: Math.floor(this.productionRates.experience * productionSeconds * totalBonus),
|
|
energy: Math.min(
|
|
this.game.systems.player.attributes.maxEnergy,
|
|
Math.floor(this.productionRates.energy * productionSeconds)
|
|
),
|
|
items: this.generateIdleItems(cappedOfflineTime)
|
|
};
|
|
|
|
// Update achievements
|
|
this.achievements.totalOfflineTime += cappedOfflineTime;
|
|
this.achievements.maxOfflineSession = Math.max(this.achievements.maxOfflineSession, cappedOfflineTime);
|
|
this.achievements.totalIdleCredits += this.offlineRewards.credits;
|
|
this.achievements.totalIdleExperience += this.offlineRewards.experience;
|
|
|
|
// Show offline rewards notification
|
|
this.showOfflineRewards(cappedOfflineTime);
|
|
}
|
|
|
|
getTotalBonus() {
|
|
return this.bonuses.premium * this.bonuses.guild * this.bonuses.research;
|
|
}
|
|
|
|
generateIdleItems(offlineTime) {
|
|
const items = [];
|
|
const hours = offlineTime / (1000 * 60 * 60);
|
|
|
|
// Chance to find items based on offline time
|
|
const itemChance = Math.min(0.5, hours * 0.05);
|
|
|
|
if (Math.random() < itemChance) {
|
|
const itemCount = Math.floor(hours / 2) + 1;
|
|
|
|
for (let i = 0; i < itemCount; i++) {
|
|
const rarity = this.getRandomItemRarity();
|
|
const item = this.game.systems.inventory.generateItem('consumable', rarity);
|
|
items.push(item);
|
|
}
|
|
}
|
|
|
|
return items;
|
|
}
|
|
|
|
getRandomItemRarity() {
|
|
const roll = Math.random();
|
|
if (roll < 0.05) return 'legendary';
|
|
if (roll < 0.15) return 'epic';
|
|
if (roll < 0.35) return 'rare';
|
|
if (roll < 0.65) return 'uncommon';
|
|
return 'common';
|
|
}
|
|
|
|
showOfflineRewards(offlineTime) {
|
|
const timeString = this.game.formatTime(offlineTime);
|
|
|
|
this.game.showNotification(
|
|
`Welcome back! You were offline for ${timeString}`,
|
|
'info',
|
|
5000
|
|
);
|
|
|
|
// Format rewards message
|
|
let rewardsMessage = 'Offline Rewards:\n';
|
|
if (this.offlineRewards.credits > 0) {
|
|
rewardsMessage += `+${this.game.formatNumber(this.offlineRewards.credits)} credits\n`;
|
|
}
|
|
if (this.offlineRewards.experience > 0) {
|
|
rewardsMessage += `+${this.game.formatNumber(this.offlineRewards.experience)} XP\n`;
|
|
}
|
|
if (this.offlineRewards.energy > 0) {
|
|
rewardsMessage += `+${this.game.formatNumber(this.offlineRewards.energy)} energy\n`;
|
|
}
|
|
if (this.offlineRewards.items.length > 0) {
|
|
rewardsMessage += `+${this.offlineRewards.items.length} items\n`;
|
|
}
|
|
|
|
this.game.showNotification(rewardsMessage, 'success', 5000);
|
|
}
|
|
|
|
claimOfflineRewards() {
|
|
// In multiplayer mode, use server communication
|
|
if (window.smartSaveManager?.isMultiplayer) {
|
|
this.game.showNotification('Claiming offline rewards from server...', 'info', 2000);
|
|
|
|
// Send request to server
|
|
if (window.game && window.game.socket) {
|
|
window.game.socket.emit('claimOfflineRewards', {});
|
|
} else {
|
|
this.game.showNotification('Not connected to server', 'error', 3000);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Singleplayer mode - use local logic
|
|
if (this.offlineRewards.credits === 0 &&
|
|
this.offlineRewards.experience === 0 &&
|
|
this.offlineRewards.items.length === 0) {
|
|
this.game.showNotification('No offline rewards to claim', 'info', 3000);
|
|
return;
|
|
}
|
|
|
|
// Give rewards
|
|
if (this.offlineRewards.credits > 0) {
|
|
this.game.systems.economy.addCredits(this.offlineRewards.credits, 'offline');
|
|
}
|
|
|
|
if (this.offlineRewards.experience > 0) {
|
|
this.game.systems.player.addExperience(this.offlineRewards.experience);
|
|
}
|
|
|
|
if (this.offlineRewards.energy > 0) {
|
|
this.game.systems.player.restoreEnergy(this.offlineRewards.energy);
|
|
}
|
|
|
|
// Add items to inventory
|
|
if (this.offlineRewards.items.length > 0) {
|
|
const inventory = this.game.systems.inventory;
|
|
this.offlineRewards.items.forEach(item => {
|
|
inventory.addItem(item);
|
|
});
|
|
}
|
|
|
|
// Reset offline rewards
|
|
this.offlineRewards = {
|
|
credits: 0,
|
|
experience: 0,
|
|
energy: 0,
|
|
items: []
|
|
};
|
|
|
|
this.game.showNotification('Offline rewards claimed!', 'success', 3000);
|
|
}
|
|
|
|
// Active idle production
|
|
update(deltaTime) {
|
|
if (this.game.state.paused) return;
|
|
|
|
// Use real computer time delta
|
|
const seconds = deltaTime / 1000;
|
|
const totalBonus = this.getTotalBonus();
|
|
|
|
// Only add resources once per second, not every frame
|
|
this.accumulatedTime += seconds;
|
|
|
|
if (this.accumulatedTime >= 1.0) {
|
|
// Calculate active production
|
|
const activeCredits = Math.floor(this.productionRates.credits * totalBonus);
|
|
const activeExperience = Math.floor(this.productionRates.experience * totalBonus);
|
|
// const activeEnergy = this.productionRates.energy * totalBonus * 0.1; // Energy is handled differently
|
|
|
|
// Add resources
|
|
if (activeCredits > 0) {
|
|
this.game.systems.economy.addCredits(activeCredits, 'idle');
|
|
}
|
|
if (activeExperience > 0) {
|
|
this.game.systems.player.addExperience(activeExperience);
|
|
}
|
|
|
|
// Regenerate energy
|
|
this.game.systems.player.restoreEnergy(this.productionRates.energy);
|
|
|
|
// Reset accumulated time, keeping any remainder
|
|
this.accumulatedTime -= 1.0;
|
|
|
|
// Debugging: Log when resources are added
|
|
// console.debug(`[IDLE] Added ${activeCredits} credits and ${activeExperience} XP. Accumulated time: ${this.accumulatedTime.toFixed(2)}s`);
|
|
}
|
|
|
|
// Update last active time for offline calculations
|
|
this.lastActiveTime = Date.now();
|
|
}
|
|
|
|
// Upgrade production rates
|
|
upgradeProduction(type) {
|
|
const upgradeCosts = {
|
|
credits: 100,
|
|
experience: 150,
|
|
energy: 80
|
|
};
|
|
|
|
const cost = upgradeCosts[type];
|
|
if (!cost || this.game.systems.economy.credits < cost) {
|
|
return false;
|
|
}
|
|
|
|
this.game.systems.economy.removeCredits(cost);
|
|
|
|
switch (type) {
|
|
case 'credits':
|
|
this.productionRates.credits += 2;
|
|
break;
|
|
case 'experience':
|
|
this.productionRates.experience += 1;
|
|
break;
|
|
case 'energy':
|
|
this.productionRates.energy += 0.2;
|
|
break;
|
|
}
|
|
|
|
this.game.showNotification(`Production upgraded: ${type}!`, 'success', 3000);
|
|
return true;
|
|
}
|
|
|
|
// Bonus management
|
|
setBonus(type, value) {
|
|
if (this.bonuses[type] !== undefined) {
|
|
this.bonuses[type] = value;
|
|
this.game.showNotification(`${type} bonus set to ${value}x`, 'info', 3000);
|
|
}
|
|
}
|
|
|
|
// Achievement checking
|
|
checkAchievements() {
|
|
const achievements = [
|
|
{
|
|
id: 'idle_warrior',
|
|
name: 'Idle Warrior',
|
|
description: 'Earn 1,000,000 credits from idle',
|
|
condition: () => this.achievements.totalIdleCredits >= 1000000,
|
|
reward: { gems: 50, experience: 1000 }
|
|
},
|
|
{
|
|
id: 'time_master',
|
|
name: 'Time Master',
|
|
description: 'Accumulate 24 hours of offline time',
|
|
condition: () => this.achievements.totalOfflineTime >= 24 * 60 * 60 * 1000,
|
|
reward: { gems: 25, experience: 500 }
|
|
},
|
|
{
|
|
id: 'marathon_idle',
|
|
name: 'Marathon Idle',
|
|
description: 'Be offline for more than 12 hours at once',
|
|
condition: () => this.achievements.maxOfflineSession >= 12 * 60 * 60 * 1000,
|
|
reward: { gems: 100, experience: 2000 }
|
|
}
|
|
];
|
|
|
|
achievements.forEach(achievement => {
|
|
if (achievement.condition()) {
|
|
this.unlockAchievement(achievement);
|
|
}
|
|
});
|
|
}
|
|
|
|
unlockAchievement(achievement) {
|
|
this.game.showNotification(`Achievement Unlocked: ${achievement.name}!`, 'success', 5000);
|
|
this.game.showNotification(achievement.description, 'info', 3000);
|
|
|
|
// Give rewards
|
|
if (achievement.reward.gems) {
|
|
this.game.systems.economy.addGems(achievement.reward.gems, 'achievement');
|
|
}
|
|
|
|
if (achievement.reward.experience) {
|
|
this.game.systems.player.addExperience(achievement.reward.experience);
|
|
}
|
|
}
|
|
|
|
// UI updates
|
|
updateUI() {
|
|
const offlineTimeElement = document.getElementById('offlineTime');
|
|
const offlineResourcesElement = document.getElementById('offlineResources');
|
|
const claimOfflineBtn = document.getElementById('claimOfflineBtn');
|
|
|
|
if (offlineTimeElement) {
|
|
const totalRewards = this.offlineRewards.credits +
|
|
this.offlineRewards.experience +
|
|
(this.offlineRewards.items.length * 100);
|
|
offlineTimeElement.textContent = totalRewards > 0 ? 'Available' : 'None';
|
|
}
|
|
|
|
if (offlineResourcesElement) {
|
|
const totalRewards = this.offlineRewards.credits +
|
|
this.offlineRewards.experience +
|
|
(this.offlineRewards.items.length * 100);
|
|
offlineResourcesElement.textContent = this.game.formatNumber(totalRewards);
|
|
}
|
|
|
|
if (claimOfflineBtn) {
|
|
const hasRewards = this.offlineRewards.credits > 0 ||
|
|
this.offlineRewards.experience > 0 ||
|
|
this.offlineRewards.items.length > 0;
|
|
claimOfflineBtn.disabled = !hasRewards;
|
|
}
|
|
}
|
|
|
|
// Save/Load
|
|
save() {
|
|
return {
|
|
lastActiveTime: this.lastActiveTime,
|
|
productionRates: this.productionRates,
|
|
bonuses: this.bonuses,
|
|
achievements: this.achievements,
|
|
offlineRewards: this.offlineRewards
|
|
};
|
|
}
|
|
|
|
load(data) {
|
|
if (data.lastActiveTime) this.lastActiveTime = data.lastActiveTime;
|
|
if (data.productionRates) this.productionRates = { ...this.productionRates, ...data.productionRates };
|
|
if (data.bonuses) this.bonuses = { ...this.bonuses, ...data.bonuses };
|
|
if (data.achievements) this.achievements = { ...this.achievements, ...data.achievements };
|
|
if (data.offlineRewards) this.offlineRewards = data.offlineRewards;
|
|
}
|
|
}
|