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
131
|
#include "StarStatusTypes.hpp"
#include "StarJsonExtra.hpp"
#include "StarDataStreamExtra.hpp"
namespace Star {
bool StatBaseMultiplier::operator==(StatBaseMultiplier const& rhs) const {
return tie(statName, baseMultiplier) == tie(rhs.statName, rhs.baseMultiplier);
}
DataStream& operator>>(DataStream& ds, StatBaseMultiplier& baseMultiplier) {
ds >> baseMultiplier.statName;
ds >> baseMultiplier.baseMultiplier;
return ds;
}
DataStream& operator<<(DataStream& ds, StatBaseMultiplier const& baseMultiplier) {
ds << baseMultiplier.statName;
ds << baseMultiplier.baseMultiplier;
return ds;
}
bool StatValueModifier::operator==(StatValueModifier const& rhs) const {
return tie(statName, value) == tie(rhs.statName, rhs.value);
}
DataStream& operator>>(DataStream& ds, StatValueModifier& valueModifier) {
ds >> valueModifier.statName;
ds >> valueModifier.value;
return ds;
}
DataStream& operator<<(DataStream& ds, StatValueModifier const& valueModifier) {
ds << valueModifier.statName;
ds << valueModifier.value;
return ds;
}
bool StatEffectiveMultiplier::operator==(StatEffectiveMultiplier const& rhs) const {
return tie(statName, effectiveMultiplier) == tie(rhs.statName, rhs.effectiveMultiplier);
}
DataStream& operator>>(DataStream& ds, StatEffectiveMultiplier& effectiveMultiplier) {
ds >> effectiveMultiplier.statName;
ds >> effectiveMultiplier.effectiveMultiplier;
return ds;
}
DataStream& operator<<(DataStream& ds, StatEffectiveMultiplier const& effectiveMultiplier) {
ds << effectiveMultiplier.statName;
ds << effectiveMultiplier.effectiveMultiplier;
return ds;
}
StatModifier jsonToStatModifier(Json const& config) {
String statName = config.getString("stat");
if (auto baseMultiplier = config.optFloat("baseMultiplier")) {
return StatModifier(StatBaseMultiplier{statName, *baseMultiplier});
} else if (auto amount = config.optFloat("amount")) {
return StatModifier(StatValueModifier{statName, *amount});
} else if (auto effectiveMultiplier = config.optFloat("effectiveMultiplier")) {
return StatModifier(StatEffectiveMultiplier{statName, *effectiveMultiplier});
} else {
throw JsonException("Could not find 'baseMultiplier' or 'effectiveMultiplier' or 'amount' element in stat effect config");
}
}
Json jsonFromStatModifier(StatModifier const& modifier) {
if (auto baseMultiplier = modifier.ptr<StatBaseMultiplier>()) {
return JsonObject{{"stat", baseMultiplier->statName}, {"baseMultiplier", baseMultiplier->baseMultiplier}};
} else if (auto valueModifier = modifier.ptr<StatValueModifier>()) {
return JsonObject{{"stat", valueModifier->statName}, {"amount", valueModifier->value}};
} else if (auto effectiveMultiplier = modifier.ptr<StatEffectiveMultiplier>()) {
return JsonObject{{"stat", effectiveMultiplier->statName}, {"effectiveMultiplier", effectiveMultiplier->effectiveMultiplier}};
} else {
throw JsonException("No 'baseMultiplier', 'amount', or 'effectiveMultiplier' member found in json");
}
}
PersistentStatusEffect jsonToPersistentStatusEffect(Json const& config) {
if (config.isType(Json::Type::String)) {
return UniqueStatusEffect(config.toString());
} else if (config.isType(Json::Type::Object)) {
return jsonToStatModifier(config);
} else {
throw JsonException("Json is wrong type for persistent stat effect config");
}
}
Json jsonFromPersistentStatusEffect(PersistentStatusEffect const& effect) {
if (auto uniqueStatusEffect = effect.ptr<UniqueStatusEffect>())
return Json(*uniqueStatusEffect);
else if (auto statModifier = effect.ptr<StatModifier>())
return jsonFromStatModifier(*statModifier);
return Json();
}
bool EphemeralStatusEffect::operator==(EphemeralStatusEffect const& rhs) const {
return tie(uniqueEffect, duration) == tie(rhs.uniqueEffect, rhs.duration);
}
DataStream& operator>>(DataStream& ds, EphemeralStatusEffect& ephemeralStatusEffect) {
ds >> ephemeralStatusEffect.uniqueEffect;
ds >> ephemeralStatusEffect.duration;
return ds;
}
DataStream& operator<<(DataStream& ds, EphemeralStatusEffect const& ephemeralStatusEffect) {
ds << ephemeralStatusEffect.uniqueEffect;
ds << ephemeralStatusEffect.duration;
return ds;
}
EphemeralStatusEffect jsonToEphemeralStatusEffect(Json const& config) {
if (config.isType(Json::Type::String)) {
return EphemeralStatusEffect{UniqueStatusEffect(config.toString()), {}};
} else if (config.isType(Json::Type::Object)) {
String effectName = config.getString("effect");
Maybe<float> duration = config.optFloat("duration");
return EphemeralStatusEffect{UniqueStatusEffect(effectName), duration};
} else {
throw JsonException("Json is wrong type for ephemeral stat effect config");
}
}
Json jsonFromEphemeralStatusEffect(EphemeralStatusEffect const& effect) {
return JsonObject{{"effect", effect.uniqueEffect}, {"duration", jsonFromMaybe(effect.duration)}};
}
}
|