DieMitchell/ReSkate
1
0 Fork 0
mirror of https://github.com/Dingo-Shenanigans/ReSkate.git synced 2026-10-18 09:05:15 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
5bfe4f7bfafa58db8c816090778078f3d5db2c73
ReSkate/Extension/Multiplayer/Test/developer_identity_tests.cpp
T
AyeZeeBB 5bfe4f7bfa tag preview, separate switches and per-item colors 
- Split the single switch into "Show my tag" and "Show my items", and
  show the tag as chat and nametags draw it.
- Color whatever is equipped instead of the one hoodie and pink board:
  top, bottoms, shoes, socks, hat, glasses, outfit, costume, deck, grip
  tape, trucks and wheels, each set on its own.
- Each item can use its list's animation (rainbow, red or gold), a
  gradient between two picked colors, one solid color, or be off.
- The choices travel with the player's appearance so everyone sees them.
  Protocol version 41.
2026-10-05 00:00:45 -05:00

324 lines
20 KiB
C++
Raw Blame History

#include "Extension/Customization/developer_board_material.h"
#include "Extension/Customization/developer_hoodie_material.h"
#include "Extension/Multiplayer/developer_identity.h"
#include <chrono>
#include <cstdlib>
#include <exception>
#include <iostream>
#include <string>
#include <thread>
using namespace dingosdk::multiplayer;
namespace {
void check(bool ok, const std::string &message) {
if (ok) return;
std::cerr << message << '\n';
std::exit(1);
}
bool rejected(std::string_view json) {
try {
parse_identity_lists(json);
} catch (const std::exception &) {
return true;
}
return false;
}
constexpr std::uint64_t dev = 76561198000000001ULL, other_dev = 76561198000000002ULL, homie = 76561198000000003ULL,
creator = 76561198000000004ULL, stranger = 76561198000000005ULL;
using L = IdentityList;
void parsing() {
// The answer as the backend sends it; a list comes back sorted, each player once.
const auto lists = parse_identity_lists(
R"({"categories":{"dev":["76561198000000002","76561198000000001","76561198000000002"],)"
R"("homie":["76561198000000003"],"content_creator":["76561198000000004"]}})");
check(lists[0] == std::vector{dev, other_dev} && lists[1] == std::vector{homie} && lists[2] == std::vector{creator} &&
lists[3].empty(),
"The backend's answer was not read as its three lists, with nobody banned");
// The ban list comes beside the categories; a player can be in both.
const auto bans = parse_identity_lists(
R"({"categories":{"dev":["76561198000000001"]},"banned":["76561198000000005","76561198000000001","76561198000000005"]})");
check(bans[0] == std::vector{dev} && bans[3] == std::vector{dev, stranger}, "The ban list was not read");
// A newer backend may list more categories and fields, and an older one fewer.
const auto partial = parse_identity_lists(
R"({"updated":"2026-10-04","categories":{"moderator":["76561198000000005"],"dev":["76561198000000001"]}})");
check(partial[0] == std::vector{dev} && partial[1].empty() && partial[2].empty(),
"An unknown category was read, or a missing one was not empty");
// The ends of the range players' SteamID64s come from.
check(!rejected(R"({"categories":{"dev":["76561197960265729","76561202255233023"]}})"), "A valid SteamID64 was refused");
for (const std::string_view wrong : {
"", "go away\n", "<html>Just a moment...</html>", "[]", "{}", R"({"categories":[]})",
R"({"categories":{"dev":"76561198000000001"}})", // not a list
R"({"categories":{"dev":[76561198000000001]}})", // a number, which JSON readers round
R"({"categories":{"dev":["76561198000000001 "]}})", R"({"categories":{"dev":["+76561198000000001"]}})",
R"({"categories":{"dev":["zee_x64"]}})", R"({"categories":{"dev":[""]}})",
R"({"categories":{"dev":["76561197960265728"]}})", // account 0
R"({"categories":{"dev":["76561202255233024"]}})", // past the last account
R"({"categories":{"dev":["103582791429521408"]}})", // a Steam group
R"({"categories":{"homie":["1"]}})", R"({"categories":{},"banned":"76561198000000005"})",
R"({"categories":{},"banned":[76561198000000005]})", R"({"categories":{},"banned":["everyone"]})"})
check(rejected(wrong), "An answer that is not the lists was accepted: " + std::string(wrong));
}
void lookup() {
check(!reskate_developer(dev) && !identity_listed(homie, L::homie), "Someone was listed before any lists arrived");
check(publish_identity_lists({{{dev, other_dev}, {homie}, {creator}}}), "The first lists did not count as a change");
check(reskate_developer(dev) && reskate_developer(other_dev) && identity_listed(homie, L::homie) &&
identity_listed(creator, L::content_creator),
"A listed player was not found");
check(!reskate_developer(homie) && !reskate_developer(creator) && !reskate_developer(stranger) &&
!identity_listed(dev, L::homie) && !identity_listed(homie, L::content_creator),
"A player was found in a list they are not in");
check(!reskate_developer(0) && !identity_listed(dev, L::count), "No player, or no list, matched");
check(!reskate_banned(dev) && !reskate_banned(stranger), "Someone is banned though the lists ban nobody");
check(publish_identity_lists({{{dev, other_dev}, {homie}, {creator}, {dev, stranger}}}) && reskate_banned(stranger) &&
reskate_banned(dev) && reskate_developer(dev) && !reskate_banned(other_dev) && !reskate_banned(0),
"The ban list did not ban exactly the players on it");
check(publish_identity_lists({{{dev, other_dev}, {homie}, {creator}}}) && !reskate_banned(stranger), "A lifted ban stayed");
check(!publish_identity_lists({{{dev, other_dev}, {homie}, {creator}}}), "The same lists counted as a change");
// The one mark a player carries: a developer's before a content creator's before a homie's.
check(publish_identity_lists({{{dev}, {dev, homie, creator}, {dev, creator}}}) && identity_mark(dev) == L::developer &&
identity_mark(creator) == L::content_creator && identity_mark(homie) == L::homie && !identity_mark(stranger) &&
!identity_mark(0),
"A player's mark is not the first list they are on");
// Their tag and their items are each their own to hide.
check(own_tag_shown() && own_items_shown(), "A player's tag or items start hidden");
show_own_tag(false);
check(!own_tag_shown() && own_items_shown() && identity_mark(dev) == L::developer,
"Hiding their own tag did not take, hid their items, or changed the lists");
show_own_tag(true);
show_own_items(false);
check(own_tag_shown() && !own_items_shown(), "Hiding their own items did not take, or hid their tag");
show_own_items(true);
check(publish_identity_lists({{{dev, other_dev}, {homie}, {creator}}}), "The lists did not go back");
// Removing someone in the panel takes their mark away at the next refresh.
check(publish_identity_lists({{{dev}, {}, {}}}) && reskate_developer(dev) && !reskate_developer(other_dev) &&
!identity_listed(homie, L::homie),
"Replaced lists kept a player who was removed");
}
// The hoodie and board: what a list gives a cosmetic, and what a player makes of it on the Special page.
void items() {
using namespace dingosdk::developer_hoodie_detail;
using dingosdk::multiplayer::MarkMode;
using dingosdk::multiplayer::MarkStyle;
using dingosdk::multiplayer::MarkStyles;
const MarkStyle standard{};
const auto spectrum = item_animation(L::developer, standard), red = item_animation(L::content_creator, standard),
gold = item_animation(L::homie, standard);
check(spectrum.on && spectrum.rainbow && red.on && !red.rainbow && gold.on && !gold.rainbow &&
!item_animation(std::nullopt, standard).on,
"A list did not give its animation, or a player on none got one");
check(item_color(spectrum, 0) == rainbow(0) && item_color(spectrum, 3000) == rainbow(3000), "The developer's rainbow changed");
// Red and gold go from a deep shade to a bright one, on into the colour next to it, and back
// every three seconds.
for (const auto *animation : {&red, &gold}) {
const auto deep = item_color(*animation, 0), bright = item_color(*animation, 750), far = item_color(*animation, 1500);
check(item_color(*animation, 3000) == deep && item_color(*animation, 4500) == far, "An animation does not repeat every three seconds");
check(bright[0] > deep[0] * 2 && far[0] >= bright[0], "An animation does not go from deep to bright");
if (animation == &red) {
// A content creator's: red, then a reddish pink.
check(bright[1] < bright[0] * .1f && bright[2] < bright[0] * .1f, "Red is not red");
check(far[2] > bright[2] * 3 && far[2] < far[0] * .4f && far[1] < far[0] * .15f, "Red does not go on into a reddish pink");
} else {
// A homie's: gold, then yellow.
check(bright[1] > bright[0] * .5f && bright[1] < bright[0] * .75f && bright[2] < bright[0] * .15f, "Gold is not gold");
check(far[1] > bright[1] * 1.2f && far[1] < far[0] && far[2] < far[1] * .4f, "Gold does not go on into yellow");
}
for (std::uint64_t at = 0; at < 6000; at += 125) {
// The material's gamut, and red always the strongest part of the colour.
const auto color = item_color(*animation, at);
check(color[0] <= .801f && color[1] > 0 && color[2] > 0 && color[0] > color[1] && color[0] > color[2],
"An animation leaves its colours");
}
}
// A cosmetic turned off, and one given the player's own two colours.
const MarkStyle off{MarkMode::off, {}, {}, 0}, own{MarkMode::gradient, {255, 0, 0}, {0, 0, 255}, 0};
check(!item_animation(L::developer, off).on && !item_animation(L::homie, off).on, "A cosmetic turned off still animates");
const auto custom = item_animation(L::homie, own);
const auto first = item_color(custom, 0), last = item_color(custom, 1500), half = item_color(custom, 750);
check(custom.on && !custom.rainbow && first[0] > .7f && first[2] < .01f && last[2] > .7f && last[0] < .01f && half[0] > .3f &&
half[2] > .3f && item_color(custom, 3000) == first,
"A player's own colours are not what their cosmetic moves between");
// A developer can leave the rainbow for colours of their own; no style gives anyone else the rainbow.
check(!item_animation(L::developer, own).rainbow && item_animation(L::developer, own).on, "A developer cannot have their own colours");
// One colour of their own stands still, at any speed.
const auto still = item_animation(L::homie, {MarkMode::solid, {0, 255, 0}, {9, 9, 9}, 2});
check(still.on && !still.rainbow && item_color(still, 0) == material_color({0, 255, 0}) && item_color(still, 0)[1] > .7f &&
item_color(still, 777) == item_color(still, 0) && item_color(still, 1500) == item_color(still, 0),
"A solid colour is not the colour picked, or does not stand still");
for (const auto mode : {MarkMode::standard, MarkMode::gradient, MarkMode::solid})
check(!item_animation(L::content_creator, {mode, {}, {}, 0}).rainbow && !item_animation(L::homie, {mode, {}, {}, 0}).rainbow,
"A style gave the rainbow to someone who is not a developer");
// Slow takes twice as long and fast half, for the rainbow too.
check(item_animation(L::homie, {MarkMode::gradient, {}, {}, 1}).period == 6000 &&
item_animation(L::homie, {MarkMode::standard, {}, {}, 2}).period == 1500 &&
item_animation(L::developer, {MarkMode::standard, {}, {}, 1}).period == 16000 &&
item_animation(L::developer, {MarkMode::standard, {}, {}, 2}).period == 4000 &&
item_color(item_animation(L::developer, {MarkMode::standard, {}, {}, 2}), 1000) == rainbow(2000),
"The speed is not half or twice the usual");
// The pickers start from colours close to the list's own.
const auto picks = standard_picks(L::content_creator);
const auto start = material_color(picks.first), finish = material_color(picks.second);
check(std::abs(start[0] - .2f) < .02f && start[1] < .02f && std::abs(finish[0] - .8f) < .01f && std::abs(finish[2] - .13f) < .02f,
"A content creator's pickers do not start from their red");
// The styles are kept in the profile as text.
MarkStyles styles{};
styles[0] = own, styles[2] = off, styles[4] = {MarkMode::gradient, {1, 2, 3}, {254, 253, 252}, 2};
styles.back() = {MarkMode::solid, {7, 8, 9}, {}, 0};
const auto text = mark_styles_text(styles);
check(text.size() == styles.size() * 16 && parse_mark_styles(text) == styles && parse_mark_styles(mark_styles_text({})) == MarkStyles{},
"The styles did not come back from their text");
check(!parse_mark_styles("") && !parse_mark_styles("00") && !parse_mark_styles(std::string(text.size(), 'f')) &&
!parse_mark_styles(std::string(text.size(), 'g')) && !parse_mark_styles(text + "00") &&
!parse_mark_styles(std::string_view(text).substr(16)),
"Text that is not styles was read as some");
// Every marked cosmetic has a name, the skater's before the board's.
check(dingosdk::multiplayer::mark_item_names.size() == slots.size() + dingosdk::developer_board_detail::part_count &&
dingosdk::multiplayer::mark_item_names[slots.size()] == "Deck" && slots[2] == "CAS_Footwear_Slot",
"The marked cosmetics and their names do not line up");
}
// Whatever a player wears is coloured where the item colours itself, each cosmetic on its own;
// turning one off (the Special page, or a list that no longer has the player) puts its own
// colours back, and publishes them the extra times the renderer needs to show them.
void settling() {
using namespace dingosdk::developer_hoodie_detail;
using dingosdk::multiplayer::MarkMode;
const auto red = item_animation(L::content_creator, {}), gold = item_animation(L::homie, {});
const ItemAnimation none;
using Skater = std::array<ItemAnimation, slots.size()>;
const auto wearing = [&](const ItemAnimation &top, const ItemAnimation &shoes) {
Skater out{};
out[0] = top, out[2] = shoes;
return out;
};
const Skater bare{};
const Color black{.02f, .02f, .02f}, navy{.02f, .02f, .2f}, teal{.02f, .3f, .3f};
const auto bound = [](std::uintptr_t item, std::uintptr_t node, std::uint64_t key, const Color &color, std::uint8_t part) {
return Binding{item, item + 40, node, {0, sizeof(Color), 1, 1, key}, color, part};
};
// What the game holds for each colour, read afresh each tick as in game: a top with two
// regions it colours and one it leaves to its texture, and shoes that colour none of theirs.
std::array<Color, 4> held{black, navy, neutral, neutral};
dingosdk::DeveloperHoodieState state;
Materials live;
live.component = 1, live.appearance = 2, live.regions_only = true;
live.bindings = {bound(10, 100, color_keys[0], black, 0), bound(10, 101, color_keys[3], navy, 0),
bound(10, 102, color_keys[7], neutral, 0), bound(11, 103, color_keys[0], neutral, 2)};
std::vector<std::uintptr_t> published;
int writes{};
auto write = [&](const Binding &binding, const Color &color) {
held[binding.node - 100] = color;
++writes;
return true;
};
auto publish = [&](std::uintptr_t item) { published.push_back(item); };
const auto tick = [&](const Skater &animations, std::uint64_t at) {
for (std::size_t i = 0; i < held.size(); ++i) live.bindings[i].color = held[i];
animate(state, live, 5, 6, animations, at, write, publish);
};
using Items = std::vector<std::uintptr_t>;
tick(wearing(red, none), 0);
tick(wearing(red, none), 700);
check(state.colors.size() == 2 && held[0] == item_color(red, 700) && held[1] == held[0] && held[2] == neutral &&
held[3] == neutral && published == Items{10, 10},
"The top's own regions were not coloured, or more than them was");
// Shoes that colour none of their regions take the colour on all of them.
tick(wearing(red, gold), 800);
check(held[3] == item_color(gold, 800) && held[2] == neutral && held[0] == item_color(red, 800) && state.colors.size() == 3,
"An item with no colours of its own was not coloured, or cosmetics did not each take their own");
published.clear();
tick(bare, 900);
check(held[0] == black && held[1] == navy && held[3] == neutral && published == Items{10, 11},
"Turning it off did not bring the items' own colours back");
for (std::uint64_t at = 901; at < 911; ++at) tick(bare, at);
check(published.size() == 2 * (1 + settle_publishes) && state.colors.empty() && held[0] == black && held[1] == navy,
"The own colours were not published the extra times, or the items were not left alone after");
// A colour the game itself sets meanwhile is the game's to keep.
tick(wearing(gold, none), 1000);
held[0] = teal;
tick(bare, 1100);
check(held[0] == teal && held[1] == navy, "Turning it off overwrote a colour the game had set");
// And it comes back on with the own colours still known.
for (std::uint64_t at = 1200; at < 1210; ++at) tick(bare, at);
tick(wearing(red, none), 2000);
tick(bare, 2100);
check(held[0] == teal && held[1] == navy, "A second round lost the top's own colours");
for (std::uint64_t at = 2200; at < 2210; ++at) tick(bare, at);
// A colour that stands still is written once, and published until the renderer shows it.
const auto still = item_animation(L::homie, {MarkMode::solid, {0, 255, 0}, {}, 0});
published.clear(), writes = 0;
for (std::uint64_t at = 3000; at < 3010; ++at) tick(wearing(still, none), at);
check(held[0] == item_color(still, 0) && held[1] == held[0] && writes == 2 && published == Items(1 + settle_publishes, 10),
"A solid colour was written again and again, or not published until it showed");
// While a recipe is on its way nothing is touched, and what was saved is kept.
live.pending = true;
tick(bare, 4000);
check(held[0] == item_color(still, 0) && state.colors.size() == 2 && writes == 2, "A pending recipe was written to");
live.pending = false;
tick(bare, 4100);
check(held[0] == teal && held[1] == navy, "The own colours were lost while a recipe was pending");
// The board does the same, each of its parts on its own: here the deck and the wheels, whose
// material has no colour of its own until one is added.
namespace board = dingosdk::developer_board_detail;
std::array<Color, 2> painted{black, board::shader_default};
dingosdk::DeveloperBoardState deck;
Materials parts;
parts.component = 1, parts.appearance = 2;
parts.bindings = {Binding{30, 10, 100, board::parameter_key(board::base_color, 1), black, 0},
Binding{31, 11, 0, board::parameter_key(board::base_color, 1), board::shader_default, 3}};
int shown{};
bool added{};
auto paint = [&](const Binding &binding, const Color &color) {
if (!binding.node) added = true; // the engine adds the missing parameter
painted[binding.part ? 1 : 0] = color;
return true;
};
auto show = [&](std::uintptr_t) { ++shown; };
using Board = std::array<ItemAnimation, board::part_count>;
const auto roll = [&](const ItemAnimation &on_deck, const ItemAnimation &on_wheels, std::uint64_t at) {
parts.bindings[0].color = painted[0], parts.bindings[1].color = painted[1];
parts.bindings[1].node = added ? 101 : 0;
animate(deck, parts, 5, 6, Board{on_deck, none, none, on_wheels}, at, paint, show);
};
roll(gold, red, 0);
roll(gold, red, 700);
check(deck.colors.size() == 2 && added && painted[0] == item_color(gold, 700) && painted[1] == item_color(red, 700),
"The board's parts did not each take their own animation, or a missing colour was not added");
// The wheels alone turned off: back to the shaders' default, while the deck goes on.
for (std::uint64_t at = 800; at < 810; ++at) roll(gold, none, at);
check(painted[0] == item_color(gold, 809) && painted[1] == board::shader_default && deck.colors.size() == 1,
"Turning one part off stopped another, or did not stop it");
shown = 0;
for (std::uint64_t at = 900; at < 910; ++at) roll(none, none, at);
check(painted[0] == black && painted[1] == board::shader_default && shown == 1 + settle_publishes && deck.colors.empty(),
"Turning it off did not bring the board's own colours back and publish them the extra times");
}
// --live <SteamID64>: the deployed backend, read the way the game reads it. Not
// part of the test run, which stays off the network.
int live(const char *player) {
const auto id = std::strtoull(player, nullptr, 10);
for (int waited = 0; waited < 150 && !reskate_developer(id); ++waited) {
refresh_identity_lists();
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
std::cout << player << (reskate_developer(id) ? " is" : " is not") << " a developer in the lists the backend sent\n";
return reskate_developer(id) ? 0 : 1;
}
} // namespace
int main(int count, char **arguments) {
if (count == 3 && std::string_view(arguments[1]) == "--live") return live(arguments[2]);
parsing();
lookup();
items();
settling();
std::cout << "developer identity tests passed\n";
}
Reference in new issue View Git Blame Copy Permalink