You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
672 lines
25 KiB
672 lines
25 KiB
let game = new Vue({ |
|
el: '#root', |
|
data: { |
|
version: 0.6, |
|
debug: { |
|
levelSandbox: false, |
|
buildingsSandbox: false |
|
}, |
|
resources: { |
|
gold: { |
|
amount: 500, |
|
name: 'Gold', |
|
worth: 100, |
|
icon: 'img/gold.png', |
|
unlocked: true |
|
}, |
|
wood: { |
|
amount: 0, |
|
name: 'Wood', |
|
worth: 10, |
|
icon: 'img/wood.png', |
|
unlocked: false |
|
}, |
|
stone: { |
|
amount: 0, |
|
name: 'Stone', |
|
worth: 25, |
|
icon: 'img/stone.png', |
|
unlocked: false |
|
}, |
|
iron: { |
|
amount: 0, |
|
name: 'Iron', |
|
worth: 100, |
|
icon: 'img/iron.png', |
|
unlocked: false |
|
}, |
|
bricks: { |
|
amount: 0, |
|
name: 'Bricks', |
|
worth: 200, |
|
icon: 'img/bricks.png', |
|
unlocked: false |
|
}, |
|
corn: { |
|
amount: 0, |
|
name: 'Corn', |
|
worth: 75, |
|
icon: 'img/corn.png', |
|
unlocked: false |
|
}, |
|
coal: { |
|
amount: 0, |
|
name: 'Coal', |
|
worth: 25, |
|
icon: 'img/coal.png', |
|
unlocked: false |
|
}, |
|
planks: { |
|
amount: 0, |
|
name: 'Planks', |
|
worth: 100, |
|
icon: 'img/planks.png', |
|
unlocked: false |
|
} |
|
}, |
|
storageNames: null, |
|
buildings: [ |
|
{ |
|
name: 'Bank', |
|
resource: 'gold', |
|
icon: 'medieval_largeCastle', |
|
level: 1, |
|
maxLevel: 10, |
|
isOwned: true, |
|
isUpgradeable: true, |
|
amount: 100, |
|
intervalInSeconds: 15, |
|
price: 500, |
|
amountPerLevel: [100, 250, 500, 750, 1000, 1500, 2000, 2500, 3000, 5000], |
|
pricePerLevel: [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000], |
|
intervalPerLevel: [15, 25, 30, 45, 60, 90, 90, 120, 120, 120], |
|
}, |
|
{ |
|
name: 'Lumberjack', |
|
resource: 'wood', |
|
icon: 'medieval_lumber', |
|
level: 0, |
|
maxLevel: 10, |
|
isOwned: false, |
|
isUpgradeable: true, |
|
amount: 2, |
|
intervalInSeconds: 10, |
|
price: 500, |
|
amountPerLevel: [100, 250, 500, 750, 1000, 1500, 2000, 2500, 3000, 5000], |
|
pricePerLevel: [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000], |
|
intervalPerLevel: [15, 25, 30, 45, 60, 90, 90, 120, 120, 120], |
|
}, |
|
{ |
|
name: 'Carpenter', |
|
resource: 'planks', |
|
icon: 'medieval_lumber', |
|
level: 0, |
|
maxLevel: 10, |
|
isOwned: false, |
|
isUpgradeable: true, |
|
amount: 5, |
|
intervalInSeconds: 25, |
|
price: 500, |
|
hasRequirements: true, |
|
requires: { |
|
wood: 2 |
|
}, |
|
amountPerLevel: [100, 250, 500, 750, 1000, 1500, 2000, 2500, 3000, 5000], |
|
pricePerLevel: [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000], |
|
intervalPerLevel: [15, 25, 30, 45, 60, 90, 90, 120, 120, 120], |
|
}, |
|
{ |
|
name: 'Quarry', |
|
resource: 'stone', |
|
icon: 'medieval_mine', |
|
level: 0, |
|
maxLevel: 10, |
|
isOwned: false, |
|
isUpgradeable: true, |
|
amount: 2, |
|
intervalInSeconds: 20, |
|
price: 500, |
|
amountPerLevel: [100, 250, 500, 750, 1000, 1500, 2000, 2500, 3000, 5000], |
|
pricePerLevel: [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000], |
|
intervalPerLevel: [15, 25, 30, 45, 60, 90, 90, 120, 120, 120], |
|
}, |
|
{ |
|
name: 'Coal Mine', |
|
resource: 'coal', |
|
icon: 'medieval_mine', |
|
level: 0, |
|
maxLevel: 10, |
|
isOwned: false, |
|
isUpgradeable: true, |
|
amount: 2, |
|
intervalInSeconds: 20, |
|
price: 500, |
|
amountPerLevel: [100, 250, 500, 750, 1000, 1500, 2000, 2500, 3000, 5000], |
|
pricePerLevel: [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000], |
|
intervalPerLevel: [15, 25, 30, 45, 60, 90, 90, 120, 120, 120], |
|
}, |
|
// { |
|
// name: 'Blacksmith', |
|
// resource: 'iron', |
|
// icon: 'medieval_blacksmith', |
|
// level: 0, |
|
// maxLevel: 10, |
|
// isOwned: false, |
|
// isUpgradeable: true, |
|
// amount: 2, |
|
// intervalInSeconds: 20, |
|
// price: 500, |
|
// hasRequirements: true, |
|
// requires: { |
|
// stone: 2, |
|
// coal: 1 |
|
// }, |
|
// amountPerLevel: [100, 250, 500, 750, 1000, 1500, 2000, 2500, 3000, 5000], |
|
// pricePerLevel: [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000], |
|
// intervalPerLevel: [15, 25, 30, 45, 60, 90, 90, 120, 120, 120], |
|
// }, |
|
{ |
|
name: 'Farm', |
|
resource: 'corn', |
|
icon: 'medieval_farm', |
|
level: 0, |
|
maxLevel: 25, |
|
isOwned: false, |
|
isUpgradeable: true, |
|
amount: 5, |
|
price: 500, |
|
intervalInSeconds: 60, |
|
amountPerLevel: [100, 250, 500, 750, 1000, 1500, 2000, 2500, 3000, 5000], |
|
pricePerLevel: [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000], |
|
intervalPerLevel: [15, 25, 30, 45, 60, 90, 90, 120, 120, 120], |
|
}, |
|
], |
|
currentQuest: null, |
|
loadedIntervals: [] |
|
}, |
|
created() { |
|
this.storageNames = { |
|
lastVersion: 'lastVersion', |
|
resources: 'resources' + this.version, |
|
buildings: 'buildings' + this.version, |
|
currentQuest: 'currentQuest' + this.version |
|
} |
|
|
|
this.checkVersion(); |
|
|
|
this.checkBuildings(); |
|
this.loadResourcesFromStorage(); |
|
this.currentQuest = JSON.parse(localStorage.getItem(this.storageNames.currentQuest)); |
|
|
|
this.loadBuildingsFromStorage(); |
|
this.reloadBuildings(); |
|
}, |
|
methods: { |
|
// System & Saving |
|
// Check if a new version is played and notify the user of the loss of his beloved score & progress |
|
checkVersion() { |
|
let lastVersion = localStorage.getItem(this.storageNames.lastVersion); |
|
|
|
if (lastVersion && lastVersion < this.version) { |
|
this.sendSystemNotification('Your beta-progress has been resetted due to a new version of the game, we\'re very sorry about that.') |
|
} |
|
|
|
localStorage.setItem(this.storageNames.lastVersion, this.version); |
|
}, |
|
|
|
// Check if buildings-array is outdated |
|
checkBuildings() { |
|
let savedBuildings = JSON.parse(localStorage.getItem(this.storageNames.buildings)); |
|
|
|
if (!savedBuildings) { |
|
localStorage.setItem(this.storageNames.buildings, JSON.stringify(this.buildings)); |
|
} else if (savedBuildings.length !== this.buildings.length) { |
|
localStorage.setItem(this.storageNames.buildings, JSON.stringify(this.buildings)); |
|
this.sendInfo('Buildings have been resetted due to an important update.'); |
|
} |
|
}, |
|
|
|
// Save buildings with progress -> has to resetted while in beta via version |
|
saveBuildingsToStorage() { |
|
localStorage.setItem(this.storageNames.buildings, JSON.stringify(this.buildings)); |
|
}, |
|
|
|
loadBuildingsFromStorage() { |
|
let savedBuildings = JSON.parse(localStorage.getItem(this.storageNames.buildings)); |
|
|
|
if (savedBuildings) { |
|
savedBuildings.forEach((building) => { |
|
if (building.isOwned) { |
|
building.loader = 0; |
|
} |
|
|
|
if (building.hasMissingResources) { |
|
building.loader = 100; |
|
} |
|
}); |
|
|
|
this.buildings = savedBuildings; |
|
} |
|
}, |
|
|
|
// Save resources a user has |
|
saveResourcesToStorage() { |
|
localStorage.setItem(this.storageNames.resources, JSON.stringify(this.resources)); |
|
}, |
|
|
|
loadResourcesFromStorage: function () { |
|
let savedResources = JSON.parse(localStorage.getItem(this.storageNames.resources)); |
|
|
|
if (savedResources) { |
|
this.resources = savedResources; |
|
} |
|
}, |
|
|
|
// Resource-Management |
|
add(amount = 0, resource = 'gold') { |
|
switch (resource) { |
|
case 'wood': |
|
this.sendResourceMessage(amount, 'wood'); |
|
console.log(this.resources.wood.amount, amount); |
|
this.resources.wood.amount += amount; |
|
this.resources.wood.unlocked = true; |
|
break; |
|
case 'planks': |
|
this.sendResourceMessage(amount, 'planks'); |
|
this.resources.planks.amount += amount; |
|
this.resources.planks.unlocked = true; |
|
break; |
|
case 'stone': |
|
this.sendResourceMessage(amount, 'stone'); |
|
this.resources.stone.amount += amount; |
|
this.resources.stone.unlocked = true; |
|
break; |
|
case 'bricks': |
|
this.sendResourceMessage(amount, 'bricks'); |
|
this.resources.bricks.amount += amount; |
|
this.resources.bricks.unlocked = true; |
|
break; |
|
case 'coal': |
|
this.sendResourceMessage(amount, 'coal'); |
|
this.resources.coal.amount += amount; |
|
this.resources.coal.unlocked = true; |
|
break; |
|
case 'iron': |
|
this.sendResourceMessage(amount, 'iron'); |
|
this.resources.iron.amount += amount; |
|
this.resources.iron.unlocked = true; |
|
break; |
|
case 'corn': |
|
this.sendResourceMessage(amount, 'corn'); |
|
this.resources.corn.amount += amount; |
|
this.resources.corn.unlocked = true; |
|
break; |
|
case 'gold': |
|
this.sendResourceMessage(amount, 'gold'); |
|
this.resources.gold.amount += amount; |
|
this.resources.gold.unlocked = true; |
|
break; |
|
} |
|
|
|
this.$forceUpdate(); |
|
this.saveResourcesToStorage(); |
|
}, |
|
|
|
sub(amount = 0, resource = false) { |
|
this.resources.gold.amount -= amount; |
|
return this.saveResourcesToStorage(); |
|
}, |
|
|
|
// Buying & upgrading buildings + checks + interval-generators |
|
reloadBuildings() { |
|
let vue = this; |
|
|
|
this.buildings.forEach((building) => { |
|
if (building.isOwned && !building.hasMissingResources) { |
|
building.price = building.pricePerLevel[building.level -1]; |
|
building.amount = building.amountPerLevel[building.level -1]; |
|
building.interval = building.intervalPerLevel[building.level -1]; |
|
vue.initiateIntervals(building); |
|
} |
|
}); |
|
}, |
|
|
|
initiateIntervals(building) { |
|
building.intervalEarnID = setInterval(() => { |
|
if (building.requires) { |
|
if ( |
|
game.buildingHasEnoughResourcesToStart(building) |
|
) { |
|
building.hasMissingResources = true; |
|
game.sendWarning(building.name + ' has stopped production of ' + building.resource + ' due to missing resources.') |
|
clearInterval(building.intervalLoadingID); |
|
game.saveBuildingsToStorage(); |
|
} else { |
|
building.hasMissingResources = false; |
|
game.sendWarning(building.name + ' has resumed production of ' + building.resource + '.') |
|
game.useRequiredResources(building); |
|
game.add(building.amount, building.resource); |
|
game.reloadSingleBuilding(building); |
|
} |
|
} else { |
|
game.add(building.amount, building.resource); |
|
} |
|
}, building.intervalInSeconds * 1000); |
|
|
|
if (this.buildingHasEnoughResourcesToStart(building)) { |
|
building.intervalLoadingID = setInterval(() => { |
|
if (building.loader < 100) { |
|
building.loader += 10; |
|
} else { |
|
building.loader = 10; |
|
} |
|
|
|
game.$forceUpdate() |
|
}, building.intervalInSeconds / 10 * 1000) |
|
} |
|
|
|
this.loadedIntervals.push(building.intervalEarnID, building.intervalLoadingID); |
|
}, |
|
|
|
buyBuilding(building) { |
|
if (this.resources.gold.amount >= building.price) { |
|
this.sub(building.price); |
|
building.isOwned = true; |
|
building.price = building.pricePerLevel[0]; |
|
building.amount = building.amountPerLevel[0]; |
|
building.interval = building.intervalPerLevel[0]; |
|
|
|
this.upgradeBuilding(building, true); |
|
this.saveBuildingsToStorage(); |
|
} else { |
|
this.sendWarning('Not enough gold'); |
|
} |
|
}, |
|
|
|
buyUpgrade(building) { |
|
if (building.level === building.maxLevel) { |
|
this.sendWarning('Already at MAX-Level'); |
|
return false; |
|
} |
|
|
|
if (this.resources.gold.amount >= building.price) { |
|
this.sub(building.price); |
|
this.upgradeBuilding(building); |
|
} else { |
|
this.sendWarning('Not enough gold'); |
|
} |
|
}, |
|
|
|
upgradeBuilding(building, first = false) { |
|
if (building.level < (building.maxLevel)) { |
|
building.level++; |
|
|
|
if (building.level === building.maxLevel) { |
|
building.isUpgradeable = false; |
|
} |
|
} else { |
|
building.isUpgradeable = false; |
|
this.sendWarning('Building is already at max-level.') |
|
return false; |
|
} |
|
|
|
building.price = building.pricePerLevel[building.level - 1]; |
|
building.amount = building.amountPerLevel[building.level - 1]; |
|
|
|
if (first === false) { |
|
building.intervalInSeconds = building.intervalPerLevel[building.level - 1]; |
|
} |
|
|
|
this.reloadSingleBuilding(building); |
|
this.saveBuildingsToStorage(); |
|
}, |
|
|
|
reloadSingleBuilding(building) { |
|
clearInterval(building.intervalEarnID); |
|
clearInterval(building.intervalLoadingID); |
|
building.loader = 0; |
|
|
|
this.initiateIntervals(building); |
|
}, |
|
|
|
buildingHasEnoughResourcesToStart(building) { |
|
if (building.requires) { |
|
return ( |
|
building.requires.wood > this.resources.wood.amount || |
|
building.requires.stone > this.resources.stone.amount || |
|
building.requires.iron > this.resources.iron.amount || |
|
building.requires.bricks > this.resources.bricks.amount || |
|
building.requires.coal > this.resources.coal.amount || |
|
building.requires.corn > this.resources.corn.amount |
|
); |
|
} else { |
|
return true; |
|
} |
|
}, |
|
|
|
// Quests |
|
generateQuestWithRandomItems() { |
|
// defines the rates of possible amounts of resources for quests |
|
let possibleAmountsForQuest = [ |
|
0, 0, 0, 0, 5, 10, 15, 20, 25, 30, 35, 5, 10, 15, 20, 25, 30, 35, 50 |
|
]; |
|
|
|
let randomWood = 0; |
|
let randomStone = 0; |
|
let randomIron = 0; |
|
let randomBricks = 0; |
|
let randomCorn = 0; |
|
let randomCoal = 0; |
|
let randomPlanks = 0; |
|
|
|
let rewardSum = 0; |
|
|
|
if (this.resources.wood.unlocked > 0) { |
|
randomWood = this.getRandomElementForQuestResource(possibleAmountsForQuest); |
|
rewardSum += (randomWood * this.resources.wood.worth); |
|
} |
|
|
|
if (this.resources.stone.unlocked > 0) { |
|
randomStone = this.getRandomElementForQuestResource(possibleAmountsForQuest); |
|
rewardSum += (randomStone * this.resources.stone.worth); |
|
} |
|
|
|
if (this.resources.iron.unlocked > 0) { |
|
randomIron = this.getRandomElementForQuestResource(possibleAmountsForQuest); |
|
rewardSum += (randomIron * this.resources.iron.worth); |
|
} |
|
|
|
if (this.resources.bricks.unlocked > 0) { |
|
randomBricks = this.getRandomElementForQuestResource(possibleAmountsForQuest); |
|
rewardSum += (randomBricks * this.resources.bricks.worth); |
|
} |
|
|
|
if (this.resources.corn.unlocked > 0) { |
|
randomCorn = this.getRandomElementForQuestResource(possibleAmountsForQuest); |
|
rewardSum += (randomCorn * this.resources.corn.worth); |
|
} |
|
|
|
if (this.resources.coal.unlocked > 0) { |
|
randomCoal = this.getRandomElementForQuestResource(possibleAmountsForQuest); |
|
rewardSum += (randomCoal * this.resources.coal.worth); |
|
} |
|
|
|
if (this.resources.planks.unlocked > 0) { |
|
randomPlanks = this.getRandomElementForQuestResource(possibleAmountsForQuest); |
|
rewardSum += (randomPlanks * this.resources.planks.worth); |
|
} |
|
|
|
if (rewardSum > 0) { |
|
this.currentQuest = { |
|
wood: randomWood, |
|
planks: randomPlanks, |
|
stone: randomStone, |
|
coal: randomCoal, |
|
iron: randomIron, |
|
bricks: randomBricks, |
|
corn: randomCorn, |
|
reward: rewardSum |
|
}; |
|
} else { |
|
this.currentQuest = null; |
|
this.sendInfo('There are no quests available. Please try again.') |
|
} |
|
|
|
localStorage.setItem(this.storageNames.currentQuest, JSON.stringify(this.currentQuest)); |
|
return this.currentQuest; |
|
}, |
|
|
|
getRandomElementForQuestResource(possibleValues) { |
|
return possibleValues[Math.floor(Math.random() * possibleValues.length)]; |
|
}, |
|
|
|
isQuestRedeemable() { |
|
let enoughWood = this.resources.wood.amount >= this.currentQuest.wood; |
|
let enoughStone = this.resources.stone.amount >= this.currentQuest.stone; |
|
let enoughIron = this.resources.iron.amount >= this.currentQuest.iron; |
|
let enoughBricks = this.resources.bricks.amount >= this.currentQuest.bricks; |
|
let enoughCorn = this.resources.corn.amount >= this.currentQuest.corn; |
|
let enoughCoal = this.resources.coal.amount >= this.currentQuest.coal; |
|
|
|
if (enoughWood && enoughStone && enoughIron && enoughBricks && enoughCorn && enoughCoal) { |
|
return true; |
|
} else { |
|
return false; |
|
} |
|
}, |
|
|
|
redeemReward() { |
|
if (this.isQuestRedeemable()) { |
|
this.resources.gold.amount += this.currentQuest.reward; |
|
this.resources.wood.amount -= this.currentQuest.wood; |
|
this.resources.stone.amount -= this.currentQuest.stone; |
|
this.resources.iron.amount -= this.currentQuest.iron; |
|
this.resources.bricks.amount -= this.currentQuest.bricks; |
|
this.resources.corn.amount -= this.currentQuest.corn; |
|
this.resources.coal.amount -= this.currentQuest.coal; |
|
|
|
this.sendRewardMessage(this.currentQuest.reward); |
|
this.generateQuestWithRandomItems(); |
|
} else { |
|
this.sendWarning('Not enough resources to redeem reward.'); |
|
return false; |
|
} |
|
}, |
|
|
|
useRequiredResources(building) { |
|
this.resources.wood.amount -= (building.requires.wood ? building.requires.wood : 0); |
|
this.resources.stone.amount -= (building.requires.stone ? building.requires.stone : 0); |
|
this.resources.iron.amount -= (building.requires.iron ? building.requires.iron : 0); |
|
this.resources.bricks.amount -= (building.requires.bricks ? building.requires.bricks : 0); |
|
this.resources.corn.amount -= (building.requires.corn ? building.requires.corn : 0); |
|
this.resources.coal.amount -= (building.requires.coal ? building.requires.coal : 0); |
|
}, |
|
|
|
// Templating |
|
getFormattedNumber(value) { |
|
return value.toLocaleString('de-DE'); |
|
}, |
|
|
|
getResourceIconForBuilding(building) { |
|
return this.getResourceIcon(building.resource); |
|
}, |
|
|
|
getResourceIcon(resource) { |
|
return '<img class="resource-icon" src="img/' + resource + '.png" title="' + resource + '" alt="' + resource + '">'; |
|
}, |
|
|
|
getRequirementsText(building) { |
|
let requirementList = '<br/>Uses'; |
|
|
|
requirementList += building.requires.wood ? ' ' + building.requires.wood + ' ' + this.getResourceIcon('wood') : ''; |
|
requirementList += building.requires.stone ? ' ' + building.requires.stone + ' ' + this.getResourceIcon('stone') : ''; |
|
requirementList += building.requires.iron ? ' ' + building.requires.iron + ' ' + this.getResourceIcon('iron') : ''; |
|
requirementList += building.requires.bricks ? ' ' + building.requires.bricks + ' ' + this.getResourceIcon('bricks') : ''; |
|
requirementList += building.requires.coal ? ' ' + building.requires.coal + ' ' + this.getResourceIcon('coal') : ''; |
|
requirementList += building.requires.corn ? ' ' + building.requires.corn + ' ' + this.getResourceIcon('corn') : ''; |
|
|
|
return requirementList + ' for ' + building.amount + ' ' + this.getResourceIconForBuilding(building); |
|
}, |
|
|
|
getColorForQuestResource(needed, has) { |
|
return (has >= needed) ? 'lightgreen' : 'red'; |
|
}, |
|
|
|
// Alerts |
|
sendRewardMessage(reward) { |
|
iziToast.show({ |
|
image: 'img/gold.png', |
|
color: 'green', |
|
message: 'You got a reward of ' + reward + ' gold!', |
|
position: 'bottomCenter', |
|
timeout: 1500, |
|
transitionIn: 'boundInRight', |
|
transitionInMobile: 'boundInRight' |
|
}); |
|
}, |
|
|
|
sendResourceMessage(amount, resource) { |
|
iziToast.show({ |
|
image: 'img/' + resource + '.png', |
|
theme: 'dark', |
|
position: 'bottomCenter', |
|
message: amount + ' ' + resource, |
|
timeout: 1000, |
|
transitionIn: 'boundInRight', |
|
transitionInMobile: 'boundInRight' |
|
}); |
|
}, |
|
|
|
sendNotification(message) { |
|
iziToast.show({ |
|
color: 'green', |
|
message: message, |
|
position: 'bottomCenter', |
|
transitionIn: 'boundInRight', |
|
transitionInMobile: 'boundInRight' |
|
}); |
|
}, |
|
|
|
sendSystemNotification(message) { |
|
iziToast.show({ |
|
color: 'red', |
|
message: message, |
|
position: 'topCenter', |
|
timeout: 7000, |
|
transitionIn: 'boundInRight', |
|
transitionInMobile: 'boundInRight' |
|
}); |
|
}, |
|
|
|
sendWarning(message) { |
|
iziToast.show({ |
|
color: 'red', |
|
message: message, |
|
position: 'bottomCenter', |
|
transitionIn: 'boundInRight', |
|
transitionInMobile: 'boundInRight' |
|
}); |
|
}, |
|
|
|
sendInfo(message) { |
|
iziToast.show({ |
|
color: 'blue', |
|
message: message, |
|
position: 'bottomCenter', |
|
transitionIn: 'boundInRight', |
|
transitionInMobile: 'boundInRight' |
|
}); |
|
}, |
|
|
|
reset(hard = false) { |
|
localStorage.removeItem('buildings' + this.version); |
|
localStorage.removeItem('currentQuest' + this.version); |
|
|
|
if (hard) { |
|
localStorage.removeItem('resources' + this.version); |
|
} |
|
|
|
location.reload(); |
|
} |
|
} |
|
});
|
|
|