/* Things to do for V2: - Better interface design. It's way too simplistic, take (some) notes from talos. - Seed: [ ] (Randomize) ?? Challenge - [] Prevent speedrun snipes // Shadows, Swamp, Town, Quarry stairs - [] Speed up various autoscrollers // Swamp platforms, Desert/Mountain elevators, Desert rotating panels (Additional required panels) - [] Desert 8 - [] Pond 5 - [] Both keep halves - [] Town lattice requires stars door // and stars door will be randomized (Debug version only) - [] Noclip - [] Noclip speed - Really randomize panels. Sorted by ROI - Random with style - Tutorial - Mountain 1 orange, green, blue, purple - Mountain 2 multipanel - Mountain 3 pillars - Laser areas (Glass Factory, Symmetry, Quarry, Treehouse, Swamp, Keep pressure plates, Town 25 dots) - (low) Discarded panels - (low) Tutorials // Dots, Stones, Swamp - Keep Hedges become like hedges 4, intersection between path and panel - Keep Pressure plates: Random with style - No idea how to randomize: - Symmetry transparent - Desert - Shadows - Town (lattice, RGB area, snipes, triple) - Monastery - Jungle - Bunker - UTM - Mountain 2 rainbow - Challenge - Any RNG rerolls should be based on previous seed so that everyone can go to next seed easily - Stability. Duh. I need to clearly define the ownership between the randomizer and the game. - Challenge should have some way to 'reroll every run' - Challenge should not turn off after time limit? - Challenge triangles should not turn off */ /* * Try to wire up both keep halves * Wire up both halves of symmetry laser * Turn off floating panel in desert * Try randomizing default-on for pitches & bunker * Speed up *everything* ? Or maybe we'll just stop using this setting entirely. * Add setting for "Don't reset the challenge seed on new challenge" * Don't rerandomize anything outside of challenge on re-click * Change re-randomization prevention? * BUGS: * Shipwreck vault is solved reversed? -> Not reversed, just "half", you can normally solve orange. Seems to need pattern name. * Tutorial sounds don't always play -> Unsure. Not controlled by pattern name. * Rainbow seems to be not copying background? ** Rainbow 1 <-> Green 3 (the poly one) worked ** Rainbow 2 <-> Treehouse Right Orange 1 didn't * FEATURES: * Start the game if it isn't running? * Randomize audio logs -- Hard, seem to be unloaded some times? * Swap sounds in jungle (along with panels) -- maybe impossible * Make orange 7 (all of oranges?) hard. Like big = hard. (See: HARD_MODE) * Try turning on first half of wire in shadows once tutorial is done * It might be possible to remove the texture on top of rainbow 5 (so that any panel can be placed there) * 20 challenges with 20 consecutive seeds * Random *rotation* of desert laser redirect? */ #include "pch.h" #include "Randomizer.h" #include "ChallengeRandomizer.h" #include "Panels.h" #include "Random.h" template int find(const std::vector &data, T search, size_t startIndex = 0) { for (size_t i=startIndex ; i(i); } std::cout << "Couldn't find " << search << " in data!" << std::endl; throw std::exception("Couldn't find value in data!"); } Randomizer::Randomizer(const std::shared_ptr& memory) : _memory(memory) {} void Randomizer::Randomize() { // reveal_exit_hall - Prevent actually ending the game (EEE) _memory->AddSigScan({0x45, 0x8B, 0xF7, 0x48, 0x8B, 0x4D}, [&](int index){ _memory->WriteData({index + 0x15}, {0xEB}); // jz -> jmp }); // begin_endgame_1 - Prevent actually ending the game (Wonkavator) _memory->AddSigScan({0x83, 0x7C, 0x01, 0xD0, 0x04}, [&](int index){ if (GLOBALS == 0x5B28C0) { // Version differences. index += 0x75; } else if (GLOBALS == 0x62D0A0) { index += 0x86; } _memory->WriteData({index}, {0xEB}); // jz -> jmp }); // Sig scans will be run during challenge randomization. // Seed challenge first for future-proofing MEMORY_CATCH(RandomizeChallenge()); // Content swaps -- must happen before squarePanels //MEMORY_CATCH(Randomize(upDownPanels, SWAP::LINES | SWAP::COLORS)); //MEMORY_CATCH(Randomize(leftForwardRightPanels, SWAP::LINES | SWAP::COLORS)); // Tutorial Bend for (int panel : utmPerspective) { Tutorialise(panel, 0x00182); } // Tutorial Straight for (int panel : squarePanels) { Tutorialise(panel, 0x00064); } //Randomize(squarePanels, SWAP::LINES | SWAP::COLORS); // Individual area modifications MEMORY_CATCH(RandomizeTutorial()); MEMORY_CATCH(RandomizeDesert()); MEMORY_CATCH(RandomizeQuarry()); MEMORY_CATCH(RandomizeTreehouse()); MEMORY_CATCH(RandomizeKeep()); MEMORY_CATCH(RandomizeShadows()); MEMORY_CATCH(RandomizeMonastery()); MEMORY_CATCH(RandomizeBunker()); MEMORY_CATCH(RandomizeJungle()); MEMORY_CATCH(RandomizeSwamp()); MEMORY_CATCH(RandomizeMountain()); MEMORY_CATCH(RandomizeTown()); MEMORY_CATCH(RandomizeSymmetry()); // RandomizeAudioLogs(); } void Randomizer::AdjustSpeed() { // Desert Surface Final Control _memory->WriteEntityData(0x09F95, OPEN_RATE, {0.04f}); // 4x // Swamp Sliding Bridge _memory->WriteEntityData(0x0061A, OPEN_RATE, {0.1f}); // 4x // Mountain 2 Elevator _memory->WriteEntityData(0x09EEC, OPEN_RATE, {0.075f}); // 3x } void Randomizer::RandomizeLasers() { Randomize(lasers, SWAP::TARGETS); // Read the target of keep front laser, and write it to keep back laser. std::vector keepFrontLaserTarget = _memory->ReadEntityData(0x0360E, TARGET, 1); _memory->WriteEntityData(0x03317, TARGET, keepFrontLaserTarget); } void Randomizer::PreventSnipes() { // Distance-gate swamp snipe 1 to prevent RNG swamp snipe //_memory->WriteEntityData(0x17C05, MAX_BROADCAST_DISTANCE, {15.0}); // Distance-gate shadows laser to prevent sniping through the bars //_memory->WriteEntityData(0x19650, MAX_BROADCAST_DISTANCE, {2.5}); } // Private methods void Randomizer::RandomizeTutorial() { // Disable tutorial cursor speed modifications (not working?) _memory->WriteEntityData(0x00295, CURSOR_SPEED_SCALE, {1.0}); _memory->WriteEntityData(0x0C373, CURSOR_SPEED_SCALE, {1.0}); _memory->WriteEntityData(0x00293, CURSOR_SPEED_SCALE, {1.0}); _memory->WriteEntityData(0x002C2, CURSOR_SPEED_SCALE, {1.0}); } void Randomizer::RandomizeSymmetry() { /*std::vector randomOrder(transparent.size(), 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); RandomizeRange(randomOrder, SWAP::NONE, 1, 5); ReassignTargets(transparent, randomOrder);*/ } void Randomizer::RandomizeDesert() { //Randomize(desertPanels, SWAP::LINES); // Turn off desert surface 8 /*_memory->WriteEntityData(0x09F94, POWER, {0.0, 0.0}); // Turn off desert flood final _memory->WriteEntityData(0x18076, POWER, {0.0, 0.0}); // Change desert floating target to desert flood final _memory->WriteEntityData(0x17ECA, TARGET, {0x18077});*/ } void Randomizer::RandomizeQuarry() { } void Randomizer::RandomizeTreehouse() { // Ensure that whatever pivot panels we have are flagged as "pivotable" // @Bug: Can return {}, be careful! int panelFlags = _memory->ReadEntityData(0x17DD1, STYLE_FLAGS, 1)[0]; _memory->WriteEntityData(0x17DD1, STYLE_FLAGS, {panelFlags | 0x8000}); panelFlags = _memory->ReadEntityData(0x17CE3, STYLE_FLAGS, 1)[0]; _memory->WriteEntityData(0x17CE3, STYLE_FLAGS, {panelFlags | 0x8000}); panelFlags = _memory->ReadEntityData(0x17DB7, STYLE_FLAGS, 1)[0]; _memory->WriteEntityData(0x17DB7, STYLE_FLAGS, {panelFlags | 0x8000}); panelFlags = _memory->ReadEntityData(0x17E52, STYLE_FLAGS, 1)[0]; _memory->WriteEntityData(0x17E52, STYLE_FLAGS, {panelFlags | 0x8000}); } void Randomizer::RandomizeKeep() { } void Randomizer::RandomizeShadows() { // Change the shadows tutorial cable to only activate avoid _memory->WriteEntityData(0x319A8, CABLE_TARGET_2, {0}); // Change shadows avoid 8 to power shadows follow _memory->WriteEntityData(0x1972F, TARGET, {0x1C34C}); /*std::vector randomOrder(shadowsPanels.size(), 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); RandomizeRange(randomOrder, SWAP::NONE, 0, 8); // Tutorial RandomizeRange(randomOrder, SWAP::NONE, 8, 16); // Avoid RandomizeRange(randomOrder, SWAP::NONE, 16, 21); // Follow ReassignTargets(shadowsPanels, randomOrder); // Turn off original starting panel _memory->WriteEntityData(shadowsPanels[0], POWER, {0.0f, 0.0f}); // Turn on new starting panel _memory->WriteEntityData(shadowsPanels[randomOrder[0]], POWER, {1.0f, 1.0f});*/ } void Randomizer::RandomizeTown() { // @Hack...? To open the gate at the end /*std::vector randomOrder(orchard.size() + 1, 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); RandomizeRange(randomOrder, SWAP::NONE, 1, 5); // Ensure that we open the gate before the final puzzle (by swapping) int panel3Index = find(randomOrder, 3); int panel4Index = find(randomOrder, 4); randomOrder[std::min(panel3Index, panel4Index)] = 3; randomOrder[std::max(panel3Index, panel4Index)] = 4; ReassignTargets(orchard, randomOrder);*/ } void Randomizer::RandomizeMonastery() { /*std::vector randomOrder(monasteryPanels.size(), 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); RandomizeRange(randomOrder, SWAP::NONE, 3, 9); // Outer 2 & 3, Inner 1-4 ReassignTargets(monasteryPanels, randomOrder);*/ } void Randomizer::RandomizeBunker() { /*std::vector randomOrder(bunkerPanels.size(), 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); // Randomize Tutorial 2-Advanced Tutorial 4 + Glass 1 // Tutorial 1 cannot be randomized, since no other panel can start on // Glass 1 will become door + glass 1, due to the targetting system RandomizeRange(randomOrder, SWAP::NONE, 1, 10); // Randomize Glass 1-3 into everything after the door/glass 1 const size_t glass1Index = find(randomOrder, 9); RandomizeRange(randomOrder, SWAP::NONE, glass1Index + 1, 12); ReassignTargets(bunkerPanels, randomOrder);*/ } void Randomizer::RandomizeJungle() { /*std::vector randomOrder(junglePanels.size(), 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); // Waves 1 cannot be randomized, since no other panel can start on RandomizeRange(randomOrder, SWAP::NONE, 1, 7); // Waves 2-7 RandomizeRange(randomOrder, SWAP::NONE, 8, 13); // Pitches 1-6 ReassignTargets(junglePanels, randomOrder);*/ // Fix the wall's target to point back to the cable, and the cable to point to the pitches panel. // auto wallTarget = _memory->ReadPanelData(junglePanels[7], TARGET, 1); // _memory->WritePanelData(junglePanels[7], TARGET, {0x3C113}); // _memory->WritePanelData(0x3C112, CABLE_TARGET_1, wallTarget); } void Randomizer::RandomizeSwamp() { } void Randomizer::RandomizeMountain() { // Randomize multipanel //Randomize(mountainMultipanel, SWAP::LINES | SWAP::COLORS); // Randomize final pillars order /*std::vector targets = {pillars[0] + 1}; for (const int pillar : pillars) { int target = _memory->ReadEntityData(pillar, TARGET, 1)[0]; targets.push_back(target); } targets[5] = pillars[5] + 1; std::vector randomOrder(pillars.size(), 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); RandomizeRange(randomOrder, SWAP::NONE, 0, 4); // Left Pillars 1-4 RandomizeRange(randomOrder, SWAP::NONE, 5, 9); // Right Pillars 1-4 ReassignTargets(pillars, randomOrder, targets); // Turn off original starting panels _memory->WriteEntityData(pillars[0], POWER, {0.0f, 0.0f}); _memory->WriteEntityData(pillars[5], POWER, {0.0f, 0.0f}); // Turn on new starting panels _memory->WriteEntityData(pillars[randomOrder[0]], POWER, {1.0f, 1.0f}); _memory->WriteEntityData(pillars[randomOrder[5]], POWER, {1.0f, 1.0f});*/ } void Randomizer::RandomizeChallenge() { /*ChallengeRandomizer cr(_memory, Random::RandInt(1, 0x7FFFFFFF)); // 0 will trigger an "RNG not initialized" block for (int panel : challengePanels) { _memory->WriteEntityData(panel, POWER_OFF_ON_FAIL, {0}); }*/ } void Randomizer::RandomizeAudioLogs() { std::vector randomOrder(audiologs.size(), 0); std::iota(randomOrder.begin(), randomOrder.end(), 0); Randomize(randomOrder, SWAP::NONE); ReassignNames(audiologs, randomOrder); } void Randomizer::Randomize(std::vector& panels, int flags) { return RandomizeRange(panels, flags, 0, panels.size()); } // Range is [start, end) void Randomizer::RandomizeRange(std::vector &panels, int flags, size_t startIndex, size_t endIndex) { if (panels.size() == 0) return; if (startIndex >= endIndex) return; if (endIndex >= panels.size()) endIndex = static_cast(panels.size()); for (size_t i = 0; i < panels.size(); i++) { /*const int target = Random::RandInt(static_cast(startIndex), static_cast(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 Randomizer::Tutorialise(int panel1, int tutorialStraight) { //const int tutorialStraight = 0x00064; _memory->CopyEntityData(tutorialStraight, panel1, PATH_COLOR, 16); _memory->CopyEntityData(tutorialStraight, panel1, REFLECTION_PATH_COLOR, 16); _memory->CopyEntityData(tutorialStraight, panel1, DOT_COLOR, 16); _memory->CopyEntityData(tutorialStraight, panel1, ACTIVE_COLOR, 16); _memory->CopyEntityData(tutorialStraight, panel1, BACKGROUND_REGION_COLOR, 12); _memory->CopyEntityData(tutorialStraight, panel1, SUCCESS_COLOR_A, 16); _memory->CopyEntityData(tutorialStraight, panel1, SUCCESS_COLOR_B, 16); _memory->CopyEntityData(tutorialStraight, panel1, STROBE_COLOR_A, 16); _memory->CopyEntityData(tutorialStraight, panel1, STROBE_COLOR_B, 16); _memory->CopyEntityData(tutorialStraight, panel1, ERROR_COLOR, 16); _memory->CopyEntityData(tutorialStraight, panel1, PATTERN_POINT_COLOR, 16); _memory->CopyEntityData(tutorialStraight, panel1, PATTERN_POINT_COLOR_A, 16); _memory->CopyEntityData(tutorialStraight, panel1, PATTERN_POINT_COLOR_B, 16); _memory->CopyEntityData(tutorialStraight, panel1, SYMBOL_A, 16); _memory->CopyEntityData(tutorialStraight, panel1, SYMBOL_B, 16); _memory->CopyEntityData(tutorialStraight, panel1, SYMBOL_C, 16); _memory->CopyEntityData(tutorialStraight, panel1, SYMBOL_D, 16); _memory->CopyEntityData(tutorialStraight, panel1, SYMBOL_E, 16); _memory->CopyEntityData(tutorialStraight, panel1, PUSH_SYMBOL_COLORS, sizeof(int)); _memory->CopyEntityData(tutorialStraight, panel1, OUTER_BACKGROUND, 16); _memory->CopyEntityData(tutorialStraight, panel1, OUTER_BACKGROUND_MODE, sizeof(int)); _memory->CopyEntityData(tutorialStraight, panel1, NUM_COLORED_REGIONS, sizeof(int)); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, COLORED_REGIONS, NUM_COLORED_REGIONS); _memory->CopyEntityData(tutorialStraight, panel1, TRACED_EDGES, 16); _memory->CopyEntityData(tutorialStraight, panel1, PATH_WIDTH_SCALE, sizeof(float)); _memory->CopyEntityData(tutorialStraight, panel1, STARTPOINT_SCALE, sizeof(float)); _memory->CopyEntityData(tutorialStraight, panel1, NUM_DOTS, sizeof(int)); _memory->CopyEntityData(tutorialStraight, panel1, NUM_CONNECTIONS, sizeof(int)); _memory->CopyArray(tutorialStraight, panel1, DOT_POSITIONS, _memory->ReadEntityData(tutorialStraight, NUM_DOTS, sizeof(int))[0]*2); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DOT_FLAGS, NUM_DOTS); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DOT_CONNECTION_A, NUM_CONNECTIONS); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DOT_CONNECTION_B, NUM_CONNECTIONS); _memory->CopyEntityData(tutorialStraight, panel1, NUM_DECORATIONS, sizeof(int)); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DECORATIONS, NUM_DECORATIONS); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DECORATION_FLAGS, NUM_DECORATIONS); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DECORATION_COLORS, NUM_DECORATIONS); //_memory->CopyArrayDynamicSize(tutorialStraight, panel1, REFLECTION_DATA, NUM_DOTS); _memory->WritePanelData(panel1, REFLECTION_DATA, { 0 }); _memory->CopyEntityData(tutorialStraight, panel1, SEQUENCE_LEN, sizeof(int)); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, SEQUENCE, SEQUENCE_LEN); _memory->CopyEntityData(tutorialStraight, panel1, DOT_SEQUENCE_LEN, sizeof(int)); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DOT_SEQUENCE, DOT_SEQUENCE_LEN); _memory->CopyEntityData(tutorialStraight, panel1, DOT_SEQUENCE_LEN_REFLECTION, sizeof(int)); _memory->CopyArrayDynamicSize(tutorialStraight, panel1, DOT_SEQUENCE_REFLECTION, DOT_SEQUENCE_LEN_REFLECTION); _memory->CopyEntityData(tutorialStraight, panel1, GRID_SIZE_X, sizeof(int)); _memory->CopyEntityData(tutorialStraight, panel1, GRID_SIZE_Y, sizeof(int)); _memory->CopyEntityData(tutorialStraight, panel1, STYLE_FLAGS, sizeof(int)); //arrays.push_back(AUDIO_PREFIX); // offsets[IS_CYLINDER] = sizeof(int); // offsets[CYLINDER_Z0] = sizeof(float); // offsets[CYLINDER_Z1] = sizeof(float); // offsets[CYLINDER_RADIUS] = sizeof(float); //arrays.push_back(PANEL_TARGET); //arrays.push_back(SPECULAR_TEXTURE); } void Randomizer::ReassignTargets(const std::vector& panels, const std::vector& order, std::vector 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->ReadEntityData(panel, TARGET, 1)[0]; targets.push_back(target); } } for (size_t i=0; iWriteEntityData(panels[order[i]], TARGET, {panelTarget}); } } void Randomizer::ReassignNames(const std::vector& panels, const std::vector& order) { std::vector names; for (const int panel : panels) { names.push_back(_memory->ReadEntityData(panel, AUDIO_LOG_NAME, 1)[0]); } for (int i=0; iWriteEntityData(panels[i], AUDIO_LOG_NAME, {names[order[i]]}); } }