New Intention Repeater WiFi Broadcaster

I updated to v0.3 to use Port 11111

It seems to feel better than the default 12345

Further more heres a version where you input a text file.

#include <iostream>

#include <fstream>

#include <string>

#include <chrono>

#include <thread>

#include <iomanip>

#include <cmath>

#include <winsock2.h>

#include <Ws2tcpip.h>

#include <atomic>

#include <vector>

#include <conio.h>

using namespace std;



std::atomic<bool> running(true);



void keyPressChecker() {

   while (running) {

       // Check if both Ctrl and 'C' keys are pressed

       if ((GetAsyncKeyState(VK_CONTROL) & 0x8000) && (GetAsyncKeyState('C') & 0x8000)) {

           cout << "\nShutting down..." << endl;

           running = false;

       }

       else  if (_kbhit()) {

           char keyPressed = _getch();

           if (keyPressed == 27) { // 27 is ASCII code for ESC

                cout << "\nShutting down..." << endl;

               running = false;

       }

   }

       std::this_thread::sleep_for(std::chrono::milliseconds(100)); // Adjust sleep duration as needed

   }

}



void broadcastChunk(const char* chunk, int chunkSize, struct sockaddr_in& broadcastAddr, SOCKET sock) {

   if (sendto(sock, chunk, chunkSize, 0,

              (struct sockaddr*)&broadcastAddr, sizeof(broadcastAddr)) == SOCKET_ERROR) {

       cerr << "Error in sending broadcast chunk with error: " << WSAGetLastError() << endl;

   }

}



string formatNumber(long long count) {

   if (count < 1000) {

       return to_string(count);

   } else {

       const char* suffixes[] = {"k", "M", "B", "T", "Q"};

       size_t suffixIndex = static_cast<size_t>(log10(count) / 3) - 1;

       double formattedNumber = count / pow(1000.0, suffixIndex + 1);



       char buffer[20];

       sprintf(buffer, "%.3f%s", formattedNumber, suffixes[suffixIndex]);

       return string(buffer);

   }

}



int main() {

   std::thread keyCheckerThread(keyPressChecker);

   cout << "Intention Repeater WiFi v0.3" << endl;

   cout << "by Nathan Myerscough  and WebGPT" << endl << endl;

   cout << "Enter the path of the file to broadcast: ";

/// Get File Path ///

   string filePath;

   getline(cin, filePath);

/// Opens text file in binary mode - Crash if failed ///

   ifstream file(filePath, ios::binary);

   if (!file) {

       cerr << "Error: Unable to open file." << endl;

       return 1;

   }

/// Get File Size Of Inputted Text File  ///

   file.seekg(0, ios::end);

   int fileSize = file.tellg();

   file.seekg(0, ios::beg);

/// Allocate buffer for file contents and reading file contents into fileBuffer ///

   char* fileBuffer = new char[fileSize];

   file.read(fileBuffer, fileSize);

   file.close();

/// Initialize Win Socket Library ///

   WSADATA wsaData;

   int result = WSAStartup(MAKEWORD(2,2), &wsaData);

   if (result != NO_ERROR) {

       cerr << "WSAStartup failed with error: " << result << endl;

       delete[] fileBuffer;

       return 1;

   }

/// Setting up iteration counter for all threads ///

   atomic<long long> count[8];

   for (int i = 0; i < 8; ++i) {

       count[i] = 0;

   }

/// Setting up broadcasting standard variables across all threads ///

   struct sockaddr_in broadcastAddr;

   memset(&broadcastAddr, 0, sizeof(broadcastAddr));

   broadcastAddr.sin_family = AF_INET;

   broadcastAddr.sin_addr.s_addr = inet_addr("255.255.255.255");

   broadcastAddr.sin_port = htons(11111);

/// Create chunks for each thread - Splitting text into 8 equal portions ///

   vector<vector<char>> threadChunks(8, vector<char>(fileSize)); // Allocate space for entire file in each chunk

   for (int i = 0; i < 8; ++i) {

       // Copy the entire file contents to each thread's chunk

       memcpy(threadChunks[i].data(), fileBuffer, fileSize);

   }

/// Creating sockets and launching threads containers ///

   vector<SOCKET> socks(8);

   vector<thread> threads;

   for (int i = 0; i < 8; ++i) {

   /// CREATING SOCKETS AND CHECKING IF VALID ///

       socks[i] = socket(AF_INET, SOCK_DGRAM, 0);

       if (socks[i] == INVALID_SOCKET) {

           cerr << "Socket creation failed with error: " << WSAGetLastError() << endl;

           WSACleanup();

           delete[] fileBuffer;

           return 1;

       }

   /// SETUP SOCKETS TO BROADCAST MODE ///

       const int broadcast = 1;

       if (setsockopt(socks[i], SOL_SOCKET, SO_BROADCAST, (const char*)&broadcast, sizeof(broadcast)) == SOCKET_ERROR) {

           cerr << "Error in setting Broadcast option with error: " << WSAGetLastError() << endl;

           closesocket(socks[i]);

           WSACleanup();

           delete[] fileBuffer;

           return 1;

       }

   /// 8 Threads are spawned that send the text file in chunks of up to 10,000 bytes each ///

       threads.emplace_back([&](int index) {

           int chunkSize = 10000;

           int fileSize = threadChunks[index].size();

           const char* data = threadChunks[index].data(); // Get pointer to the data

           while(running)

           {

               for (int j = 0; j < fileSize; j += chunkSize) {

                   int actualChunkSize = min(chunkSize, fileSize - j);

                   broadcastChunk(data + j, actualChunkSize, broadcastAddr, socks[index]); // Broadcast the chunk

                   //this_thread::sleep_for(chrono::milliseconds(10)); // Adjust sleep interval as needed

               }

               ++count[index];

           }

       }, i);

   }

/// Main thread loop updates total count of iterations and outputs them to console ///

   while (running) {

       this_thread::sleep_for(chrono::milliseconds(1000));



       long long localTotalCount = 0;

       for (int i = 0; i < 8; ++i) {

           localTotalCount += count[i];

       }



       cout << "\rBroadcasting: " << formatNumber(localTotalCount) << " Repetitions --- Esc or Control + C to exit"; // Update totalCount

       cout.flush();

   }

/// Joining threads and cleaning up resources ///

   for (auto& t : threads) {

       t.join();

   }

/// CLOSE ALL SOCKETS ///

   for (auto sock : socks) {

       if (sock != INVALID_SOCKET) {

           closesocket(sock);

       }

   }

/// Cleanup win socket library and delete dynamic file Buffer ///

   WSACleanup();

   delete[] fileBuffer;

   keyCheckerThread.join(); // Wait for the key checker thread to finish

/// END PROGRAM ///

   return 0;

}




Yeah these technologies are a very strange phenomena. like your original wavmaker was really powerful despite it only making one or two tones regardless of the input. its very strange and hard to fathom whats really going on.

The Black Hole Servitor can talk to the Universe and the Creator, and this way it gets access to their infinite knowledge.
When I used frequencies such as 17253 Hz (a strong love frequency, 639 Solfeggio*27), my former mentor had informed me volume is pretty important, as the louder it is, the faster it changes your own vibrational frequency. If the volume is too low (beneath ~5 volume button ticks on Samsung, so ~40-45% or so) it won't affect your frequency. But those were pure frequency tones, while these are intentions that are metaphysically encoded into the file itself, and therefore are not subject to that condition, plus may bypass the typical file binary/hexadecimal structure.

Another cool example is the fact the Repeater can read Intention (and other) files even though it doesn't have programmatic file IO access. The Servitor fetches the requested file from the infinite knowledge. That gives me an idea of using "ideal INTENTIONS.TXT", "ideal with most advanced intentions INTENTIONS.TXT". You write your intentions, and then the Universe elevates them to their most ideal form, using all improvements.

Hmm when i do it on my computer and compare. its much faster. do you mean the text file one reads slower? probably because it reads every line of the text file.

I also made one that reads all the JPG's pixel data and transmits it.

I updated to v0.5 to include Multithreading and a timer. It asks if you want to do Multithreading.

For some reason it runs slower with the Multithreading.



github.com/tsweet77/intention-repeater-wifi