/
WarPoints.kt
99 lines (86 loc) · 3.61 KB
/
WarPoints.kt
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
package org.kingdoms.peacetreaties.data
import org.kingdoms.constants.group.Kingdom
import org.kingdoms.constants.land.abstraction.data.DeserializationContext
import org.kingdoms.constants.land.abstraction.data.SerializationContext
import org.kingdoms.constants.metadata.KingdomMetadata
import org.kingdoms.constants.metadata.KingdomMetadataHandler
import org.kingdoms.constants.metadata.KingdomsObject
import org.kingdoms.constants.namespace.Namespace
import org.kingdoms.data.database.dataprovider.SectionCreatableDataSetter
import org.kingdoms.data.database.dataprovider.SectionableDataGetter
import org.kingdoms.locale.compiler.placeholders.PlaceholderContextBuilder
import org.kingdoms.peacetreaties.config.PeaceTreatyConfig
import org.kingdoms.utils.MathUtils
import java.util.*
typealias WarPoints = MutableMap<UUID, Double>
class WarPointsMeta(var warPoints: WarPoints) : KingdomMetadata {
@Suppress("UNCHECKED_CAST")
override var value: Any
get() = warPoints
set(value) {
this.warPoints = value as WarPoints
}
override fun serialize(container: KingdomsObject<*>, context: SerializationContext<SectionCreatableDataSetter>) {
context.dataProvider.setMap(warPoints) { key, keyProvider, value ->
keyProvider.setUUID(key)
keyProvider.getValueProvider().setDouble(value)
}
}
override fun shouldSave(container: KingdomsObject<*>): Boolean = warPoints.isNotEmpty()
}
class WarPoint {
companion object {
@JvmStatic
fun Kingdom.getWarPoints(): WarPoints {
val meta = this.metadata[WarPointsMetaHandler.INSTANCE]
return if (meta == null) {
val data: WarPoints = HashMap()
this.metadata[WarPointsMetaHandler.INSTANCE] = WarPointsMeta(data)
data
} else {
(meta as WarPointsMeta).warPoints
}
}
@JvmStatic
fun Kingdom.getWarPoints(other: Kingdom): Double = getWarPoints()[other.dataKey] ?: 0.0
@JvmStatic
fun Kingdom.hasWarPoints(other: Kingdom, amount: Double): Boolean = getWarPoints(other) >= amount
/**
* Sets war points ignoring the max war points limit.
*/
@JvmStatic
fun Kingdom.setWarPoints(other: Kingdom, amount: Double) {
val meta = getWarPoints()
meta[other.dataKey] = amount
}
@JvmStatic
fun Kingdom.getMaxWarPoints(other: Kingdom): Double =
MathUtils.eval(
PeaceTreatyConfig.WAR_POINTS_MAX.manager.mathExpression,
PlaceholderContextBuilder().withContext(this).other(other)
)
/**
* Adds war points respecting the max war points.
* If you want to bypass this limit use [setWarPoints] instead.
*/
@JvmStatic
fun Kingdom.addWarPoints(other: Kingdom, amount: Double): Double {
val maxWarPoints = getMaxWarPoints(other)
return getWarPoints().compute(other.dataKey) { _, v -> maxWarPoints.coerceAtMost(if (v == null) amount else v + amount) }!!
}
}
}
class WarPointsMetaHandler private constructor() : KingdomMetadataHandler(Namespace("PeaceTreaties", "WAR_POINTS")) {
override fun deserialize(
container: KingdomsObject<*>,
context: DeserializationContext<SectionableDataGetter>,
): KingdomMetadata {
return WarPointsMeta(context.dataProvider.asMap(hashMapOf()) { map, key, value ->
map[key.asUUID()!!] = value.asDouble()
})
}
companion object {
@JvmField
val INSTANCE = WarPointsMetaHandler()
}
}