void GenerateGems(json::Value& value, json::Value& data) {
TranslateJson(value, data);
auto names = Strings::list("Items");
auto powers = Strings::list("ItemPassivePowerDescriptions");
for (auto& kv : value["gemColors"].getMap()) {
std::string id = kv.first;
id[0] = toupper(id[0]);
size_t levels = value["gemQualities"].length();
auto& dst = value["gemColors"][kv.first]["names"];
for (size_t level = 1; level <= levels; ++level) {
dst.append(names.getfmt("x1_%s_%02d", id.c_str(), level));
}
}
for (auto& gem : data["legendaryGems"].getMap()) {
std::string id = gem.second["id"].getString();
auto* item = ItemLibrary::get(id);
if (!names.has(id) || !item) {
Logger::log("Item not found: %s", id.c_str());
continue;
}
auto& dst = value["legendaryGems"][gem.first];
dst["name"] = names[id];
if (gem.second.has("effects")) {
if (gem.second["effects"].has("0") && gem.second["effects"]["0"].has("format")) {
char const* name = Power::name(item->x4B8_AttributeSpecifier.x04_Param);
auto* tag = PowerTags::getraw(item->x4B8_AttributeSpecifier.x04_Param);
if (!name || !tag || !powers.has(name)) {
Logger::log("Power(0) not found for %s", id.c_str());
} else {
std::string fmt = powers[name];
auto values = GameAffixes::defaultMap();
values["value1"] = AttributeValue("%");
dst["effects"]["0"]["format"] = FormatDescription(powers[name], FormatTags, values, tag);
}
}
if (gem.second["effects"].has("1") && gem.second["effects"]["1"].has("format")) {
std::vector<AttributeSpecifier> specs;
specs.emplace_back(item->x4D0_AttributeSpecifier);
auto format = GameAffixes::format(specs, FormatTags);
if (format.empty()) {
Logger::log("Unknown power(1) for %s", id.c_str());
} else {
dst["effects"]["1"]["format"] = format[0];
}
}
}
}
}
void GenerateSkills(json::Value& value, json::Value& data) {
TranslateJson(value, data);
SnoFile<GameBalance> gmb("Characters");
auto names = Strings::list("Powers");
auto attrs = Strings::list("AttributeDescriptions");
for (auto& chr : gmb->x088_Heros) {
SkillTips tips;
tips.generate(canonize(chr.x000_Text), chr.x120_SkillKitSno, false, &data["skillFix"]);
data["passivetips"][tips.charClass] = tips.passives;
data["skilltips"][tips.charClass] = tips.skills;
for (auto& kv : tips.skillMap.getMap()) {
auto& dst = value["skills"][tips.charClass][kv.first];
dst["name"] = names[kv.second.getString() + "_name"];
data["skillMap"][kv.first] = kv.second;
for (char rune = 'a'; rune <= 'e'; ++rune) {
//NameRune_A#Witchdoctor_Firebomb
dst["runes"][std::string{rune}] = attrs.getfmt("NameRune_%c#%s", rune - 'a' + 'A', kv.second.getString().c_str());
}
}
for (auto& kv : tips.passiveMap.getMap()) {
value["passives"][tips.charClass][kv.first]["name"] = names[kv.second.getString() + "_name"];
data["skillMap"][kv.first] = kv.second;
}
value["skillcat"][tips.charClass] = tips.categoryMap;
}
for (auto& cls : value["extraskills"]) {
for (auto& skill : cls) {
std::string power = skill["power"].getString();
skill.remove("power");
if (!names.has(power + "_name")) {
Logger::log("Power not found: %s", power.c_str());
continue;
}
skill["name"] = names[power + "_name"];
skill["tip"] = SkillTips::format(power);
}
}
//data["skillMap"]
}
static int query_format(struct vf_instance_s* vf, unsigned int outfmt){
unsigned int fmt=getfmt(outfmt,vf->priv->forced);
if(!fmt) return 0;
return vf_next_query_format(vf,fmt) & (~VFCAP_CSP_SUPPORTED_BY_HW);
}
static int config(struct vf_instance_s* vf,
int width, int height, int d_width, int d_height,
unsigned int flags, unsigned int outfmt){
vf->priv->fmt=getfmt(outfmt,vf->priv->forced);
return vf_next_config(vf,width,height,d_width,d_height,flags,vf->priv->fmt);
}
int
main(int argc, char *argv[])
{
struct athstatfoo *wf;
const char *ifname;
int c, banner = 1;
ifname = getenv("ATH");
if (ifname == NULL)
ifname = "ath0";
wf = athstats_new(ifname, getfmt("default"));
while ((c = getopt(argc, argv, "bi:lo:z")) != -1) {
switch (c) {
case 'b':
banner = 0;
break;
case 'i':
wf->setifname(wf, optarg);
break;
case 'l':
wf->print_fields(wf, stdout);
return 0;
case 'o':
wf->setfmt(wf, getfmt(optarg));
break;
case 'z':
wf->zerostats(wf);
break;
default:
errx(-1, "usage: %s [-a] [-i ifname] [-l] [-o fmt] [-z] [interval]\n", argv[0]);
/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
u_long interval = strtoul(argv[0], NULL, 0);
int line, omask;
if (interval < 1)
interval = 1;
signal(SIGALRM, catchalarm);
signalled = 0;
alarm(interval);
banner:
if (banner)
wf->print_header(wf, stdout);
line = 0;
loop:
if (line != 0) {
wf->collect_cur(wf);
wf->print_current(wf, stdout);
wf->update_tot(wf);
} else {
wf->collect_tot(wf);
wf->print_total(wf, stdout);
}
fflush(stdout);
omask = sigblock(sigmask(SIGALRM));
if (!signalled)
sigpause(0);
sigsetmask(omask);
signalled = 0;
alarm(interval);
line++;
if (line == 21) /* XXX tty line count */
goto banner;
else
goto loop;
/*NOTREACHED*/
} else {
wf->collect_tot(wf);
wf->print_verbose(wf, stdout);
}
return 0;
}
void GenerateSimBuffs(json::Value& value, json::Value& data) {
TransformJson(value, data, FormatTag);
auto powers = Strings::list("Powers");
auto attrs = Strings::list("AttributeDescriptions");
auto powersEn = Strings::list("Powers", SnoLoader::default);
auto attrsEn = Strings::list("AttributeDescriptions", SnoLoader::default);
auto sets = Strings::list("ItemSets");
auto setsEn = Strings::list("ItemSets", SnoLoader::default);
auto items = Strings::list("Items");
auto itemsEn = Strings::list("Items", SnoLoader::default);
for (auto& kv : data["simMapping"]["buffs"].getMap()) {
std::string type = kv.second["category"].getString();
auto& dst = value["simMapping"]["buffs"][kv.first];
dst["category"] = fmtstring("$Simulator/%s$", type.c_str());
if (type == "Status") {
dst["name"] = value["simMapping"]["status"][kv.first];
} else {
std::string name, repl;
std::string realname = kv.second["name"].getString();
if (kv.second.has("skill")) {
auto& skill = kv.second["skill"];
std::string id = skill[0].getString();
if (!data["skillMap"].has(id)) {
Logger::log("Unknown skill: %s", id.c_str());
} else {
std::string power = data["skillMap"][id].getString();
name = powersEn[power + "_name"];
repl = powers[power + "_name"];
if (skill.length() > 1) {
char rune = skill[1].getString()[0];
name.append(" - ");
name.append(attrsEn.getfmt("NameRune_%c#%s", rune - 'a' + 'A', power.c_str()));
repl.append(" - ");
repl.append(attrs.getfmt("NameRune_%c#%s", rune - 'a' + 'A', power.c_str()));
}
}
} else if (kv.second.has("passive")) {
std::string id = kv.second["passive"].getString();
if (!data["skillMap"].has(id)) {
Logger::log("Unknown passive: %s", id.c_str());
} else {
std::string power = data["skillMap"][id].getString();
name = powersEn[power + "_name"];
repl = powers[power + "_name"];
}
} else if (kv.second.has("set")) {
std::string id = kv.second["set"][0].getString();
int count = kv.second["set"][1].getInteger();
if (!data["setMap"].has(id)) {
Logger::log("Unknown item set: %s", id.c_str());
} else {
id = data["setMap"][id].getString();
name = setsEn[id];
repl = sets[id];
if (name != realname) {
std::string suffix = fmtstring(" (%d)", count);
name.append(suffix);
repl.append(suffix);
}
}
} else if (kv.second.has("stat")) {
std::string id;
if (kv.second["stat"].type() == json::Value::tString) {
id = kv.second["stat"].getString();
} else {
id = kv.second["stat"][0].getString();
}
if (!data["legendaryMap"].has(id)) {
Logger::log("Unknown item: %s", id.c_str());
} else {
id = data["legendaryMap"][id].getString();
name = itemsEn[id];
repl = (items.has(id) ? items[id] : name);
}
} else if (kv.second.has("gem")) {
std::string id = kv.second["gem"][0].getString();
if (!data["legendaryGems"].has(id)) {
Logger::log("Unknown gem: %s", id.c_str());
} else {
id = data["legendaryGems"][id]["id"].getString();
name = itemsEn[id];
repl = items[id];
}
}
if (realname == "Boots of Disregard") {
int adsf = 0;
}
if (realname == name) {
dst["name"] = repl;
} else {
dst["name"] = fmtstring("$Simulator/%s$", realname.c_str());
data["stringlist"]["Simulator"][realname]["text"] = realname;
data["stringlist"]["Simulator"][realname]["tip"] = type + " buff";
}
}
}
StoreJson(value, data);
}