1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
package at.hannibal2.skyhanni.utils
import at.hannibal2.skyhanni.data.jsonobjects.repo.neu.NeuEssenceCostJson
import at.hannibal2.skyhanni.events.NeuRepositoryReloadEvent
import at.hannibal2.skyhanni.skyhannimodule.SkyHanniModule
import at.hannibal2.skyhanni.test.command.ErrorManager
import at.hannibal2.skyhanni.utils.CollectionUtils.addOrPut
import at.hannibal2.skyhanni.utils.NEUInternalName.Companion.asInternalName
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
@SkyHanniModule
object EssenceItemUtils {
var itemPrices = mapOf<NEUInternalName, Map<Int, EssenceUpgradePrice>>()
@SubscribeEvent
fun onNeuRepoReload(event: NeuRepositoryReloadEvent) {
val unformattedData = event.getConstant<Map<String, NeuEssenceCostJson>>("essencecosts", NeuEssenceCostJson.TYPE)
this.itemPrices = reformatData(unformattedData)
}
fun NEUInternalName.getEssencePrices(): Map<Int, EssenceUpgradePrice>? = itemPrices[this]
private fun reformatData(unformattedData: Map<String, NeuEssenceCostJson>): MutableMap<NEUInternalName, Map<Int, EssenceUpgradePrice>> {
val itemPrices = mutableMapOf<NEUInternalName, Map<Int, EssenceUpgradePrice>>()
for ((name, data) in unformattedData) {
val essencePrices = loadEssencePrices(data)
val extraItems = data.extraItems ?: emptyMap()
val (coinPrices, iemPrices) = loadCoinAndItemPrices(extraItems)
val upgradePrices = mutableMapOf<Int, EssenceUpgradePrice>()
for ((tier, essencePrice) in essencePrices) {
val coinPrice = coinPrices[tier]
val itemPrice = iemPrices[tier] ?: emptyMap()
upgradePrices[tier] = EssenceUpgradePrice(essencePrice, coinPrice, itemPrice)
}
val internalName = name.asInternalName()
itemPrices[internalName] = upgradePrices
}
return itemPrices
}
private fun loadCoinAndItemPrices(
extraItems: Map<String, List<String>>,
): Pair<MutableMap<Int, Long>, MutableMap<Int, Map<NEUInternalName, Int>>> {
val collectCoinPrices = mutableMapOf<Int, Long>()
val collectItemPrices = mutableMapOf<Int, Map<NEUInternalName, Int>>()
for ((tier, rawItems) in extraItems.mapKeys { it.key.toInt() }) {
val itemPrices = mutableMapOf<NEUInternalName, Int>()
for ((itemName, amount) in rawItems.map { split(it) }) {
if (itemName == NEUInternalName.SKYBLOCK_COIN) {
collectCoinPrices[tier] = amount
} else {
itemPrices[itemName] = amount.toInt()
}
}
collectItemPrices[tier] = itemPrices
}
return Pair(collectCoinPrices, collectItemPrices)
}
private fun split(string: String): Pair<NEUInternalName, Long> = string.split(":").let {
it[0].asInternalName() to it[1].toLong()
}
private fun loadEssencePrices(data: NeuEssenceCostJson): MutableMap<Int, EssencePrice> {
val map = mutableMapOf<Int, EssencePrice>()
val essenceType = data.essenceType
data.essenceFor1?.let { map[1] = EssencePrice(it, essenceType) }
data.essenceFor2?.let { map[2] = EssencePrice(it, essenceType) }
data.essenceFor3?.let { map[3] = EssencePrice(it, essenceType) }
data.essenceFor4?.let { map[4] = EssencePrice(it, essenceType) }
data.essenceFor5?.let { map[5] = EssencePrice(it, essenceType) }
data.essenceFor6?.let { map[6] = EssencePrice(it, essenceType) }
data.essenceFor7?.let { map[7] = EssencePrice(it, essenceType) }
data.essenceFor8?.let { map[8] = EssencePrice(it, essenceType) }
data.essenceFor9?.let { map[9] = EssencePrice(it, essenceType) }
data.essenceFor10?.let { map[10] = EssencePrice(it, essenceType) }
data.essenceFor11?.let { map[11] = EssencePrice(it, essenceType) }
data.essenceFor12?.let { map[12] = EssencePrice(it, essenceType) }
data.essenceFor13?.let { map[13] = EssencePrice(it, essenceType) }
data.essenceFor14?.let { map[14] = EssencePrice(it, essenceType) }
data.essenceFor15?.let { map[15] = EssencePrice(it, essenceType) }
return map
}
data class EssenceUpgradePrice(
val essencePrice: EssencePrice,
val coinPrice: Long?,
val itemPrice: Map<NEUInternalName, Int>,
) {
operator fun plus(other: EssenceUpgradePrice): EssenceUpgradePrice {
if (other.essencePrice.essenceType != essencePrice.essenceType) ErrorManager.skyHanniError(
"Trying to add non compatible EssenceUpgradePrices!",
"essencePrice.essenceType" to essencePrice.essenceType,
"other.essencePrice.essenceType" to other.essencePrice.essenceType,
)
val coinPrice = coinPrice ?: 0L
val otherCoinPrice = other.coinPrice ?: 0L
val map = itemPrice.toMutableMap()
for (entry in other.itemPrice) {
map.addOrPut(entry.key, entry.value)
}
return EssenceUpgradePrice(essencePrice + other.essencePrice, coinPrice + otherCoinPrice, map)
}
}
data class EssencePrice(val essenceAmount: Int, val essenceType: String) {
operator fun plus(other: EssencePrice): EssencePrice {
if (other.essenceType != essenceType) ErrorManager.skyHanniError(
"Trying to add non compatible essence prices!",
"essenceType" to essenceType,
"other.essenceType" to other.essenceType,
)
return EssencePrice(essenceAmount + other.essenceAmount, essenceType)
}
}
}
|
