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
132
133
134
135
136
137
138
139
|
#include "RandomizerCore.h"
#include "Memory.h"
#include "Random.h"
#include <sstream>
void RandomizerCore::Randomize(std::vector<int>& panels, int flags) {
return RandomizeRange(panels, flags, 0, panels.size());
}
// Range is [start, end)
void RandomizerCore::RandomizeRange(std::vector<int> &panels, int flags, size_t startIndex, size_t endIndex) {
if (panels.size() == 0) return;
if (startIndex >= endIndex) return;
if (endIndex >= panels.size()) endIndex = panels.size();
for (size_t i = endIndex-1; i > startIndex; i--) {
const size_t target = Random::RandInt(startIndex, i);
if (i != target) {
// std::cout << "Swapping panels " << std::hex << panels[i] << " and " << std::hex << panels[target] << std::endl;
SwapPanels(panels[i], panels[target], flags);
std::swap(panels[i], panels[target]); // Panel indices in the array
}
}
}
void RandomizerCore::SwapPanels(int panel1, int panel2, int flags) {
std::map<int, int> offsets;
if (flags & SWAP_TARGETS) {
offsets[TARGET] = sizeof(int);
}
if (flags & SWAP_AUDIO_NAMES) {
offsets[AUDIO_LOG_NAME] = sizeof(void*);
}
if (flags & SWAP_LINES) {
offsets[PATH_COLOR] = 16;
offsets[REFLECTION_PATH_COLOR] = 16;
offsets[DOT_COLOR] = 16;
offsets[ACTIVE_COLOR] = 16;
offsets[BACKGROUND_REGION_COLOR] = 12; // Not copying alpha to preserve transparency.
offsets[SUCCESS_COLOR_A] = 16;
offsets[SUCCESS_COLOR_B] = 16;
offsets[STROBE_COLOR_A] = 16;
offsets[STROBE_COLOR_B] = 16;
offsets[ERROR_COLOR] = 16;
offsets[PATTERN_POINT_COLOR] = 16;
offsets[PATTERN_POINT_COLOR_A] = 16;
offsets[PATTERN_POINT_COLOR_B] = 16;
offsets[SYMBOL_A] = 16;
offsets[SYMBOL_B] = 16;
offsets[SYMBOL_C] = 16;
offsets[SYMBOL_D] = 16;
offsets[SYMBOL_E] = 16;
offsets[PUSH_SYMBOL_COLORS] = sizeof(int);
offsets[OUTER_BACKGROUND] = 16;
offsets[OUTER_BACKGROUND_MODE] = sizeof(int);
offsets[TRACED_EDGES] = 16;
offsets[AUDIO_PREFIX] = sizeof(void*);
// offsets[IS_CYLINDER] = sizeof(int);
// offsets[CYLINDER_Z0] = sizeof(float);
// offsets[CYLINDER_Z1] = sizeof(float);
// offsets[CYLINDER_RADIUS] = sizeof(float);
offsets[SPECULAR_ADD] = sizeof(float);
offsets[SPECULAR_POWER] = sizeof(int);
offsets[PATH_WIDTH_SCALE] = sizeof(float);
offsets[STARTPOINT_SCALE] = sizeof(float);
offsets[NUM_DOTS] = sizeof(int);
offsets[NUM_CONNECTIONS] = sizeof(int);
offsets[DOT_POSITIONS] = sizeof(void*);
offsets[DOT_FLAGS] = sizeof(void*);
offsets[DOT_CONNECTION_A] = sizeof(void*);
offsets[DOT_CONNECTION_B] = sizeof(void*);
offsets[DECORATIONS] = sizeof(void*);
offsets[DECORATION_FLAGS] = sizeof(void*);
offsets[DECORATION_COLORS] = sizeof(void*);
offsets[NUM_DECORATIONS] = sizeof(int);
offsets[REFLECTION_DATA] = sizeof(void*);
offsets[GRID_SIZE_X] = sizeof(int);
offsets[GRID_SIZE_Y] = sizeof(int);
offsets[STYLE_FLAGS] = sizeof(int);
offsets[SEQUENCE_LEN] = sizeof(int);
offsets[SEQUENCE] = sizeof(void*);
offsets[DOT_SEQUENCE_LEN] = sizeof(int);
offsets[DOT_SEQUENCE] = sizeof(void*);
offsets[DOT_SEQUENCE_LEN_REFLECTION] = sizeof(int);
offsets[DOT_SEQUENCE_REFLECTION] = sizeof(void*);
offsets[NUM_COLORED_REGIONS] = sizeof(int);
offsets[COLORED_REGIONS] = sizeof(void*);
offsets[PANEL_TARGET] = sizeof(void*);
offsets[SPECULAR_TEXTURE] = sizeof(void*);
}
for (auto const& [offset, size] : offsets) {
std::vector<byte> panel1data = _memory->ReadPanelData<byte>(panel1, offset, size);
std::vector<byte> panel2data = _memory->ReadPanelData<byte>(panel2, offset, size);
_memory->WritePanelData<byte>(panel2, offset, panel1data);
_memory->WritePanelData<byte>(panel1, offset, panel2data);
}
}
void RandomizerCore::ReassignTargets(const std::vector<int>& panels, const std::vector<int>& order, std::vector<int> targets) {
if (targets.empty()) {
// This list is offset by 1, so the target of the Nth panel is in position N (aka the N+1th element)
// The first panel may not have a wire to power it, so we use the panel ID itself.
targets = {panels[0] + 1};
for (const int panel : panels) {
int target = _memory->ReadPanelData<int>(panel, TARGET, 1)[0];
targets.push_back(target);
}
}
for (size_t i=0; i<order.size() - 1; i++) {
// Set the target of order[i] to order[i+1], using the "real" target as determined above.
const int panelTarget = targets[order[i+1]];
_memory->WritePanelData<int>(panels[order[i]], TARGET, {panelTarget});
}
}
void RandomizerCore::ReassignNames(const std::vector<int>& panels, const std::vector<int>& order) {
std::vector<int64_t> names;
for (const int panel : panels) {
names.push_back(_memory->ReadPanelData<int64_t>(panel, AUDIO_LOG_NAME, 1)[0]);
}
for (int i=0; i<panels.size(); i++) {
_memory->WritePanelData<int64_t>(panels[i], AUDIO_LOG_NAME, {names[order[i]]});
}
}
short RandomizerCore::ReadMetadata() {
return _memory->ReadData<short>({GLOBALS + METADATA}, 1)[0];
}
void RandomizerCore::WriteMetadata(short metadata) {
return _memory->WriteData<short>({GLOBALS + METADATA}, {metadata});
}
int RandomizerCore::GetCurrentFrame() {
return _memory->ReadData<int>({SCRIPT_FRAMES}, 1)[0];
}
|
