├── CPPBot.sln ├── CPPBot ├── CPPBot.cpp ├── CPPBot.vcxproj ├── CPPBot.vcxproj.filters ├── CPPBot.vcxproj.user ├── corefunc.h ├── enet │ ├── callbacks.c │ ├── compress.c │ ├── host.c │ ├── include │ │ ├── callbacks.h │ │ ├── enet.h │ │ ├── list.h │ │ ├── protocol.h │ │ ├── time2.h │ │ ├── types.h │ │ ├── unix.h │ │ ├── utility.h │ │ └── win32.h │ ├── list.c │ ├── packet.c │ ├── peer.c │ ├── protocol.c │ ├── unix.c │ └── win32.c ├── json.hpp ├── packet.h ├── pch.cpp ├── pch.h ├── proton │ ├── hash.hpp │ ├── rtparam.hpp │ ├── variant.hpp │ └── vector.hpp ├── userfunc.h └── utilsfunc.h └── README.md /CPPBot.sln: -------------------------------------------------------------------------------- 1 | 2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 15 4 | VisualStudioVersion = 15.0.28307.757 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CPPBot", "CPPBot\CPPBot.vcxproj", "{BCD48403-BF4B-470C-B278-D38109CD95FC}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Debug|x64.ActiveCfg = Debug|x64 17 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Debug|x64.Build.0 = Debug|x64 18 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Debug|x86.ActiveCfg = Debug|Win32 19 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Debug|x86.Build.0 = Debug|Win32 20 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Release|x64.ActiveCfg = Release|x64 21 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Release|x64.Build.0 = Release|x64 22 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Release|x86.ActiveCfg = Release|Win32 23 | {BCD48403-BF4B-470C-B278-D38109CD95FC}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {0593AC20-A111-42A0-A647-99073A4DAAEF} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /CPPBot/CPPBot.cpp: -------------------------------------------------------------------------------- 1 | // CPPBot.cpp : This file contains the 'main' function. Program execution begins and ends there. 2 | 3 | #include "pch.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include "corefunc.h" 10 | #include "userfunc.h" 11 | #include "json.hpp" 12 | #include 13 | #include 14 | #include 15 | #define GetCurrentDir _getcwd 16 | 17 | using namespace std; 18 | using json = nlohmann::json; 19 | 20 | vector bots; 21 | 22 | inline bool exists_test(const string& name) { 23 | ifstream f(name.c_str()); 24 | return f.good(); 25 | } 26 | 27 | int main() { 28 | init(); 29 | cout << "GrowtopiaBot v1.0 [Not included QT]! by GrowtopiaNoobs and DrOreo002" << endl; 30 | char cCurrentPath[FILENAME_MAX]; 31 | 32 | if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath))) 33 | { 34 | return errno; 35 | } 36 | 37 | cCurrentPath[sizeof(cCurrentPath) - 1] = '\0'; 38 | string botDataPath = cCurrentPath + string("\\bot.json"); 39 | 40 | if (!exists_test(botDataPath)) { 41 | cout << "Cannot find bot data on that path!. Stuck?, please read README.md" << endl; 42 | return 0; 43 | } 44 | cout << "Loading bot data on path (" << botDataPath << ")" << endl; 45 | 46 | ifstream i(botDataPath); 47 | json j; 48 | i >> j; 49 | 50 | GrowtopiaBot bot = { 51 | j["username"], j["password"] 52 | }; 53 | cout << "------------------------" << endl; 54 | cout << "Bot loaded!. Using username " << j["username"].get() << ", With owner " + j["ownerUsername"].get() << endl; 55 | 56 | bot.gameVersion = j["gameVersion"].get(); 57 | bot.worldName = j["targetWorld"].get(); 58 | bot.ownerUsername = j["ownerUsername"].get(); 59 | 60 | bot.userInit(); 61 | bots.push_back(bot); 62 | 63 | while (true) { 64 | bot.eventLoop(); 65 | bot.userLoop(); 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /CPPBot/CPPBot.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 15.0 23 | {BCD48403-BF4B-470C-B278-D38109CD95FC} 24 | Win32Proj 25 | CPPBot 26 | 10.0.17763.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v141 33 | Unicode 34 | 35 | 36 | Application 37 | false 38 | v141 39 | true 40 | Unicode 41 | 42 | 43 | Application 44 | true 45 | v141 46 | Unicode 47 | 48 | 49 | Application 50 | false 51 | v141 52 | true 53 | Unicode 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | true 75 | 76 | 77 | true 78 | 79 | 80 | false 81 | 82 | 83 | false 84 | 85 | 86 | 87 | Use 88 | Level3 89 | Disabled 90 | true 91 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 92 | true 93 | pch.h 94 | 95 | 96 | Console 97 | true 98 | enet.lib;ws2_32.lib;winmm.lib;%(AdditionalDependencies) 99 | 100 | 101 | 102 | 103 | NotUsing 104 | Level3 105 | Disabled 106 | true 107 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 108 | true 109 | pch.h 110 | 111 | 112 | Console 113 | true 114 | ws2_32.lib;winmm.lib;%(AdditionalDependencies) 115 | 116 | 117 | 118 | 119 | Use 120 | Level3 121 | MaxSpeed 122 | true 123 | true 124 | true 125 | WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 126 | true 127 | pch.h 128 | 129 | 130 | Console 131 | true 132 | true 133 | true 134 | enet.lib;ws2_32.lib;winmm.lib;%(AdditionalDependencies) 135 | false 136 | 137 | 138 | 139 | 140 | NotUsing 141 | Level3 142 | MaxSpeed 143 | true 144 | true 145 | true 146 | NDEBUG;_CONSOLE;%(PreprocessorDefinitions) 147 | true 148 | pch.h 149 | 150 | 151 | Console 152 | true 153 | true 154 | true 155 | ws2_32.lib;winmm.lib;%(AdditionalDependencies) 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | Create 186 | Create 187 | Create 188 | Create 189 | 190 | 191 | 192 | 193 | 194 | -------------------------------------------------------------------------------- /CPPBot/CPPBot.vcxproj.filters: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | {570099a0-b0de-4614-b36c-030ad4062f98} 18 | 19 | 20 | 21 | 22 | Header Files 23 | 24 | 25 | Header Files 26 | 27 | 28 | Header Files 29 | 30 | 31 | Header Files 32 | 33 | 34 | enet 35 | 36 | 37 | enet 38 | 39 | 40 | enet 41 | 42 | 43 | enet 44 | 45 | 46 | enet 47 | 48 | 49 | enet 50 | 51 | 52 | enet 53 | 54 | 55 | enet 56 | 57 | 58 | enet 59 | 60 | 61 | 62 | 63 | Source Files 64 | 65 | 66 | Source Files 67 | 68 | 69 | enet 70 | 71 | 72 | enet 73 | 74 | 75 | enet 76 | 77 | 78 | enet 79 | 80 | 81 | enet 82 | 83 | 84 | enet 85 | 86 | 87 | enet 88 | 89 | 90 | enet 91 | 92 | 93 | enet 94 | 95 | 96 | -------------------------------------------------------------------------------- /CPPBot/CPPBot.vcxproj.user: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /CPPBot/corefunc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Grotopia Bot 4 | // Copyright (C) 2018 Growtopia Noobs 5 | // 6 | // This program is free software: you can redistribute it and/or modify 7 | // it under the terms of the GNU Affero General Public License as published 8 | // by the Free Software Foundation, either version 3 of the License, or 9 | // (at your option) any later version. 10 | // 11 | // This program is distributed in the hope that it will be useful, 12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | // GNU Affero General Public License for more details. 15 | // 16 | // You should have received a copy of the GNU Affero General Public License 17 | // along with this program. If not, see . 18 | 19 | #include "enet/include/enet.h" 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include "proton/variant.hpp" 27 | #include "packet.h" 28 | 29 | using namespace std; 30 | bool replace(std::string& str, const std::string& from, const std::string& to) { 31 | size_t start_pos = str.find(from); 32 | if (start_pos == std::string::npos) 33 | return false; 34 | str.replace(start_pos, from.length(), to); 35 | return true; 36 | } 37 | string SERVER_HOST = "213.179.209.168"; 38 | int SERVER_PORT = 17196; 39 | 40 | /********* hidden vars ********/ 41 | class GrowtopiaBot 42 | { 43 | public: 44 | ENetPeer *peer; 45 | ENetHost *client; 46 | 47 | int login_user = 0; 48 | int login_token = 0; 49 | 50 | string currentWorld; 51 | int timeFromWorldEnter = 0; // in 10mss... 52 | 53 | string gameVersion = "3.011"; 54 | /********* hidden vars ********/ 55 | 56 | /********** user sutff ***************/ 57 | int owner = -1; 58 | string ownerUsername; 59 | 60 | int localx=-1; 61 | int localy=-1; 62 | int localnetid=-1; 63 | 64 | struct ObjectData 65 | { 66 | int netId = -1; // used to interact with stuff in world 67 | int userId = -1; // growtopia id 68 | string name = ""; 69 | string country = ""; 70 | string objectType = ""; // "avatar" is player creature 71 | float x = -1; 72 | float y = -1; 73 | bool isGone = false; // set true if character left 74 | int rectX; // collision stuff 75 | int rectY; // collision stuff 76 | int rectWidth; // collision stuff 77 | int rectHeight; // collision stuff 78 | bool isMod = false; 79 | bool isLocal = false; 80 | }; 81 | 82 | vector objects; 83 | 84 | string uname; 85 | string upass; 86 | string worldName; // excepted world name 87 | 88 | bool isFollowing = false; 89 | bool backwardWalk = false; 90 | 91 | int respawnX; 92 | int respawnY; 93 | /********** user sutff ***************/ 94 | 95 | /*********** structs declaration *********/ 96 | struct PlayerMoving 97 | { 98 | int netID; 99 | float x; 100 | float y; 101 | int characterState; 102 | int plantingTree; 103 | float XSpeed; 104 | float YSpeed; 105 | int punchX; 106 | int punchY; 107 | }; 108 | /*********** structs declaration *********/ 109 | 110 | /********* user funcs *********/ 111 | void userRender(); 112 | void userRender2(); 113 | void userLoop(); 114 | void userInit(); 115 | void onLoginRequested(); 116 | void packet_type3(string text); 117 | void packet_type6(string text); 118 | void packet_unknown(ENetPacket *packet); 119 | void OnSendToServer(string address, int port, int userId, int token); 120 | void OnConsoleMessage(string message); 121 | void OnPlayPositioned(string sound); 122 | void OnSetFreezeState(int state); 123 | void OnRemove(string data); 124 | void OnSpawn(string data); 125 | void OnAction(string command); 126 | void SetHasGrowID(int state, string name, string password); 127 | void SetHasAccountSecured(int state); 128 | void OnTalkBubble(int netID, string bubbleText, int type); 129 | void SetRespawnPos(int respawnPos); 130 | void OnEmoticonDataChanged(int val1, string emoticons); 131 | void OnSetPos(float x, float y); 132 | void OnAddNotification(string image, string message, string audio, int val1); 133 | void AtApplyTileDamage(int x, int y, int damge); 134 | void AtApplyLock(int x, int y, int itemId); 135 | void AtPlayerMoving(PlayerMoving *data); 136 | void AtAvatarSetIconState(int netID, int state); 137 | void WhenConnected(); 138 | void WhenDisconnected(); 139 | 140 | void respawn(); 141 | /********* user funcs *********/ 142 | 143 | /*************** debug stuff ***************/ 144 | void dbgPrint(string text) 145 | { 146 | cout << "[DBG] " + text << endl; 147 | } 148 | /*************** debug stuff ***************/ 149 | 150 | GrowtopiaBot(string username, string password) 151 | { 152 | this->uname = username; 153 | this->upass = password; 154 | } 155 | 156 | /******************* enet core *********************/ 157 | void SendPacket(int a1, string a2, ENetPeer *enetPeer) 158 | { 159 | if (enetPeer) 160 | { 161 | ENetPacket *v3 = enet_packet_create(0, a2.length() + 5, 1); 162 | memcpy(v3->data, &a1, 4); 163 | //*(v3->data) = (DWORD)a1; 164 | memcpy((v3->data) + 4, a2.c_str(), a2.length()); 165 | 166 | //cout << std::hex << (int)(char)v3->data[3] << endl; 167 | enet_peer_send(enetPeer, 0, v3); 168 | } 169 | } 170 | 171 | void SendPacketNew(int type, uint8_t* data, int len) 172 | { 173 | auto packet = enet_packet_create(0, len + 5, ENET_PACKET_FLAG_RELIABLE); 174 | auto game_packet = (gametextpacket_t*)packet->data; 175 | game_packet->m_type = type; 176 | if (data) 177 | memcpy(&game_packet->m_data, data, len); 178 | 179 | memset(&game_packet->m_data + len, 0, 1); 180 | int code = enet_peer_send(peer, 0, packet); 181 | if (code != 0) 182 | printf("Error sending packet! code: %d\n", code); 183 | enet_host_flush(client); 184 | 185 | } 186 | 187 | void SendPacketRaw(int a1, void *packetData, size_t packetDataSize, void *a4, ENetPeer *peer, int packetFlag) 188 | { 189 | ENetPacket *p; 190 | 191 | if (peer) // check if we have it setup 192 | { 193 | if (a1 == 4 && *((BYTE *)packetData + 12) & 8) 194 | { 195 | p = enet_packet_create(0, packetDataSize + *((DWORD *)packetData + 13) + 5, packetFlag); 196 | int four = 4; 197 | memcpy(p->data, &four, 4); 198 | memcpy((char *)p->data + 4, packetData, packetDataSize); 199 | memcpy((char *)p->data + packetDataSize + 4, a4, *((DWORD *)packetData + 13)); 200 | enet_peer_send(peer, 0, p); 201 | } 202 | else 203 | { 204 | p = enet_packet_create(0, packetDataSize + 5, packetFlag); 205 | memcpy(p->data, &a1, 4); 206 | memcpy((char *)p->data + 4, packetData, packetDataSize); 207 | enet_peer_send(peer, 0, p); 208 | } 209 | } 210 | } 211 | 212 | // Connect with default value 213 | void connectClient() 214 | { 215 | connectClient(SERVER_HOST, SERVER_PORT); 216 | } 217 | 218 | void connectClient(string hostName, int port) 219 | { 220 | cout << "Connecting bot to " << hostName << ":" << port << endl; 221 | client = enet_host_create(NULL /* create a client host */, 222 | 1 /* only allow 1 outgoing connection */, 223 | 2 /* allow up 2 channels to be used, 0 and 1 */, 224 | 0 /* 56K modem with 56 Kbps downstream bandwidth */, 225 | 0 /* 56K modem with 14 Kbps upstream bandwidth */); 226 | if (client == NULL) 227 | { 228 | cout << "An error occurred while trying to create an ENet client host.\n"; 229 | _getch(); 230 | exit(EXIT_FAILURE); 231 | } 232 | ENetAddress address; 233 | client->usingNewPacket = true; 234 | client->checksum = enet_crc32; 235 | enet_host_compress_with_range_coder(client); 236 | enet_address_set_host(&address, hostName.c_str()); 237 | address.port = port; 238 | 239 | /* Initiate the connection, allocating the two channels 0 and 1. */ 240 | peer = enet_host_connect(client, &address, 2, 0); 241 | if (peer == NULL) 242 | { 243 | cout << "No available peers for initiating an ENet connection.\n"; 244 | _getch(); 245 | exit(EXIT_FAILURE); 246 | } 247 | enet_host_flush(client); 248 | } 249 | /******************* enet core *********************/ 250 | 251 | /*************** sender sutff **************/ 252 | 253 | void RequestItemActivate(unsigned int item) 254 | { 255 | BYTE *data = new BYTE[56]; 256 | for (int i = 0; i < 56; i++) 257 | { 258 | data[i] = 0; 259 | } 260 | BYTE ten = 10; 261 | memcpy(data + 0, &ten, 1); 262 | memcpy(data + 20, &item, 1); 263 | SendPacketRaw(4, data, 0x38u, 0, peer, 1); 264 | free(data); 265 | } 266 | 267 | void SetAndBroadcastIconState(int netID, int state) 268 | { 269 | BYTE *data = new BYTE[56]; 270 | for (int i = 0; i < 56; i++) 271 | { 272 | data[i] = 0; 273 | } 274 | BYTE eighteen = 18; 275 | memcpy(data + 0, &eighteen, 1); 276 | memcpy(data + 4, &netID, 4); // (a1+40) 277 | memcpy(data + 44, &state, 4); 278 | SendPacketRaw(4, data, 0x38u, 0, peer, 1); 279 | free(data); 280 | } 281 | 282 | void SendPing() 283 | { 284 | BYTE *data = new BYTE[56]; 285 | for (int i = 0; i < 56; i++) 286 | { 287 | data[i] = 0; 288 | } 289 | BYTE twentytwo = 22; 290 | memcpy(data + 0, &twentytwo, 1); 291 | SendPacketRaw(4, data, 56, 0, peer, 1); 292 | free(data); 293 | } 294 | 295 | /*************** sender sutff **************/ 296 | 297 | int GetMessageTypeFromPacket(ENetPacket *packet) 298 | { 299 | int result; 300 | 301 | if (packet->dataLength > 3u) 302 | { 303 | result = *(packet->data); 304 | } 305 | else 306 | { 307 | cout << "Bad packet length, ignoring message" << endl; 308 | result = 0; 309 | } 310 | return result; 311 | } 312 | 313 | char *GetTextPointerFromPacket(ENetPacket *packet) 314 | { 315 | char zero = 0; 316 | memcpy(packet->data + packet->dataLength - 1, &zero, 1); 317 | return (char *)(packet->data + 4); 318 | } 319 | 320 | void handlevarlist(uint8_t *data) 321 | { 322 | variantlist_t varlist{}; 323 | varlist.serialize_from_mem(data+56); 324 | printf("varlist: %s\n", varlist.print().c_str()); 325 | 326 | auto action = varlist[0].get_string(); 327 | if (action == "OnSendToServer") 328 | { 329 | OnSendToServer(varlist[4].get_string(), varlist[1].get_int32(), varlist[3].get_int32(), varlist[2].get_int32()); 330 | } 331 | else if (action == "OnConsoleMessage") 332 | { 333 | OnConsoleMessage(varlist[1].get_string()); 334 | }else if (action == "OnRemove") 335 | { 336 | OnRemove(varlist[1].get_string()); 337 | } 338 | else if (action == "OnSpawn") 339 | { 340 | OnSpawn(varlist[1].get_string()); 341 | }else if (action == "OnTalkBubble") 342 | { 343 | OnTalkBubble(varlist[1].get_int32(), varlist[2].get_string(), 0); 344 | }else if (action == "OnDialogRequest") 345 | { 346 | string dialog = varlist[1].get_string(); 347 | if (dialog.find("con|big|`wAre you Human?``|left|20") != string::npos) 348 | { 349 | replace(dialog, 350 | "set_default_color|`o\nadd_label_with_icon|big|`wAre you Human?``|left|206|\nadd_spacer|small|\nadd_textbox|What will be the sum of the following " 351 | "numbers|left|\nadd_textbox|", 352 | ""); 353 | replace(dialog, "|left|\nadd_text_input|captcha_answer|Answer:||32|\nend_dialog|captcha_submit||Submit|", ""); 354 | auto number1 = dialog.substr(0, dialog.find(" +")); 355 | auto number2 = dialog.substr(number1.length() + 3, dialog.length()); 356 | int result = atoi(number1.c_str()) + atoi(number2.c_str()); 357 | 358 | SendPacket(2,"action|dialog_return\ndialog_name|captcha_submit\ncaptcha_answer|" + std::to_string(result), peer); 359 | } 360 | }else if (action == "onShowCaptcha") 361 | { 362 | string dialog = varlist[1].get_string(); 363 | if (dialog.find("con|big|`wAre you Human?``|left|20") != string::npos) 364 | { 365 | replace(dialog, 366 | "set_default_color|`o\nadd_label_with_icon|big|`wAre you Human?``|left|206|\nadd_spacer|small|\nadd_textbox|What will be the sum of the following " 367 | "numbers|left|\nadd_textbox|", 368 | ""); 369 | replace(dialog, "|left|\nadd_text_input|captcha_answer|Answer:||32|\nend_dialog|captcha_submit||Submit|", ""); 370 | auto number1 = dialog.substr(0, dialog.find(" +")); 371 | auto number2 = dialog.substr(number1.length() + 3, dialog.length()); 372 | int result = atoi(number1.c_str()) + atoi(number2.c_str()); 373 | 374 | SendPacket(2,"action|dialog_return\ndialog_name|captcha_submit\ncaptcha_answer|" + std::to_string(result), peer); 375 | } 376 | } 377 | } 378 | 379 | BYTE *GetExtendedDataPointerFromTankPacket(BYTE *a1) 380 | { 381 | return (BYTE *)(/*(*(int *)(a1 + 12) << 28 >> 31) & */ (int)(a1 + 56)); 382 | } 383 | 384 | void HandlePacketTileChangeRequest(gameupdatepacket_t*data) 385 | { 386 | 387 | } 388 | 389 | struct WorldThingStruct 390 | { 391 | }; 392 | 393 | struct WorldStruct 394 | { 395 | int XSize; 396 | int YSize; 397 | int tileCount; 398 | string name; 399 | __int16 *foreground; 400 | __int16 *background; 401 | WorldThingStruct *specials; 402 | }; 403 | 404 | BYTE *packPlayerMoving(PlayerMoving *dataStruct) 405 | { 406 | BYTE *data = new BYTE[56]; 407 | for (int i = 0; i < 56; i++) 408 | { 409 | data[i] = 0; 410 | } 411 | memcpy(data + 4, &dataStruct->netID, 4); 412 | memcpy(data + 12, &dataStruct->characterState, 4); 413 | memcpy(data + 20, &dataStruct->plantingTree, 4); 414 | memcpy(data + 24, &dataStruct->x, 4); 415 | memcpy(data + 28, &dataStruct->y, 4); 416 | memcpy(data + 32, &dataStruct->XSpeed, 4); 417 | memcpy(data + 36, &dataStruct->YSpeed, 4); 418 | memcpy(data + 44, &dataStruct->punchX, 4); 419 | memcpy(data + 48, &dataStruct->punchY, 4); 420 | return data; 421 | } 422 | 423 | PlayerMoving *unpackPlayerMoving(BYTE *data) 424 | { 425 | PlayerMoving *dataStruct = new PlayerMoving; 426 | memcpy(&dataStruct->netID, data + 4, 4); 427 | memcpy(&dataStruct->characterState, data + 12, 4); 428 | memcpy(&dataStruct->plantingTree, data + 20, 4); 429 | memcpy(&dataStruct->x, data + 24, 4); 430 | memcpy(&dataStruct->y, data + 28, 4); 431 | memcpy(&dataStruct->XSpeed, data + 32, 4); 432 | memcpy(&dataStruct->YSpeed, data + 36, 4); 433 | memcpy(&dataStruct->punchX, data + 44, 4); 434 | memcpy(&dataStruct->punchY, data + 48, 4); 435 | return dataStruct; 436 | } 437 | 438 | WorldStruct *world = NULL; 439 | 440 | //ProcessTankUpdatePacket(0, NULL, tankUpdatePacket); 441 | void ProcessTankUpdatePacket(float someVal, BYTE *structPointer) 442 | { 443 | 444 | auto gamepacket = reinterpret_cast(structPointer); 445 | 446 | 447 | 448 | switch (gamepacket->m_type) 449 | { 450 | 451 | case 0: // AvatarPacketReceiver::LerpState 452 | { 453 | if(gamepacket->m_player_flags != owner) return; 454 | SendPacketNew(4,(uint8_t *)&gamepacket, sizeof(gameupdatepacket_t)); 455 | break; 456 | } 457 | 458 | case 1: 459 | { 460 | handlevarlist(structPointer); 461 | break; 462 | } 463 | 464 | 465 | case 3: 466 | dbgPrint("Destroyed/placed tile might be tree also!!! TODO!!!"); 467 | break; 468 | 469 | case 5: 470 | { 471 | BYTE *tileData = GetExtendedDataPointerFromTankPacket(structPointer); 472 | dbgPrint("Update of blocks visuals.."); 473 | } 474 | 475 | case 8: 476 | { 477 | HandlePacketTileChangeRequest(gamepacket); 478 | //cout << *(int*)(structPointer + 4) << endl; 479 | break; 480 | } 481 | case 9: 482 | { 483 | BYTE *playerItems = GetExtendedDataPointerFromTankPacket(structPointer); 484 | dbgPrint("Update player inventory.."); 485 | break; 486 | } 487 | 488 | case 12: 489 | { 490 | string x = std::to_string(*(int *)(structPointer + 44)); 491 | string y = std::to_string(*(int *)(structPointer + 48)); 492 | cout << "Some tile change at X:" + x + " Y: " + y << endl; 493 | break; 494 | } 495 | 496 | 497 | 498 | case 14: 499 | { 500 | dbgPrint("Object change request! TODO!!!!!!"); 501 | } 502 | 503 | case 16: 504 | { 505 | BYTE *itemsData = GetExtendedDataPointerFromTankPacket(structPointer); 506 | __int16 val1 = *(__int16 *)itemsData; 507 | int itemsCount = *(int *)(itemsData + 2); 508 | break; 509 | } 510 | 511 | case 18: 512 | { 513 | AtAvatarSetIconState(*(int *)(structPointer + 4), *(int *)(structPointer + 44)); 514 | break; 515 | } 516 | case 20: 517 | { 518 | 519 | dbgPrint("Set character state"); 520 | break; 521 | } 522 | 523 | case 22: 524 | { 525 | gameupdatepacket_t data {}; 526 | data.m_type = 21; 527 | data.m_item = 29657995 ; 528 | data.m_int_data = 29657995 ; 529 | data.m_vec_x = 64.0; 530 | data.m_vec_y = 64.0; 531 | data.m_vec2_x = 1000.0; 532 | data.m_vec2_y = 250.0; 533 | SendPacketNew(4,(uint8_t *)&data, sizeof(gameupdatepacket_t)); 534 | break; 535 | } 536 | case 4: 537 | { 538 | //BYTE *worldPtr = GetExtendedDataPointerFromTankPacket(structPointer); // World::LoadFromMem 539 | BYTE *worldPtr = structPointer + 60; // 4 + 56 540 | world = new WorldStruct; 541 | worldPtr += 6; 542 | __int16 strLen = *(__int16 *)worldPtr; 543 | worldPtr += 2; 544 | world->name = ""; 545 | for (int i = 0; i < strLen; i++) 546 | { 547 | world->name += worldPtr[0]; 548 | worldPtr++; 549 | } 550 | world->XSize = *(int *)worldPtr; 551 | worldPtr += 4; 552 | world->YSize = *(int *)worldPtr; 553 | worldPtr += 4; 554 | world->tileCount = *(int *)worldPtr; 555 | worldPtr += 4; 556 | 557 | cout << "World " + std::to_string(world->XSize) + "x" + std::to_string(world->YSize) + " with name " + world->name << endl; 558 | currentWorld = world->name; 559 | break; 560 | } 561 | 562 | default: 563 | dbgPrint("Unknown tank update packet type " + std::to_string(*(char *)structPointer)); 564 | break; 565 | } 566 | } 567 | 568 | BYTE *GetStructPointerFromTankPacket(ENetPacket *packet) 569 | { 570 | unsigned int packetLenght = packet->dataLength; 571 | BYTE *result = NULL; 572 | if (packetLenght >= 0x3C) 573 | { 574 | BYTE *packetData = packet->data; 575 | result = packetData + 4; 576 | 577 | if (*(BYTE *)(packetData + 16) & 8) 578 | { 579 | cout << "Is zero!" << *(int *)(packetData + 56) << endl; 580 | if (packetLenght < *(int *)(packetData + 56) + 60) 581 | { 582 | cout << "Packet too small for extended packet to be valid" << endl; 583 | cout << "Sizeof float is 4. TankUpdatePacket size: 56" << endl; 584 | result = 0; 585 | } 586 | } 587 | else 588 | { 589 | int zero = 0; 590 | memcpy(packetData + 56, &zero, 4); 591 | } 592 | } 593 | return result; 594 | } 595 | 596 | void ProcessPacket(ENetEvent *event, ENetPeer *peer) 597 | { 598 | int messageType = GetMessageTypeFromPacket(event->packet); 599 | //cout << "Packet type is " << messageType << endl; 600 | //cout << (event->packet->data+4) << endl; 601 | switch (messageType) 602 | { 603 | case 1: 604 | onLoginRequested(); 605 | break; 606 | default: 607 | packet_unknown(event->packet); 608 | break; 609 | case 3: 610 | packet_type3(GetTextPointerFromPacket(event->packet)); 611 | break; 612 | case 4: 613 | { 614 | BYTE *tankUpdatePacket = GetStructPointerFromTankPacket(event->packet); 615 | if (tankUpdatePacket) 616 | { 617 | //cout << std::hex << (char*)(tankUpdatePacket+4) << endl; 618 | /*v12 = (EntityComponent *)GetGameLogic(); 619 | GameLogicComponent::ProcessTankUpdatePacket(a1, v12, tankUpdatePacket);*/ 620 | //cout << "Size: " << event->packet->dataLength << endl; 621 | ProcessTankUpdatePacket(0, tankUpdatePacket); 622 | } 623 | 624 | else 625 | { 626 | cout << "Got bad tank packet"; 627 | } 628 | /*char buffer[2048]; 629 | for (int i = 0; i < event->packet->dataLength; i++) 630 | { 631 | sprintf(&buffer[2 * i], "%02X", event->packet->data[i]); 632 | } 633 | cout << buffer;*/ 634 | } 635 | break; 636 | case 5: 637 | 638 | break; 639 | case 6: 640 | packet_type6(GetTextPointerFromPacket(event->packet)); 641 | break; 642 | } 643 | } 644 | 645 | void eventLoop() 646 | { 647 | ENetEvent event; 648 | while (enet_host_service(client, &event, 0) > 0) 649 | { 650 | switch (event.type) 651 | { 652 | case ENET_EVENT_TYPE_NONE: 653 | cout << "No event???" << endl; 654 | break; 655 | case ENET_EVENT_TYPE_CONNECT: 656 | WhenConnected(); 657 | break; 658 | case ENET_EVENT_TYPE_DISCONNECT: 659 | WhenDisconnected(); 660 | break; 661 | case ENET_EVENT_TYPE_RECEIVE: 662 | ProcessPacket(&event, peer); 663 | enet_packet_destroy(event.packet); 664 | break; 665 | default: 666 | cout << "WTF???" << endl; 667 | break; 668 | } 669 | } 670 | userLoop(); 671 | } 672 | }; 673 | 674 | void init() 675 | { 676 | if (enet_initialize() != 0) 677 | { 678 | fprintf(stderr, "An error occurred while initializing ENet.\n"); 679 | exit(0); 680 | } 681 | atexit(enet_deinitialize); 682 | srand(time(NULL)); 683 | } 684 | -------------------------------------------------------------------------------- /CPPBot/enet/callbacks.c: -------------------------------------------------------------------------------- 1 | /** 2 | @file callbacks.c 3 | @brief ENet callback functions 4 | */ 5 | #define ENET_BUILDING_LIB 1 6 | #include "include/enet.h" 7 | 8 | static ENetCallbacks callbacks = { malloc, free, abort }; 9 | 10 | int 11 | enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits) 12 | { 13 | if (version < ENET_VERSION_CREATE (1, 3, 0)) 14 | return -1; 15 | 16 | if (inits -> malloc != NULL || inits -> free != NULL) 17 | { 18 | if (inits -> malloc == NULL || inits -> free == NULL) 19 | return -1; 20 | 21 | callbacks.malloc = inits -> malloc; 22 | callbacks.free = inits -> free; 23 | } 24 | 25 | if (inits -> no_memory != NULL) 26 | callbacks.no_memory = inits -> no_memory; 27 | 28 | return enet_initialize (); 29 | } 30 | 31 | ENetVersion 32 | enet_linked_version (void) 33 | { 34 | return ENET_VERSION; 35 | } 36 | 37 | void * 38 | enet_malloc (size_t size) 39 | { 40 | void * memory = callbacks.malloc (size); 41 | 42 | if (memory == NULL) 43 | callbacks.no_memory (); 44 | 45 | return memory; 46 | } 47 | 48 | void 49 | enet_free (void * memory) 50 | { 51 | callbacks.free (memory); 52 | } 53 | 54 | -------------------------------------------------------------------------------- /CPPBot/enet/compress.c: -------------------------------------------------------------------------------- 1 | /** 2 | @file compress.c 3 | @brief An adaptive order-2 PPM range coder 4 | */ 5 | #define ENET_BUILDING_LIB 1 6 | #include 7 | #include "include/enet.h" 8 | 9 | typedef struct _ENetSymbol 10 | { 11 | /* binary indexed tree of symbols */ 12 | enet_uint8 value; 13 | enet_uint8 count; 14 | enet_uint16 under; 15 | enet_uint16 left, right; 16 | 17 | /* context defined by this symbol */ 18 | enet_uint16 symbols; 19 | enet_uint16 escapes; 20 | enet_uint16 total; 21 | enet_uint16 parent; 22 | } ENetSymbol; 23 | 24 | /* adaptation constants tuned aggressively for small packet sizes rather than large file compression */ 25 | enum 26 | { 27 | ENET_RANGE_CODER_TOP = 1<<24, 28 | ENET_RANGE_CODER_BOTTOM = 1<<16, 29 | 30 | ENET_CONTEXT_SYMBOL_DELTA = 3, 31 | ENET_CONTEXT_SYMBOL_MINIMUM = 1, 32 | ENET_CONTEXT_ESCAPE_MINIMUM = 1, 33 | 34 | ENET_SUBCONTEXT_ORDER = 2, 35 | ENET_SUBCONTEXT_SYMBOL_DELTA = 2, 36 | ENET_SUBCONTEXT_ESCAPE_DELTA = 5 37 | }; 38 | 39 | /* context exclusion roughly halves compression speed, so disable for now */ 40 | #undef ENET_CONTEXT_EXCLUSION 41 | 42 | typedef struct _ENetRangeCoder 43 | { 44 | /* only allocate enough symbols for reasonable MTUs, would need to be larger for large file compression */ 45 | ENetSymbol symbols[4096]; 46 | } ENetRangeCoder; 47 | 48 | void * 49 | enet_range_coder_create (void) 50 | { 51 | ENetRangeCoder * rangeCoder = (ENetRangeCoder *) enet_malloc (sizeof (ENetRangeCoder)); 52 | if (rangeCoder == NULL) 53 | return NULL; 54 | 55 | return rangeCoder; 56 | } 57 | 58 | void 59 | enet_range_coder_destroy (void * context) 60 | { 61 | ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context; 62 | if (rangeCoder == NULL) 63 | return; 64 | 65 | enet_free (rangeCoder); 66 | } 67 | 68 | #define ENET_SYMBOL_CREATE(symbol, value_, count_) \ 69 | { \ 70 | symbol = & rangeCoder -> symbols [nextSymbol ++]; \ 71 | symbol -> value = value_; \ 72 | symbol -> count = count_; \ 73 | symbol -> under = count_; \ 74 | symbol -> left = 0; \ 75 | symbol -> right = 0; \ 76 | symbol -> symbols = 0; \ 77 | symbol -> escapes = 0; \ 78 | symbol -> total = 0; \ 79 | symbol -> parent = 0; \ 80 | } 81 | 82 | #define ENET_CONTEXT_CREATE(context, escapes_, minimum) \ 83 | { \ 84 | ENET_SYMBOL_CREATE (context, 0, 0); \ 85 | (context) -> escapes = escapes_; \ 86 | (context) -> total = escapes_ + 256*minimum; \ 87 | (context) -> symbols = 0; \ 88 | } 89 | 90 | static enet_uint16 91 | enet_symbol_rescale (ENetSymbol * symbol) 92 | { 93 | enet_uint16 total = 0; 94 | for (;;) 95 | { 96 | symbol -> count -= symbol->count >> 1; 97 | symbol -> under = symbol -> count; 98 | if (symbol -> left) 99 | symbol -> under += enet_symbol_rescale (symbol + symbol -> left); 100 | total += symbol -> under; 101 | if (! symbol -> right) break; 102 | symbol += symbol -> right; 103 | } 104 | return total; 105 | } 106 | 107 | #define ENET_CONTEXT_RESCALE(context, minimum) \ 108 | { \ 109 | (context) -> total = (context) -> symbols ? enet_symbol_rescale ((context) + (context) -> symbols) : 0; \ 110 | (context) -> escapes -= (context) -> escapes >> 1; \ 111 | (context) -> total += (context) -> escapes + 256*minimum; \ 112 | } 113 | 114 | #define ENET_RANGE_CODER_OUTPUT(value) \ 115 | { \ 116 | if (outData >= outEnd) \ 117 | return 0; \ 118 | * outData ++ = value; \ 119 | } 120 | 121 | #define ENET_RANGE_CODER_ENCODE(under, count, total) \ 122 | { \ 123 | encodeRange /= (total); \ 124 | encodeLow += (under) * encodeRange; \ 125 | encodeRange *= (count); \ 126 | for (;;) \ 127 | { \ 128 | if((encodeLow ^ (encodeLow + encodeRange)) >= ENET_RANGE_CODER_TOP) \ 129 | { \ 130 | if(encodeRange >= ENET_RANGE_CODER_BOTTOM) break; \ 131 | encodeRange = -encodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \ 132 | } \ 133 | ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \ 134 | encodeRange <<= 8; \ 135 | encodeLow <<= 8; \ 136 | } \ 137 | } 138 | 139 | #define ENET_RANGE_CODER_FLUSH \ 140 | { \ 141 | while (encodeLow) \ 142 | { \ 143 | ENET_RANGE_CODER_OUTPUT (encodeLow >> 24); \ 144 | encodeLow <<= 8; \ 145 | } \ 146 | } 147 | 148 | #define ENET_RANGE_CODER_FREE_SYMBOLS \ 149 | { \ 150 | if (nextSymbol >= sizeof (rangeCoder -> symbols) / sizeof (ENetSymbol) - ENET_SUBCONTEXT_ORDER ) \ 151 | { \ 152 | nextSymbol = 0; \ 153 | ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); \ 154 | predicted = 0; \ 155 | order = 0; \ 156 | } \ 157 | } 158 | 159 | #define ENET_CONTEXT_ENCODE(context, symbol_, value_, under_, count_, update, minimum) \ 160 | { \ 161 | under_ = value*minimum; \ 162 | count_ = minimum; \ 163 | if (! (context) -> symbols) \ 164 | { \ 165 | ENET_SYMBOL_CREATE (symbol_, value_, update); \ 166 | (context) -> symbols = symbol_ - (context); \ 167 | } \ 168 | else \ 169 | { \ 170 | ENetSymbol * node = (context) + (context) -> symbols; \ 171 | for (;;) \ 172 | { \ 173 | if (value_ < node -> value) \ 174 | { \ 175 | node -> under += update; \ 176 | if (node -> left) { node += node -> left; continue; } \ 177 | ENET_SYMBOL_CREATE (symbol_, value_, update); \ 178 | node -> left = symbol_ - node; \ 179 | } \ 180 | else \ 181 | if (value_ > node -> value) \ 182 | { \ 183 | under_ += node -> under; \ 184 | if (node -> right) { node += node -> right; continue; } \ 185 | ENET_SYMBOL_CREATE (symbol_, value_, update); \ 186 | node -> right = symbol_ - node; \ 187 | } \ 188 | else \ 189 | { \ 190 | count_ += node -> count; \ 191 | under_ += node -> under - node -> count; \ 192 | node -> under += update; \ 193 | node -> count += update; \ 194 | symbol_ = node; \ 195 | } \ 196 | break; \ 197 | } \ 198 | } \ 199 | } 200 | 201 | #ifdef ENET_CONTEXT_EXCLUSION 202 | static const ENetSymbol emptyContext = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 203 | 204 | #define ENET_CONTEXT_WALK(context, body) \ 205 | { \ 206 | const ENetSymbol * node = (context) + (context) -> symbols; \ 207 | const ENetSymbol * stack [256]; \ 208 | size_t stackSize = 0; \ 209 | while (node -> left) \ 210 | { \ 211 | stack [stackSize ++] = node; \ 212 | node += node -> left; \ 213 | } \ 214 | for (;;) \ 215 | { \ 216 | body; \ 217 | if (node -> right) \ 218 | { \ 219 | node += node -> right; \ 220 | while (node -> left) \ 221 | { \ 222 | stack [stackSize ++] = node; \ 223 | node += node -> left; \ 224 | } \ 225 | } \ 226 | else \ 227 | if (stackSize <= 0) \ 228 | break; \ 229 | else \ 230 | node = stack [-- stackSize]; \ 231 | } \ 232 | } 233 | 234 | #define ENET_CONTEXT_ENCODE_EXCLUDE(context, value_, under, total, minimum) \ 235 | ENET_CONTEXT_WALK(context, { \ 236 | if (node -> value != value_) \ 237 | { \ 238 | enet_uint16 parentCount = rangeCoder -> symbols [node -> parent].count + minimum; \ 239 | if (node -> value < value_) \ 240 | under -= parentCount; \ 241 | total -= parentCount; \ 242 | } \ 243 | }) 244 | #endif 245 | 246 | size_t 247 | enet_range_coder_compress (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit) 248 | { 249 | ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context; 250 | enet_uint8 * outStart = outData, * outEnd = & outData [outLimit]; 251 | const enet_uint8 * inData, * inEnd; 252 | enet_uint32 encodeLow = 0, encodeRange = ~0; 253 | ENetSymbol * root; 254 | enet_uint16 predicted = 0; 255 | size_t order = 0, nextSymbol = 0; 256 | 257 | if (rangeCoder == NULL || inBufferCount <= 0 || inLimit <= 0) 258 | return 0; 259 | 260 | inData = (const enet_uint8 *) inBuffers -> data; 261 | inEnd = & inData [inBuffers -> dataLength]; 262 | inBuffers ++; 263 | inBufferCount --; 264 | 265 | ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); 266 | 267 | for (;;) 268 | { 269 | ENetSymbol * subcontext, * symbol; 270 | #ifdef ENET_CONTEXT_EXCLUSION 271 | const ENetSymbol * childContext = & emptyContext; 272 | #endif 273 | enet_uint8 value; 274 | enet_uint16 count, under, * parent = & predicted, total; 275 | if (inData >= inEnd) 276 | { 277 | if (inBufferCount <= 0) 278 | break; 279 | inData = (const enet_uint8 *) inBuffers -> data; 280 | inEnd = & inData [inBuffers -> dataLength]; 281 | inBuffers ++; 282 | inBufferCount --; 283 | } 284 | value = * inData ++; 285 | 286 | for (subcontext = & rangeCoder -> symbols [predicted]; 287 | subcontext != root; 288 | #ifdef ENET_CONTEXT_EXCLUSION 289 | childContext = subcontext, 290 | #endif 291 | subcontext = & rangeCoder -> symbols [subcontext -> parent]) 292 | { 293 | ENET_CONTEXT_ENCODE (subcontext, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0); 294 | * parent = symbol - rangeCoder -> symbols; 295 | parent = & symbol -> parent; 296 | total = subcontext -> total; 297 | #ifdef ENET_CONTEXT_EXCLUSION 298 | if (childContext -> total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA) 299 | ENET_CONTEXT_ENCODE_EXCLUDE (childContext, value, under, total, 0); 300 | #endif 301 | if (count > 0) 302 | { 303 | ENET_RANGE_CODER_ENCODE (subcontext -> escapes + under, count, total); 304 | } 305 | else 306 | { 307 | if (subcontext -> escapes > 0 && subcontext -> escapes < total) 308 | ENET_RANGE_CODER_ENCODE (0, subcontext -> escapes, total); 309 | subcontext -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA; 310 | subcontext -> total += ENET_SUBCONTEXT_ESCAPE_DELTA; 311 | } 312 | subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA; 313 | if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100) 314 | ENET_CONTEXT_RESCALE (subcontext, 0); 315 | if (count > 0) goto nextInput; 316 | } 317 | 318 | ENET_CONTEXT_ENCODE (root, symbol, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM); 319 | * parent = symbol - rangeCoder -> symbols; 320 | parent = & symbol -> parent; 321 | total = root -> total; 322 | #ifdef ENET_CONTEXT_EXCLUSION 323 | if (childContext -> total > ENET_SUBCONTEXT_SYMBOL_DELTA + ENET_SUBCONTEXT_ESCAPE_DELTA) 324 | ENET_CONTEXT_ENCODE_EXCLUDE (childContext, value, under, total, ENET_CONTEXT_SYMBOL_MINIMUM); 325 | #endif 326 | ENET_RANGE_CODER_ENCODE (root -> escapes + under, count, total); 327 | root -> total += ENET_CONTEXT_SYMBOL_DELTA; 328 | if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100) 329 | ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM); 330 | 331 | nextInput: 332 | if (order >= ENET_SUBCONTEXT_ORDER) 333 | predicted = rangeCoder -> symbols [predicted].parent; 334 | else 335 | order ++; 336 | ENET_RANGE_CODER_FREE_SYMBOLS; 337 | } 338 | 339 | ENET_RANGE_CODER_FLUSH; 340 | 341 | return (size_t) (outData - outStart); 342 | } 343 | 344 | #define ENET_RANGE_CODER_SEED \ 345 | { \ 346 | if (inData < inEnd) decodeCode |= * inData ++ << 24; \ 347 | if (inData < inEnd) decodeCode |= * inData ++ << 16; \ 348 | if (inData < inEnd) decodeCode |= * inData ++ << 8; \ 349 | if (inData < inEnd) decodeCode |= * inData ++; \ 350 | } 351 | 352 | #define ENET_RANGE_CODER_READ(total) ((decodeCode - decodeLow) / (decodeRange /= (total))) 353 | 354 | #define ENET_RANGE_CODER_DECODE(under, count, total) \ 355 | { \ 356 | decodeLow += (under) * decodeRange; \ 357 | decodeRange *= (count); \ 358 | for (;;) \ 359 | { \ 360 | if((decodeLow ^ (decodeLow + decodeRange)) >= ENET_RANGE_CODER_TOP) \ 361 | { \ 362 | if(decodeRange >= ENET_RANGE_CODER_BOTTOM) break; \ 363 | decodeRange = -decodeLow & (ENET_RANGE_CODER_BOTTOM - 1); \ 364 | } \ 365 | decodeCode <<= 8; \ 366 | if (inData < inEnd) \ 367 | decodeCode |= * inData ++; \ 368 | decodeRange <<= 8; \ 369 | decodeLow <<= 8; \ 370 | } \ 371 | } 372 | 373 | #define ENET_CONTEXT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, createRoot, visitNode, createRight, createLeft) \ 374 | { \ 375 | under_ = 0; \ 376 | count_ = minimum; \ 377 | if (! (context) -> symbols) \ 378 | { \ 379 | createRoot; \ 380 | } \ 381 | else \ 382 | { \ 383 | ENetSymbol * node = (context) + (context) -> symbols; \ 384 | for (;;) \ 385 | { \ 386 | enet_uint16 after = under_ + node -> under + (node -> value + 1)*minimum, before = node -> count + minimum; \ 387 | visitNode; \ 388 | if (code >= after) \ 389 | { \ 390 | under_ += node -> under; \ 391 | if (node -> right) { node += node -> right; continue; } \ 392 | createRight; \ 393 | } \ 394 | else \ 395 | if (code < after - before) \ 396 | { \ 397 | node -> under += update; \ 398 | if (node -> left) { node += node -> left; continue; } \ 399 | createLeft; \ 400 | } \ 401 | else \ 402 | { \ 403 | value_ = node -> value; \ 404 | count_ += node -> count; \ 405 | under_ = after - before; \ 406 | node -> under += update; \ 407 | node -> count += update; \ 408 | symbol_ = node; \ 409 | } \ 410 | break; \ 411 | } \ 412 | } \ 413 | } 414 | 415 | #define ENET_CONTEXT_TRY_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \ 416 | ENET_CONTEXT_DECODE (context, symbol_, code, value_, under_, count_, update, minimum, return 0, exclude (node -> value, after, before), return 0, return 0) 417 | 418 | #define ENET_CONTEXT_ROOT_DECODE(context, symbol_, code, value_, under_, count_, update, minimum, exclude) \ 419 | ENET_CONTEXT_DECODE (context, symbol_, code, value_, under_, count_, update, minimum, \ 420 | { \ 421 | value_ = code / minimum; \ 422 | under_ = code - code%minimum; \ 423 | ENET_SYMBOL_CREATE (symbol_, value_, update); \ 424 | (context) -> symbols = symbol_ - (context); \ 425 | }, \ 426 | exclude (node -> value, after, before), \ 427 | { \ 428 | value_ = node->value + 1 + (code - after)/minimum; \ 429 | under_ = code - (code - after)%minimum; \ 430 | ENET_SYMBOL_CREATE (symbol_, value_, update); \ 431 | node -> right = symbol_ - node; \ 432 | }, \ 433 | { \ 434 | value_ = node->value - 1 - (after - before - code - 1)/minimum; \ 435 | under_ = code - (after - before - code - 1)%minimum; \ 436 | ENET_SYMBOL_CREATE (symbol_, value_, update); \ 437 | node -> left = symbol_ - node; \ 438 | }) \ 439 | 440 | #ifdef ENET_CONTEXT_EXCLUSION 441 | typedef struct _ENetExclude 442 | { 443 | enet_uint8 value; 444 | enet_uint16 under; 445 | } ENetExclude; 446 | 447 | #define ENET_CONTEXT_DECODE_EXCLUDE(context, total, minimum) \ 448 | { \ 449 | enet_uint16 under = 0; \ 450 | nextExclude = excludes; \ 451 | ENET_CONTEXT_WALK (context, { \ 452 | under += rangeCoder -> symbols [node -> parent].count + minimum; \ 453 | nextExclude -> value = node -> value; \ 454 | nextExclude -> under = under; \ 455 | nextExclude ++; \ 456 | }); \ 457 | total -= under; \ 458 | } 459 | 460 | #define ENET_CONTEXT_EXCLUDED(value_, after, before) \ 461 | { \ 462 | size_t low = 0, high = nextExclude - excludes; \ 463 | for(;;) \ 464 | { \ 465 | size_t mid = (low + high) >> 1; \ 466 | const ENetExclude * exclude = & excludes [mid]; \ 467 | if (value_ < exclude -> value) \ 468 | { \ 469 | if (low + 1 < high) \ 470 | { \ 471 | high = mid; \ 472 | continue; \ 473 | } \ 474 | if (exclude > excludes) \ 475 | after -= exclude [-1].under; \ 476 | } \ 477 | else \ 478 | { \ 479 | if (value_ > exclude -> value) \ 480 | { \ 481 | if (low + 1 < high) \ 482 | { \ 483 | low = mid; \ 484 | continue; \ 485 | } \ 486 | } \ 487 | else \ 488 | before = 0; \ 489 | after -= exclude -> under; \ 490 | } \ 491 | break; \ 492 | } \ 493 | } 494 | #endif 495 | 496 | #define ENET_CONTEXT_NOT_EXCLUDED(value_, after, before) 497 | 498 | size_t 499 | enet_range_coder_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit) 500 | { 501 | ENetRangeCoder * rangeCoder = (ENetRangeCoder *) context; 502 | enet_uint8 * outStart = outData, * outEnd = & outData [outLimit]; 503 | const enet_uint8 * inEnd = & inData [inLimit]; 504 | enet_uint32 decodeLow = 0, decodeCode = 0, decodeRange = ~0; 505 | ENetSymbol * root; 506 | enet_uint16 predicted = 0; 507 | size_t order = 0, nextSymbol = 0; 508 | #ifdef ENET_CONTEXT_EXCLUSION 509 | ENetExclude excludes [256]; 510 | ENetExclude * nextExclude = excludes; 511 | #endif 512 | 513 | if (rangeCoder == NULL || inLimit <= 0) 514 | return 0; 515 | 516 | ENET_CONTEXT_CREATE (root, ENET_CONTEXT_ESCAPE_MINIMUM, ENET_CONTEXT_SYMBOL_MINIMUM); 517 | 518 | ENET_RANGE_CODER_SEED; 519 | 520 | for (;;) 521 | { 522 | ENetSymbol * subcontext, * symbol, * patch; 523 | #ifdef ENET_CONTEXT_EXCLUSION 524 | const ENetSymbol * childContext = & emptyContext; 525 | #endif 526 | enet_uint8 value = 0; 527 | enet_uint16 code, under, count, bottom, * parent = & predicted, total; 528 | 529 | for (subcontext = & rangeCoder -> symbols [predicted]; 530 | subcontext != root; 531 | #ifdef ENET_CONTEXT_EXCLUSION 532 | childContext = subcontext, 533 | #endif 534 | subcontext = & rangeCoder -> symbols [subcontext -> parent]) 535 | { 536 | if (subcontext -> escapes <= 0) 537 | continue; 538 | total = subcontext -> total; 539 | #ifdef ENET_CONTEXT_EXCLUSION 540 | if (childContext -> total > 0) 541 | ENET_CONTEXT_DECODE_EXCLUDE (childContext, total, 0); 542 | #endif 543 | if (subcontext -> escapes >= total) 544 | continue; 545 | code = ENET_RANGE_CODER_READ (total); 546 | if (code < subcontext -> escapes) 547 | { 548 | ENET_RANGE_CODER_DECODE (0, subcontext -> escapes, total); 549 | continue; 550 | } 551 | code -= subcontext -> escapes; 552 | #ifdef ENET_CONTEXT_EXCLUSION 553 | if (childContext -> total > 0) 554 | { 555 | ENET_CONTEXT_TRY_DECODE (subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0, ENET_CONTEXT_EXCLUDED); 556 | } 557 | else 558 | #endif 559 | { 560 | ENET_CONTEXT_TRY_DECODE (subcontext, symbol, code, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0, ENET_CONTEXT_NOT_EXCLUDED); 561 | } 562 | bottom = symbol - rangeCoder -> symbols; 563 | ENET_RANGE_CODER_DECODE (subcontext -> escapes + under, count, total); 564 | subcontext -> total += ENET_SUBCONTEXT_SYMBOL_DELTA; 565 | if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || subcontext -> total > ENET_RANGE_CODER_BOTTOM - 0x100) 566 | ENET_CONTEXT_RESCALE (subcontext, 0); 567 | goto patchContexts; 568 | } 569 | 570 | total = root -> total; 571 | #ifdef ENET_CONTEXT_EXCLUSION 572 | if (childContext -> total > 0) 573 | ENET_CONTEXT_DECODE_EXCLUDE (childContext, total, ENET_CONTEXT_SYMBOL_MINIMUM); 574 | #endif 575 | code = ENET_RANGE_CODER_READ (total); 576 | if (code < root -> escapes) 577 | { 578 | ENET_RANGE_CODER_DECODE (0, root -> escapes, total); 579 | break; 580 | } 581 | code -= root -> escapes; 582 | #ifdef ENET_CONTEXT_EXCLUSION 583 | if (childContext -> total > 0) 584 | { 585 | ENET_CONTEXT_ROOT_DECODE (root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_EXCLUDED); 586 | } 587 | else 588 | #endif 589 | { 590 | ENET_CONTEXT_ROOT_DECODE (root, symbol, code, value, under, count, ENET_CONTEXT_SYMBOL_DELTA, ENET_CONTEXT_SYMBOL_MINIMUM, ENET_CONTEXT_NOT_EXCLUDED); 591 | } 592 | bottom = symbol - rangeCoder -> symbols; 593 | ENET_RANGE_CODER_DECODE (root -> escapes + under, count, total); 594 | root -> total += ENET_CONTEXT_SYMBOL_DELTA; 595 | if (count > 0xFF - 2*ENET_CONTEXT_SYMBOL_DELTA + ENET_CONTEXT_SYMBOL_MINIMUM || root -> total > ENET_RANGE_CODER_BOTTOM - 0x100) 596 | ENET_CONTEXT_RESCALE (root, ENET_CONTEXT_SYMBOL_MINIMUM); 597 | 598 | patchContexts: 599 | for (patch = & rangeCoder -> symbols [predicted]; 600 | patch != subcontext; 601 | patch = & rangeCoder -> symbols [patch -> parent]) 602 | { 603 | ENET_CONTEXT_ENCODE (patch, symbol, value, under, count, ENET_SUBCONTEXT_SYMBOL_DELTA, 0); 604 | * parent = symbol - rangeCoder -> symbols; 605 | parent = & symbol -> parent; 606 | if (count <= 0) 607 | { 608 | patch -> escapes += ENET_SUBCONTEXT_ESCAPE_DELTA; 609 | patch -> total += ENET_SUBCONTEXT_ESCAPE_DELTA; 610 | } 611 | patch -> total += ENET_SUBCONTEXT_SYMBOL_DELTA; 612 | if (count > 0xFF - 2*ENET_SUBCONTEXT_SYMBOL_DELTA || patch -> total > ENET_RANGE_CODER_BOTTOM - 0x100) 613 | ENET_CONTEXT_RESCALE (patch, 0); 614 | } 615 | * parent = bottom; 616 | 617 | ENET_RANGE_CODER_OUTPUT (value); 618 | 619 | if (order >= ENET_SUBCONTEXT_ORDER) 620 | predicted = rangeCoder -> symbols [predicted].parent; 621 | else 622 | order ++; 623 | ENET_RANGE_CODER_FREE_SYMBOLS; 624 | } 625 | 626 | return (size_t) (outData - outStart); 627 | } 628 | 629 | /** @defgroup host ENet host functions 630 | @{ 631 | */ 632 | 633 | /** Sets the packet compressor the host should use to the default range coder. 634 | @param host host to enable the range coder for 635 | @returns 0 on success, < 0 on failure 636 | */ 637 | int 638 | enet_host_compress_with_range_coder (ENetHost * host) 639 | { 640 | ENetCompressor compressor; 641 | memset (& compressor, 0, sizeof (compressor)); 642 | compressor.context = enet_range_coder_create(); 643 | if (compressor.context == NULL) 644 | return -1; 645 | compressor.compress = enet_range_coder_compress; 646 | compressor.decompress = enet_range_coder_decompress; 647 | compressor.destroy = enet_range_coder_destroy; 648 | enet_host_compress (host, & compressor); 649 | return 0; 650 | } 651 | 652 | /** @} */ 653 | 654 | 655 | -------------------------------------------------------------------------------- /CPPBot/enet/host.c: -------------------------------------------------------------------------------- 1 | /** 2 | @file host.c 3 | @brief ENet host management functions 4 | */ 5 | #define ENET_BUILDING_LIB 1 6 | #include 7 | #include "include/enet.h" 8 | 9 | /** @defgroup host ENet host functions 10 | @{ 11 | */ 12 | 13 | /** Creates a host for communicating to peers. 14 | 15 | @param address the address at which other peers may connect to this host. If NULL, then no peers may connect to the host. 16 | @param peerCount the maximum number of peers that should be allocated for the host. 17 | @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT 18 | @param incomingBandwidth downstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth. 19 | @param outgoingBandwidth upstream bandwidth of the host in bytes/second; if 0, ENet will assume unlimited bandwidth. 20 | 21 | @returns the host on success and NULL on failure 22 | 23 | @remarks ENet will strategically drop packets on specific sides of a connection between hosts 24 | to ensure the host's bandwidth is not overwhelmed. The bandwidth parameters also determine 25 | the window size of a connection which limits the amount of reliable packets that may be in transit 26 | at any given time. 27 | */ 28 | ENetHost * 29 | enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth) 30 | { 31 | ENetHost * host; 32 | ENetPeer * currentPeer; 33 | 34 | if (peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID) 35 | return NULL; 36 | 37 | host = (ENetHost *) enet_malloc (sizeof (ENetHost)); 38 | if (host == NULL) 39 | return NULL; 40 | memset (host, 0, sizeof (ENetHost)); 41 | 42 | host -> peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer)); 43 | if (host -> peers == NULL) 44 | { 45 | enet_free (host); 46 | 47 | return NULL; 48 | } 49 | memset (host -> peers, 0, peerCount * sizeof (ENetPeer)); 50 | 51 | host -> socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM); 52 | if (host -> socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind (host -> socket, address) < 0)) 53 | { 54 | if (host -> socket != ENET_SOCKET_NULL) 55 | enet_socket_destroy (host -> socket); 56 | 57 | enet_free (host -> peers); 58 | enet_free (host); 59 | 60 | return NULL; 61 | } 62 | 63 | enet_socket_set_option (host -> socket, ENET_SOCKOPT_NONBLOCK, 1); 64 | enet_socket_set_option (host -> socket, ENET_SOCKOPT_BROADCAST, 1); 65 | enet_socket_set_option (host -> socket, ENET_SOCKOPT_RCVBUF, ENET_HOST_RECEIVE_BUFFER_SIZE); 66 | enet_socket_set_option (host -> socket, ENET_SOCKOPT_SNDBUF, ENET_HOST_SEND_BUFFER_SIZE); 67 | 68 | if (address != NULL && enet_socket_get_address (host -> socket, & host -> address) < 0) 69 | host -> address = * address; 70 | 71 | if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) 72 | channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT; 73 | else 74 | if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) 75 | channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT; 76 | 77 | host -> randomSeed = (enet_uint32) (size_t) host; 78 | host -> randomSeed += enet_host_random_seed (); 79 | host -> randomSeed = (host -> randomSeed << 16) | (host -> randomSeed >> 16); 80 | host -> channelLimit = channelLimit; 81 | host -> incomingBandwidth = incomingBandwidth; 82 | host -> outgoingBandwidth = outgoingBandwidth; 83 | host -> bandwidthThrottleEpoch = 0; 84 | host -> recalculateBandwidthLimits = 0; 85 | host -> mtu = ENET_HOST_DEFAULT_MTU; 86 | host -> peerCount = peerCount; 87 | host -> commandCount = 0; 88 | host -> bufferCount = 0; 89 | host -> checksum = NULL; 90 | host -> receivedAddress.host = ENET_HOST_ANY; 91 | host -> receivedAddress.port = 0; 92 | host -> receivedData = NULL; 93 | host -> receivedDataLength = 0; 94 | 95 | host -> totalSentData = 0; 96 | host -> totalSentPackets = 0; 97 | host -> totalReceivedData = 0; 98 | host -> totalReceivedPackets = 0; 99 | 100 | host -> connectedPeers = 0; 101 | host -> bandwidthLimitedPeers = 0; 102 | host -> duplicatePeers = ENET_PROTOCOL_MAXIMUM_PEER_ID; 103 | host -> maximumPacketSize = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE; 104 | host -> maximumWaitingData = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA; 105 | 106 | host -> compressor.context = NULL; 107 | host -> compressor.compress = NULL; 108 | host -> compressor.decompress = NULL; 109 | host -> compressor.destroy = NULL; 110 | 111 | host -> intercept = NULL; 112 | 113 | enet_list_clear (& host -> dispatchQueue); 114 | 115 | for (currentPeer = host -> peers; 116 | currentPeer < & host -> peers [host -> peerCount]; 117 | ++ currentPeer) 118 | { 119 | currentPeer -> host = host; 120 | currentPeer -> incomingPeerID = currentPeer - host -> peers; 121 | currentPeer -> outgoingSessionID = currentPeer -> incomingSessionID = 0xFF; 122 | currentPeer -> data = NULL; 123 | 124 | enet_list_clear (& currentPeer -> acknowledgements); 125 | enet_list_clear (& currentPeer -> sentReliableCommands); 126 | enet_list_clear (& currentPeer -> sentUnreliableCommands); 127 | enet_list_clear (& currentPeer -> outgoingReliableCommands); 128 | enet_list_clear (& currentPeer -> outgoingUnreliableCommands); 129 | enet_list_clear (& currentPeer -> dispatchedCommands); 130 | 131 | enet_peer_reset (currentPeer); 132 | } 133 | 134 | return host; 135 | } 136 | 137 | /** Destroys the host and all resources associated with it. 138 | @param host pointer to the host to destroy 139 | */ 140 | void 141 | enet_host_destroy (ENetHost * host) 142 | { 143 | ENetPeer * currentPeer; 144 | 145 | if (host == NULL) 146 | return; 147 | 148 | enet_socket_destroy (host -> socket); 149 | 150 | for (currentPeer = host -> peers; 151 | currentPeer < & host -> peers [host -> peerCount]; 152 | ++ currentPeer) 153 | { 154 | enet_peer_reset (currentPeer); 155 | } 156 | 157 | if (host -> compressor.context != NULL && host -> compressor.destroy) 158 | (* host -> compressor.destroy) (host -> compressor.context); 159 | 160 | enet_free (host -> peers); 161 | enet_free (host); 162 | } 163 | 164 | /** Initiates a connection to a foreign host. 165 | @param host host seeking the connection 166 | @param address destination for the connection 167 | @param channelCount number of channels to allocate 168 | @param data user data supplied to the receiving host 169 | @returns a peer representing the foreign host on success, NULL on failure 170 | @remarks The peer returned will have not completed the connection until enet_host_service() 171 | notifies of an ENET_EVENT_TYPE_CONNECT event for the peer. 172 | */ 173 | ENetPeer * 174 | enet_host_connect (ENetHost * host, const ENetAddress * address, size_t channelCount, enet_uint32 data) 175 | { 176 | ENetPeer * currentPeer; 177 | ENetChannel * channel; 178 | ENetProtocol command; 179 | 180 | if (channelCount < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) 181 | channelCount = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT; 182 | else 183 | if (channelCount > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) 184 | channelCount = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT; 185 | 186 | for (currentPeer = host -> peers; 187 | currentPeer < & host -> peers [host -> peerCount]; 188 | ++ currentPeer) 189 | { 190 | if (currentPeer -> state == ENET_PEER_STATE_DISCONNECTED) 191 | break; 192 | } 193 | 194 | if (currentPeer >= & host -> peers [host -> peerCount]) 195 | return NULL; 196 | 197 | currentPeer -> channels = (ENetChannel *) enet_malloc (channelCount * sizeof (ENetChannel)); 198 | if (currentPeer -> channels == NULL) 199 | return NULL; 200 | currentPeer -> channelCount = channelCount; 201 | currentPeer -> state = ENET_PEER_STATE_CONNECTING; 202 | currentPeer -> address = * address; 203 | currentPeer -> connectID = ++ host -> randomSeed; 204 | 205 | if (host -> outgoingBandwidth == 0) 206 | currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; 207 | else 208 | currentPeer -> windowSize = (host -> outgoingBandwidth / 209 | ENET_PEER_WINDOW_SIZE_SCALE) * 210 | ENET_PROTOCOL_MINIMUM_WINDOW_SIZE; 211 | 212 | if (currentPeer -> windowSize < ENET_PROTOCOL_MINIMUM_WINDOW_SIZE) 213 | currentPeer -> windowSize = ENET_PROTOCOL_MINIMUM_WINDOW_SIZE; 214 | else 215 | if (currentPeer -> windowSize > ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE) 216 | currentPeer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; 217 | 218 | for (channel = currentPeer -> channels; 219 | channel < & currentPeer -> channels [channelCount]; 220 | ++ channel) 221 | { 222 | channel -> outgoingReliableSequenceNumber = 0; 223 | channel -> outgoingUnreliableSequenceNumber = 0; 224 | channel -> incomingReliableSequenceNumber = 0; 225 | channel -> incomingUnreliableSequenceNumber = 0; 226 | 227 | enet_list_clear (& channel -> incomingReliableCommands); 228 | enet_list_clear (& channel -> incomingUnreliableCommands); 229 | 230 | channel -> usedReliableWindows = 0; 231 | memset (channel -> reliableWindows, 0, sizeof (channel -> reliableWindows)); 232 | } 233 | 234 | command.header.command = ENET_PROTOCOL_COMMAND_CONNECT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; 235 | command.header.channelID = 0xFF; 236 | command.connect.outgoingPeerID = ENET_HOST_TO_NET_16 (currentPeer -> incomingPeerID); 237 | command.connect.incomingSessionID = currentPeer -> incomingSessionID; 238 | command.connect.outgoingSessionID = currentPeer -> outgoingSessionID; 239 | command.connect.mtu = ENET_HOST_TO_NET_32 (currentPeer -> mtu); 240 | command.connect.windowSize = ENET_HOST_TO_NET_32 (currentPeer -> windowSize); 241 | command.connect.channelCount = ENET_HOST_TO_NET_32 (channelCount); 242 | command.connect.incomingBandwidth = ENET_HOST_TO_NET_32 (host -> incomingBandwidth); 243 | command.connect.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth); 244 | command.connect.packetThrottleInterval = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleInterval); 245 | command.connect.packetThrottleAcceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleAcceleration); 246 | command.connect.packetThrottleDeceleration = ENET_HOST_TO_NET_32 (currentPeer -> packetThrottleDeceleration); 247 | command.connect.connectID = currentPeer -> connectID; 248 | command.connect.data = ENET_HOST_TO_NET_32 (data); 249 | 250 | enet_peer_queue_outgoing_command (currentPeer, & command, NULL, 0, 0); 251 | 252 | return currentPeer; 253 | } 254 | 255 | /** Queues a packet to be sent to all peers associated with the host. 256 | @param host host on which to broadcast the packet 257 | @param channelID channel on which to broadcast 258 | @param packet packet to broadcast 259 | */ 260 | void 261 | enet_host_broadcast (ENetHost * host, enet_uint8 channelID, ENetPacket * packet) 262 | { 263 | ENetPeer * currentPeer; 264 | 265 | for (currentPeer = host -> peers; 266 | currentPeer < & host -> peers [host -> peerCount]; 267 | ++ currentPeer) 268 | { 269 | if (currentPeer -> state != ENET_PEER_STATE_CONNECTED) 270 | continue; 271 | 272 | enet_peer_send (currentPeer, channelID, packet); 273 | } 274 | 275 | if (packet -> referenceCount == 0) 276 | enet_packet_destroy (packet); 277 | } 278 | 279 | /** Sets the packet compressor the host should use to compress and decompress packets. 280 | @param host host to enable or disable compression for 281 | @param compressor callbacks for for the packet compressor; if NULL, then compression is disabled 282 | */ 283 | void 284 | enet_host_compress (ENetHost * host, const ENetCompressor * compressor) 285 | { 286 | if (host -> compressor.context != NULL && host -> compressor.destroy) 287 | (* host -> compressor.destroy) (host -> compressor.context); 288 | 289 | if (compressor) 290 | host -> compressor = * compressor; 291 | else 292 | host -> compressor.context = NULL; 293 | } 294 | 295 | /** Limits the maximum allowed channels of future incoming connections. 296 | @param host host to limit 297 | @param channelLimit the maximum number of channels allowed; if 0, then this is equivalent to ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT 298 | */ 299 | void 300 | enet_host_channel_limit (ENetHost * host, size_t channelLimit) 301 | { 302 | if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT) 303 | channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT; 304 | else 305 | if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT) 306 | channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT; 307 | 308 | host -> channelLimit = channelLimit; 309 | } 310 | 311 | 312 | /** Adjusts the bandwidth limits of a host. 313 | @param host host to adjust 314 | @param incomingBandwidth new incoming bandwidth 315 | @param outgoingBandwidth new outgoing bandwidth 316 | @remarks the incoming and outgoing bandwidth parameters are identical in function to those 317 | specified in enet_host_create(). 318 | */ 319 | void 320 | enet_host_bandwidth_limit (ENetHost * host, enet_uint32 incomingBandwidth, enet_uint32 outgoingBandwidth) 321 | { 322 | host -> incomingBandwidth = incomingBandwidth; 323 | host -> outgoingBandwidth = outgoingBandwidth; 324 | host -> recalculateBandwidthLimits = 1; 325 | } 326 | 327 | void 328 | enet_host_bandwidth_throttle (ENetHost * host) 329 | { 330 | enet_uint32 timeCurrent = enet_time_get (), 331 | elapsedTime = timeCurrent - host -> bandwidthThrottleEpoch, 332 | peersRemaining = (enet_uint32) host -> connectedPeers, 333 | dataTotal = ~0, 334 | bandwidth = ~0, 335 | throttle = 0, 336 | bandwidthLimit = 0; 337 | int needsAdjustment = host -> bandwidthLimitedPeers > 0 ? 1 : 0; 338 | ENetPeer * peer; 339 | ENetProtocol command; 340 | 341 | if (elapsedTime < ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL) 342 | return; 343 | 344 | host -> bandwidthThrottleEpoch = timeCurrent; 345 | 346 | if (peersRemaining == 0) 347 | return; 348 | 349 | if (host -> outgoingBandwidth != 0) 350 | { 351 | dataTotal = 0; 352 | bandwidth = (host -> outgoingBandwidth * elapsedTime) / 1000; 353 | 354 | for (peer = host -> peers; 355 | peer < & host -> peers [host -> peerCount]; 356 | ++ peer) 357 | { 358 | if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) 359 | continue; 360 | 361 | dataTotal += peer -> outgoingDataTotal; 362 | } 363 | } 364 | 365 | while (peersRemaining > 0 && needsAdjustment != 0) 366 | { 367 | needsAdjustment = 0; 368 | 369 | if (dataTotal <= bandwidth) 370 | throttle = ENET_PEER_PACKET_THROTTLE_SCALE; 371 | else 372 | throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal; 373 | 374 | for (peer = host -> peers; 375 | peer < & host -> peers [host -> peerCount]; 376 | ++ peer) 377 | { 378 | enet_uint32 peerBandwidth; 379 | 380 | if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) || 381 | peer -> incomingBandwidth == 0 || 382 | peer -> outgoingBandwidthThrottleEpoch == timeCurrent) 383 | continue; 384 | 385 | peerBandwidth = (peer -> incomingBandwidth * elapsedTime) / 1000; 386 | if ((throttle * peer -> outgoingDataTotal) / ENET_PEER_PACKET_THROTTLE_SCALE <= peerBandwidth) 387 | continue; 388 | 389 | peer -> packetThrottleLimit = (peerBandwidth * 390 | ENET_PEER_PACKET_THROTTLE_SCALE) / peer -> outgoingDataTotal; 391 | 392 | if (peer -> packetThrottleLimit == 0) 393 | peer -> packetThrottleLimit = 1; 394 | 395 | if (peer -> packetThrottle > peer -> packetThrottleLimit) 396 | peer -> packetThrottle = peer -> packetThrottleLimit; 397 | 398 | peer -> outgoingBandwidthThrottleEpoch = timeCurrent; 399 | 400 | peer -> incomingDataTotal = 0; 401 | peer -> outgoingDataTotal = 0; 402 | 403 | needsAdjustment = 1; 404 | -- peersRemaining; 405 | bandwidth -= peerBandwidth; 406 | dataTotal -= peerBandwidth; 407 | } 408 | } 409 | 410 | if (peersRemaining > 0) 411 | { 412 | if (dataTotal <= bandwidth) 413 | throttle = ENET_PEER_PACKET_THROTTLE_SCALE; 414 | else 415 | throttle = (bandwidth * ENET_PEER_PACKET_THROTTLE_SCALE) / dataTotal; 416 | 417 | for (peer = host -> peers; 418 | peer < & host -> peers [host -> peerCount]; 419 | ++ peer) 420 | { 421 | if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) || 422 | peer -> outgoingBandwidthThrottleEpoch == timeCurrent) 423 | continue; 424 | 425 | peer -> packetThrottleLimit = throttle; 426 | 427 | if (peer -> packetThrottle > peer -> packetThrottleLimit) 428 | peer -> packetThrottle = peer -> packetThrottleLimit; 429 | 430 | peer -> incomingDataTotal = 0; 431 | peer -> outgoingDataTotal = 0; 432 | } 433 | } 434 | 435 | if (host -> recalculateBandwidthLimits) 436 | { 437 | host -> recalculateBandwidthLimits = 0; 438 | 439 | peersRemaining = (enet_uint32) host -> connectedPeers; 440 | bandwidth = host -> incomingBandwidth; 441 | needsAdjustment = 1; 442 | 443 | if (bandwidth == 0) 444 | bandwidthLimit = 0; 445 | else 446 | while (peersRemaining > 0 && needsAdjustment != 0) 447 | { 448 | needsAdjustment = 0; 449 | bandwidthLimit = bandwidth / peersRemaining; 450 | 451 | for (peer = host -> peers; 452 | peer < & host -> peers [host -> peerCount]; 453 | ++ peer) 454 | { 455 | if ((peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) || 456 | peer -> incomingBandwidthThrottleEpoch == timeCurrent) 457 | continue; 458 | 459 | if (peer -> outgoingBandwidth > 0 && 460 | peer -> outgoingBandwidth >= bandwidthLimit) 461 | continue; 462 | 463 | peer -> incomingBandwidthThrottleEpoch = timeCurrent; 464 | 465 | needsAdjustment = 1; 466 | -- peersRemaining; 467 | bandwidth -= peer -> outgoingBandwidth; 468 | } 469 | } 470 | 471 | for (peer = host -> peers; 472 | peer < & host -> peers [host -> peerCount]; 473 | ++ peer) 474 | { 475 | if (peer -> state != ENET_PEER_STATE_CONNECTED && peer -> state != ENET_PEER_STATE_DISCONNECT_LATER) 476 | continue; 477 | 478 | command.header.command = ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE; 479 | command.header.channelID = 0xFF; 480 | command.bandwidthLimit.outgoingBandwidth = ENET_HOST_TO_NET_32 (host -> outgoingBandwidth); 481 | 482 | if (peer -> incomingBandwidthThrottleEpoch == timeCurrent) 483 | command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (peer -> outgoingBandwidth); 484 | else 485 | command.bandwidthLimit.incomingBandwidth = ENET_HOST_TO_NET_32 (bandwidthLimit); 486 | 487 | enet_peer_queue_outgoing_command (peer, & command, NULL, 0, 0); 488 | } 489 | } 490 | } 491 | 492 | /** @} */ 493 | -------------------------------------------------------------------------------- /CPPBot/enet/include/callbacks.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file callbacks.h 3 | @brief ENet callbacks 4 | */ 5 | #ifndef __ENET_CALLBACKS_H__ 6 | #define __ENET_CALLBACKS_H__ 7 | 8 | #include 9 | 10 | typedef struct _ENetCallbacks 11 | { 12 | void * (ENET_CALLBACK * malloc) (size_t size); 13 | void (ENET_CALLBACK * free) (void * memory); 14 | void (ENET_CALLBACK * no_memory) (void); 15 | } ENetCallbacks; 16 | 17 | /** @defgroup callbacks ENet internal callbacks 18 | @{ 19 | @ingroup private 20 | */ 21 | extern void * enet_malloc (size_t); 22 | extern void enet_free (void *); 23 | 24 | /** @} */ 25 | 26 | #endif /* __ENET_CALLBACKS_H__ */ 27 | 28 | -------------------------------------------------------------------------------- /CPPBot/enet/include/enet.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file enet.h 3 | @brief ENet public header file 4 | */ 5 | #ifndef __ENET_ENET_H__ 6 | #define __ENET_ENET_H__ 7 | 8 | #ifdef __cplusplus 9 | extern "C" 10 | { 11 | #endif 12 | 13 | #include 14 | 15 | #ifdef _WIN32 16 | #include "win32.h" 17 | #else 18 | #include "unix.h" 19 | #endif 20 | 21 | #include "types.h" 22 | #include "protocol.h" 23 | #include "list.h" 24 | #include "callbacks.h" 25 | 26 | #define ENET_VERSION_MAJOR 1 27 | #define ENET_VERSION_MINOR 3 28 | #define ENET_VERSION_PATCH 14 29 | #define ENET_VERSION_CREATE(major, minor, patch) (((major)<<16) | ((minor)<<8) | (patch)) 30 | #define ENET_VERSION_GET_MAJOR(version) (((version)>>16)&0xFF) 31 | #define ENET_VERSION_GET_MINOR(version) (((version)>>8)&0xFF) 32 | #define ENET_VERSION_GET_PATCH(version) ((version)&0xFF) 33 | #define ENET_VERSION ENET_VERSION_CREATE(ENET_VERSION_MAJOR, ENET_VERSION_MINOR, ENET_VERSION_PATCH) 34 | 35 | typedef enet_uint32 ENetVersion; 36 | 37 | struct _ENetHost; 38 | struct _ENetEvent; 39 | struct _ENetPacket; 40 | 41 | typedef enum _ENetSocketType 42 | { 43 | ENET_SOCKET_TYPE_STREAM = 1, 44 | ENET_SOCKET_TYPE_DATAGRAM = 2 45 | } ENetSocketType; 46 | 47 | typedef enum _ENetSocketWait 48 | { 49 | ENET_SOCKET_WAIT_NONE = 0, 50 | ENET_SOCKET_WAIT_SEND = (1 << 0), 51 | ENET_SOCKET_WAIT_RECEIVE = (1 << 1), 52 | ENET_SOCKET_WAIT_INTERRUPT = (1 << 2) 53 | } ENetSocketWait; 54 | 55 | typedef enum _ENetSocketOption 56 | { 57 | ENET_SOCKOPT_NONBLOCK = 1, 58 | ENET_SOCKOPT_BROADCAST = 2, 59 | ENET_SOCKOPT_RCVBUF = 3, 60 | ENET_SOCKOPT_SNDBUF = 4, 61 | ENET_SOCKOPT_REUSEADDR = 5, 62 | ENET_SOCKOPT_RCVTIMEO = 6, 63 | ENET_SOCKOPT_SNDTIMEO = 7, 64 | ENET_SOCKOPT_ERROR = 8, 65 | ENET_SOCKOPT_NODELAY = 9 66 | } ENetSocketOption; 67 | 68 | typedef enum _ENetSocketShutdown 69 | { 70 | ENET_SOCKET_SHUTDOWN_READ = 0, 71 | ENET_SOCKET_SHUTDOWN_WRITE = 1, 72 | ENET_SOCKET_SHUTDOWN_READ_WRITE = 2 73 | } ENetSocketShutdown; 74 | 75 | #define ENET_HOST_ANY 0 76 | #define ENET_HOST_BROADCAST 0xFFFFFFFFU 77 | #define ENET_PORT_ANY 0 78 | 79 | /** 80 | * Portable internet address structure. 81 | * 82 | * The host must be specified in network byte-order, and the port must be in host 83 | * byte-order. The constant ENET_HOST_ANY may be used to specify the default 84 | * server host. The constant ENET_HOST_BROADCAST may be used to specify the 85 | * broadcast address (255.255.255.255). This makes sense for enet_host_connect, 86 | * but not for enet_host_create. Once a server responds to a broadcast, the 87 | * address is updated from ENET_HOST_BROADCAST to the server's actual IP address. 88 | */ 89 | typedef struct _ENetAddress { 90 | enet_uint32 host; 91 | enet_uint16 port; 92 | } ENetAddress; 93 | 94 | /** 95 | * Packet flag bit constants. 96 | * 97 | * The host must be specified in network byte-order, and the port must be in 98 | * host byte-order. The constant ENET_HOST_ANY may be used to specify the 99 | * default server host. 100 | 101 | @sa ENetPacket 102 | */ 103 | typedef enum _ENetPacketFlag 104 | { 105 | /** packet must be received by the target peer and resend attempts should be 106 | * made until the packet is delivered */ 107 | ENET_PACKET_FLAG_RELIABLE = (1 << 0), 108 | /** packet will not be sequenced with other packets 109 | * not supported for reliable packets 110 | */ 111 | ENET_PACKET_FLAG_UNSEQUENCED = (1 << 1), 112 | /** packet will not allocate data, and user must supply it instead */ 113 | ENET_PACKET_FLAG_NO_ALLOCATE = (1 << 2), 114 | /** packet will be fragmented using unreliable (instead of reliable) sends 115 | * if it exceeds the MTU */ 116 | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT = (1 << 3), 117 | 118 | /** whether the packet has been sent from all queues it has been entered into */ 119 | ENET_PACKET_FLAG_SENT = (1<<8) 120 | } ENetPacketFlag; 121 | 122 | typedef void (ENET_CALLBACK * ENetPacketFreeCallback) (struct _ENetPacket *); 123 | 124 | /** 125 | * ENet packet structure. 126 | * 127 | * An ENet data packet that may be sent to or received from a peer. The shown 128 | * fields should only be read and never modified. The data field contains the 129 | * allocated data for the packet. The dataLength fields specifies the length 130 | * of the allocated data. The flags field is either 0 (specifying no flags), 131 | * or a bitwise-or of any combination of the following flags: 132 | * 133 | * ENET_PACKET_FLAG_RELIABLE - packet must be received by the target peer 134 | * and resend attempts should be made until the packet is delivered 135 | * 136 | * ENET_PACKET_FLAG_UNSEQUENCED - packet will not be sequenced with other packets 137 | * (not supported for reliable packets) 138 | * 139 | * ENET_PACKET_FLAG_NO_ALLOCATE - packet will not allocate data, and user must supply it instead 140 | * 141 | * ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT - packet will be fragmented using unreliable 142 | * (instead of reliable) sends if it exceeds the MTU 143 | * 144 | * ENET_PACKET_FLAG_SENT - whether the packet has been sent from all queues it has been entered into 145 | @sa ENetPacketFlag 146 | */ 147 | typedef struct _ENetPacket 148 | { 149 | size_t referenceCount; /**< internal use only */ 150 | enet_uint32 flags; /**< bitwise-or of ENetPacketFlag constants */ 151 | enet_uint8 * data; /**< allocated data for packet */ 152 | size_t dataLength; /**< length of data */ 153 | ENetPacketFreeCallback freeCallback; /**< function to be called when the packet is no longer in use */ 154 | void * userData; /**< application private data, may be freely modified */ 155 | } ENetPacket; 156 | 157 | typedef struct _ENetAcknowledgement 158 | { 159 | ENetListNode acknowledgementList; 160 | enet_uint32 sentTime; 161 | ENetProtocol command; 162 | } ENetAcknowledgement; 163 | 164 | typedef struct _ENetOutgoingCommand 165 | { 166 | ENetListNode outgoingCommandList; 167 | enet_uint16 reliableSequenceNumber; 168 | enet_uint16 unreliableSequenceNumber; 169 | enet_uint32 sentTime; 170 | enet_uint32 roundTripTimeout; 171 | enet_uint32 roundTripTimeoutLimit; 172 | enet_uint32 fragmentOffset; 173 | enet_uint16 fragmentLength; 174 | enet_uint16 sendAttempts; 175 | ENetProtocol command; 176 | ENetPacket * packet; 177 | } ENetOutgoingCommand; 178 | 179 | typedef struct _ENetIncomingCommand 180 | { 181 | ENetListNode incomingCommandList; 182 | enet_uint16 reliableSequenceNumber; 183 | enet_uint16 unreliableSequenceNumber; 184 | ENetProtocol command; 185 | enet_uint32 fragmentCount; 186 | enet_uint32 fragmentsRemaining; 187 | enet_uint32 * fragments; 188 | ENetPacket * packet; 189 | } ENetIncomingCommand; 190 | 191 | typedef enum _ENetPeerState 192 | { 193 | ENET_PEER_STATE_DISCONNECTED = 0, 194 | ENET_PEER_STATE_CONNECTING = 1, 195 | ENET_PEER_STATE_ACKNOWLEDGING_CONNECT = 2, 196 | ENET_PEER_STATE_CONNECTION_PENDING = 3, 197 | ENET_PEER_STATE_CONNECTION_SUCCEEDED = 4, 198 | ENET_PEER_STATE_CONNECTED = 5, 199 | ENET_PEER_STATE_DISCONNECT_LATER = 6, 200 | ENET_PEER_STATE_DISCONNECTING = 7, 201 | ENET_PEER_STATE_ACKNOWLEDGING_DISCONNECT = 8, 202 | ENET_PEER_STATE_ZOMBIE = 9 203 | } ENetPeerState; 204 | 205 | #ifndef ENET_BUFFER_MAXIMUM 206 | #define ENET_BUFFER_MAXIMUM (1 + 2 * ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS) 207 | #endif 208 | 209 | enum 210 | { 211 | ENET_HOST_RECEIVE_BUFFER_SIZE = 256 * 1024, 212 | ENET_HOST_SEND_BUFFER_SIZE = 256 * 1024, 213 | ENET_HOST_BANDWIDTH_THROTTLE_INTERVAL = 1000, 214 | ENET_HOST_DEFAULT_MTU = 1400, 215 | ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE = 32 * 1024 * 1024, 216 | ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA = 32 * 1024 * 1024, 217 | 218 | ENET_PEER_DEFAULT_ROUND_TRIP_TIME = 500, 219 | ENET_PEER_DEFAULT_PACKET_THROTTLE = 32, 220 | ENET_PEER_PACKET_THROTTLE_SCALE = 32, 221 | ENET_PEER_PACKET_THROTTLE_COUNTER = 7, 222 | ENET_PEER_PACKET_THROTTLE_ACCELERATION = 2, 223 | ENET_PEER_PACKET_THROTTLE_DECELERATION = 2, 224 | ENET_PEER_PACKET_THROTTLE_INTERVAL = 5000, 225 | ENET_PEER_PACKET_LOSS_SCALE = (1 << 16), 226 | ENET_PEER_PACKET_LOSS_INTERVAL = 10000, 227 | ENET_PEER_WINDOW_SIZE_SCALE = 64 * 1024, 228 | ENET_PEER_TIMEOUT_LIMIT = 32, 229 | ENET_PEER_TIMEOUT_MINIMUM = 5000, 230 | ENET_PEER_TIMEOUT_MAXIMUM = 30000, 231 | ENET_PEER_PING_INTERVAL = 500, 232 | ENET_PEER_UNSEQUENCED_WINDOWS = 64, 233 | ENET_PEER_UNSEQUENCED_WINDOW_SIZE = 1024, 234 | ENET_PEER_FREE_UNSEQUENCED_WINDOWS = 32, 235 | ENET_PEER_RELIABLE_WINDOWS = 16, 236 | ENET_PEER_RELIABLE_WINDOW_SIZE = 0x1000, 237 | ENET_PEER_FREE_RELIABLE_WINDOWS = 8 238 | }; 239 | 240 | typedef struct _ENetChannel 241 | { 242 | enet_uint16 outgoingReliableSequenceNumber; 243 | enet_uint16 outgoingUnreliableSequenceNumber; 244 | enet_uint16 usedReliableWindows; 245 | enet_uint16 reliableWindows [ENET_PEER_RELIABLE_WINDOWS]; 246 | enet_uint16 incomingReliableSequenceNumber; 247 | enet_uint16 incomingUnreliableSequenceNumber; 248 | ENetList incomingReliableCommands; 249 | ENetList incomingUnreliableCommands; 250 | } ENetChannel; 251 | 252 | /** 253 | * An ENet peer which data packets may be sent or received from. 254 | * 255 | * No fields should be modified unless otherwise specified. 256 | */ 257 | typedef struct _ENetPeer 258 | { 259 | ENetListNode dispatchList; 260 | struct _ENetHost * host; 261 | enet_uint16 outgoingPeerID; 262 | enet_uint16 incomingPeerID; 263 | enet_uint32 connectID; 264 | enet_uint8 outgoingSessionID; 265 | enet_uint8 incomingSessionID; 266 | ENetAddress address; /**< Internet address of the peer */ 267 | void * data; /**< Application private data, may be freely modified */ 268 | ENetPeerState state; 269 | ENetChannel * channels; 270 | size_t channelCount; /**< Number of channels allocated for communication with peer */ 271 | enet_uint32 incomingBandwidth; /**< Downstream bandwidth of the client in bytes/second */ 272 | enet_uint32 outgoingBandwidth; /**< Upstream bandwidth of the client in bytes/second */ 273 | enet_uint32 incomingBandwidthThrottleEpoch; 274 | enet_uint32 outgoingBandwidthThrottleEpoch; 275 | enet_uint32 incomingDataTotal; 276 | enet_uint32 outgoingDataTotal; 277 | enet_uint32 lastSendTime; 278 | enet_uint32 lastReceiveTime; 279 | enet_uint32 nextTimeout; 280 | enet_uint32 earliestTimeout; 281 | enet_uint32 packetLossEpoch; 282 | enet_uint32 packetsSent; 283 | enet_uint32 packetsLost; 284 | enet_uint32 packetLoss; /**< mean packet loss of reliable packets as a ratio with respect to the constant ENET_PEER_PACKET_LOSS_SCALE */ 285 | enet_uint32 packetLossVariance; 286 | enet_uint32 packetThrottle; 287 | enet_uint32 packetThrottleLimit; 288 | enet_uint32 packetThrottleCounter; 289 | enet_uint32 packetThrottleEpoch; 290 | enet_uint32 packetThrottleAcceleration; 291 | enet_uint32 packetThrottleDeceleration; 292 | enet_uint32 packetThrottleInterval; 293 | enet_uint32 pingInterval; 294 | enet_uint32 timeoutLimit; 295 | enet_uint32 timeoutMinimum; 296 | enet_uint32 timeoutMaximum; 297 | enet_uint32 lastRoundTripTime; 298 | enet_uint32 lowestRoundTripTime; 299 | enet_uint32 lastRoundTripTimeVariance; 300 | enet_uint32 highestRoundTripTimeVariance; 301 | enet_uint32 roundTripTime; /**< mean round trip time (RTT), in milliseconds, between sending a reliable packet and receiving its acknowledgement */ 302 | enet_uint32 roundTripTimeVariance; 303 | enet_uint32 mtu; 304 | enet_uint32 windowSize; 305 | enet_uint32 reliableDataInTransit; 306 | enet_uint16 outgoingReliableSequenceNumber; 307 | ENetList acknowledgements; 308 | ENetList sentReliableCommands; 309 | ENetList sentUnreliableCommands; 310 | ENetList outgoingReliableCommands; 311 | ENetList outgoingUnreliableCommands; 312 | ENetList dispatchedCommands; 313 | int needsDispatch; 314 | enet_uint16 incomingUnsequencedGroup; 315 | enet_uint16 outgoingUnsequencedGroup; 316 | enet_uint32 unsequencedWindow [ENET_PEER_UNSEQUENCED_WINDOW_SIZE / 32]; 317 | enet_uint32 eventData; 318 | size_t totalWaitingData; 319 | } ENetPeer; 320 | 321 | /** An ENet packet compressor for compressing UDP packets before socket sends or receives. 322 | */ 323 | typedef struct _ENetCompressor 324 | { 325 | /** Context data for the compressor. Must be non-NULL. */ 326 | void * context; 327 | /** Compresses from inBuffers[0:inBufferCount-1], containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */ 328 | size_t (ENET_CALLBACK * compress) (void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit); 329 | /** Decompresses from inData, containing inLimit bytes, to outData, outputting at most outLimit bytes. Should return 0 on failure. */ 330 | size_t (ENET_CALLBACK * decompress) (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit); 331 | /** Destroys the context when compression is disabled or the host is destroyed. May be NULL. */ 332 | void (ENET_CALLBACK * destroy) (void * context); 333 | } ENetCompressor; 334 | 335 | /** Callback that computes the checksum of the data held in buffers[0:bufferCount-1] */ 336 | typedef enet_uint32 (ENET_CALLBACK * ENetChecksumCallback) (const ENetBuffer * buffers, size_t bufferCount); 337 | 338 | /** Callback for intercepting received raw UDP packets. Should return 1 to intercept, 0 to ignore, or -1 to propagate an error. */ 339 | typedef int (ENET_CALLBACK * ENetInterceptCallback) (struct _ENetHost * host, struct _ENetEvent * event); 340 | 341 | /** An ENet host for communicating with peers. 342 | * 343 | * No fields should be modified unless otherwise stated. 344 | 345 | @sa enet_host_create() 346 | @sa enet_host_destroy() 347 | @sa enet_host_connect() 348 | @sa enet_host_service() 349 | @sa enet_host_flush() 350 | @sa enet_host_broadcast() 351 | @sa enet_host_compress() 352 | @sa enet_host_compress_with_range_coder() 353 | @sa enet_host_channel_limit() 354 | @sa enet_host_bandwidth_limit() 355 | @sa enet_host_bandwidth_throttle() 356 | */ 357 | typedef struct _ENetHost 358 | { 359 | ENetSocket socket; 360 | ENetAddress address; /**< Internet address of the host */ 361 | enet_uint32 incomingBandwidth; /**< downstream bandwidth of the host */ 362 | enet_uint32 outgoingBandwidth; /**< upstream bandwidth of the host */ 363 | enet_uint32 bandwidthThrottleEpoch; 364 | enet_uint32 mtu; 365 | enet_uint32 randomSeed; 366 | int recalculateBandwidthLimits; 367 | ENetPeer * peers; /**< array of peers allocated for this host */ 368 | size_t peerCount; /**< number of peers allocated for this host */ 369 | size_t channelLimit; /**< maximum number of channels allowed for connected peers */ 370 | enet_uint32 serviceTime; 371 | ENetList dispatchQueue; 372 | int continueSending; 373 | size_t packetSize; 374 | enet_uint16 headerFlags; 375 | ENetProtocol commands [ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS]; 376 | size_t commandCount; 377 | ENetBuffer buffers [ENET_BUFFER_MAXIMUM]; 378 | size_t bufferCount; 379 | ENetChecksumCallback checksum; /**< callback the user can set to enable packet checksums for this host */ 380 | ENetCompressor compressor; 381 | enet_uint8 packetData [2][ENET_PROTOCOL_MAXIMUM_MTU]; 382 | ENetAddress receivedAddress; 383 | enet_uint8 * receivedData; 384 | size_t receivedDataLength; 385 | enet_uint32 totalSentData; /**< total data sent, user should reset to 0 as needed to prevent overflow */ 386 | enet_uint32 totalSentPackets; /**< total UDP packets sent, user should reset to 0 as needed to prevent overflow */ 387 | enet_uint32 totalReceivedData; /**< total data received, user should reset to 0 as needed to prevent overflow */ 388 | enet_uint32 totalReceivedPackets; /**< total UDP packets received, user should reset to 0 as needed to prevent overflow */ 389 | ENetInterceptCallback intercept; /**< callback the user can set to intercept received raw UDP packets */ 390 | size_t connectedPeers; 391 | size_t bandwidthLimitedPeers; 392 | size_t duplicatePeers; /**< optional number of allowed peers from duplicate IPs, defaults to ENET_PROTOCOL_MAXIMUM_PEER_ID */ 393 | size_t maximumPacketSize; /**< the maximum allowable packet size that may be sent or received on a peer */ 394 | size_t maximumWaitingData; /**< the maximum aggregate amount of buffer space a peer may use waiting for packets to be delivered */ 395 | size_t usingNewPacket; /**< the New and Improved! */ 396 | } ENetHost; 397 | 398 | /** 399 | * An ENet event type, as specified in @ref ENetEvent. 400 | */ 401 | typedef enum _ENetEventType 402 | { 403 | /** no event occurred within the specified time limit */ 404 | ENET_EVENT_TYPE_NONE = 0, 405 | 406 | /** a connection request initiated by enet_host_connect has completed. 407 | * The peer field contains the peer which successfully connected. 408 | */ 409 | ENET_EVENT_TYPE_CONNECT = 1, 410 | 411 | /** a peer has disconnected. This event is generated on a successful 412 | * completion of a disconnect initiated by enet_peer_disconnect, if 413 | * a peer has timed out, or if a connection request intialized by 414 | * enet_host_connect has timed out. The peer field contains the peer 415 | * which disconnected. The data field contains user supplied data 416 | * describing the disconnection, or 0, if none is available. 417 | */ 418 | ENET_EVENT_TYPE_DISCONNECT = 2, 419 | 420 | /** a packet has been received from a peer. The peer field specifies the 421 | * peer which sent the packet. The channelID field specifies the channel 422 | * number upon which the packet was received. The packet field contains 423 | * the packet that was received; this packet must be destroyed with 424 | * enet_packet_destroy after use. 425 | */ 426 | ENET_EVENT_TYPE_RECEIVE = 3 427 | } ENetEventType; 428 | 429 | /** 430 | * An ENet event as returned by enet_host_service(). 431 | 432 | @sa enet_host_service 433 | */ 434 | typedef struct _ENetEvent 435 | { 436 | ENetEventType type; /**< type of the event */ 437 | ENetPeer * peer; /**< peer that generated a connect, disconnect or receive event */ 438 | enet_uint8 channelID; /**< channel on the peer that generated the event, if appropriate */ 439 | enet_uint32 data; /**< data associated with the event, if appropriate */ 440 | ENetPacket * packet; /**< packet associated with the event, if appropriate */ 441 | } ENetEvent; 442 | 443 | /** @defgroup global ENet global functions 444 | @{ 445 | */ 446 | 447 | /** 448 | Initializes ENet globally. Must be called prior to using any functions in 449 | ENet. 450 | @returns 0 on success, < 0 on failure 451 | */ 452 | ENET_API int enet_initialize (void); 453 | 454 | /** 455 | Initializes ENet globally and supplies user-overridden callbacks. Must be called prior to using any functions in ENet. Do not use enet_initialize() if you use this variant. Make sure the ENetCallbacks structure is zeroed out so that any additional callbacks added in future versions will be properly ignored. 456 | 457 | @param version the constant ENET_VERSION should be supplied so ENet knows which version of ENetCallbacks struct to use 458 | @param inits user-overridden callbacks where any NULL callbacks will use ENet's defaults 459 | @returns 0 on success, < 0 on failure 460 | */ 461 | ENET_API int enet_initialize_with_callbacks (ENetVersion version, const ENetCallbacks * inits); 462 | 463 | /** 464 | Shuts down ENet globally. Should be called when a program that has 465 | initialized ENet exits. 466 | */ 467 | ENET_API void enet_deinitialize (void); 468 | 469 | /** 470 | Gives the linked version of the ENet library. 471 | @returns the version number 472 | */ 473 | ENET_API ENetVersion enet_linked_version (void); 474 | 475 | /** @} */ 476 | 477 | /** @defgroup private ENet private implementation functions */ 478 | 479 | /** 480 | Returns the wall-time in milliseconds. Its initial value is unspecified 481 | unless otherwise set. 482 | */ 483 | ENET_API enet_uint32 enet_time_get (void); 484 | /** 485 | Sets the current wall-time in milliseconds. 486 | */ 487 | ENET_API void enet_time_set (enet_uint32); 488 | 489 | /** @defgroup socket ENet socket functions 490 | @{ 491 | */ 492 | ENET_API ENetSocket enet_socket_create (ENetSocketType); 493 | ENET_API int enet_socket_bind (ENetSocket, const ENetAddress *); 494 | ENET_API int enet_socket_get_address (ENetSocket, ENetAddress *); 495 | ENET_API int enet_socket_listen (ENetSocket, int); 496 | ENET_API ENetSocket enet_socket_accept (ENetSocket, ENetAddress *); 497 | ENET_API int enet_socket_connect (ENetSocket, const ENetAddress *); 498 | ENET_API int enet_socket_send (ENetSocket, const ENetAddress *, const ENetBuffer *, size_t); 499 | ENET_API int enet_socket_receive (ENetSocket, ENetAddress *, ENetBuffer *, size_t); 500 | ENET_API int enet_socket_wait (ENetSocket, enet_uint32 *, enet_uint32); 501 | ENET_API int enet_socket_set_option (ENetSocket, ENetSocketOption, int); 502 | ENET_API int enet_socket_get_option (ENetSocket, ENetSocketOption, int *); 503 | ENET_API int enet_socket_shutdown (ENetSocket, ENetSocketShutdown); 504 | ENET_API void enet_socket_destroy (ENetSocket); 505 | ENET_API int enet_socketset_select (ENetSocket, ENetSocketSet *, ENetSocketSet *, enet_uint32); 506 | 507 | /** @} */ 508 | 509 | /** @defgroup Address ENet address functions 510 | @{ 511 | */ 512 | 513 | /** Attempts to parse the printable form of the IP address in the parameter hostName 514 | and sets the host field in the address parameter if successful. 515 | @param address destination to store the parsed IP address 516 | @param hostName IP address to parse 517 | @retval 0 on success 518 | @retval < 0 on failure 519 | @returns the address of the given hostName in address on success 520 | */ 521 | ENET_API int enet_address_set_host_ip (ENetAddress * address, const char * hostName); 522 | 523 | /** Attempts to resolve the host named by the parameter hostName and sets 524 | the host field in the address parameter if successful. 525 | @param address destination to store resolved address 526 | @param hostName host name to lookup 527 | @retval 0 on success 528 | @retval < 0 on failure 529 | @returns the address of the given hostName in address on success 530 | */ 531 | ENET_API int enet_address_set_host (ENetAddress * address, const char * hostName); 532 | 533 | /** Gives the printable form of the IP address specified in the address parameter. 534 | @param address address printed 535 | @param hostName destination for name, must not be NULL 536 | @param nameLength maximum length of hostName. 537 | @returns the null-terminated name of the host in hostName on success 538 | @retval 0 on success 539 | @retval < 0 on failure 540 | */ 541 | ENET_API int enet_address_get_host_ip (const ENetAddress * address, char * hostName, size_t nameLength); 542 | 543 | /** Attempts to do a reverse lookup of the host field in the address parameter. 544 | @param address address used for reverse lookup 545 | @param hostName destination for name, must not be NULL 546 | @param nameLength maximum length of hostName. 547 | @returns the null-terminated name of the host in hostName on success 548 | @retval 0 on success 549 | @retval < 0 on failure 550 | */ 551 | ENET_API int enet_address_get_host (const ENetAddress * address, char * hostName, size_t nameLength); 552 | 553 | /** @} */ 554 | 555 | ENET_API ENetPacket * enet_packet_create (const void *, size_t, enet_uint32); 556 | ENET_API void enet_packet_destroy (ENetPacket *); 557 | ENET_API int enet_packet_resize (ENetPacket *, size_t); 558 | ENET_API enet_uint32 enet_crc32 (const ENetBuffer *, size_t); 559 | 560 | ENET_API ENetHost * enet_host_create (const ENetAddress *, size_t, size_t, enet_uint32, enet_uint32); 561 | ENET_API void enet_host_destroy (ENetHost *); 562 | ENET_API ENetPeer * enet_host_connect (ENetHost *, const ENetAddress *, size_t, enet_uint32); 563 | ENET_API int enet_host_check_events (ENetHost *, ENetEvent *); 564 | ENET_API int enet_host_service (ENetHost *, ENetEvent *, enet_uint32); 565 | ENET_API void enet_host_flush (ENetHost *); 566 | ENET_API void enet_host_broadcast (ENetHost *, enet_uint8, ENetPacket *); 567 | ENET_API void enet_host_compress (ENetHost *, const ENetCompressor *); 568 | ENET_API int enet_host_compress_with_range_coder (ENetHost * host); 569 | ENET_API void enet_host_channel_limit (ENetHost *, size_t); 570 | ENET_API void enet_host_bandwidth_limit (ENetHost *, enet_uint32, enet_uint32); 571 | extern void enet_host_bandwidth_throttle (ENetHost *); 572 | extern enet_uint32 enet_host_random_seed (void); 573 | 574 | ENET_API int enet_peer_send (ENetPeer *, enet_uint8, ENetPacket *); 575 | ENET_API ENetPacket * enet_peer_receive (ENetPeer *, enet_uint8 * channelID); 576 | ENET_API void enet_peer_ping (ENetPeer *); 577 | ENET_API void enet_peer_ping_interval (ENetPeer *, enet_uint32); 578 | ENET_API void enet_peer_timeout (ENetPeer *, enet_uint32, enet_uint32, enet_uint32); 579 | ENET_API void enet_peer_reset (ENetPeer *); 580 | ENET_API void enet_peer_disconnect (ENetPeer *, enet_uint32); 581 | ENET_API void enet_peer_disconnect_now (ENetPeer *, enet_uint32); 582 | ENET_API void enet_peer_disconnect_later (ENetPeer *, enet_uint32); 583 | ENET_API void enet_peer_throttle_configure (ENetPeer *, enet_uint32, enet_uint32, enet_uint32); 584 | extern int enet_peer_throttle (ENetPeer *, enet_uint32); 585 | extern void enet_peer_reset_queues (ENetPeer *); 586 | extern void enet_peer_setup_outgoing_command (ENetPeer *, ENetOutgoingCommand *); 587 | extern ENetOutgoingCommand * enet_peer_queue_outgoing_command (ENetPeer *, const ENetProtocol *, ENetPacket *, enet_uint32, enet_uint16); 588 | extern ENetIncomingCommand * enet_peer_queue_incoming_command (ENetPeer *, const ENetProtocol *, const void *, size_t, enet_uint32, enet_uint32); 589 | extern ENetAcknowledgement * enet_peer_queue_acknowledgement (ENetPeer *, const ENetProtocol *, enet_uint16); 590 | extern void enet_peer_dispatch_incoming_unreliable_commands (ENetPeer *, ENetChannel *); 591 | extern void enet_peer_dispatch_incoming_reliable_commands (ENetPeer *, ENetChannel *); 592 | extern void enet_peer_on_connect (ENetPeer *); 593 | extern void enet_peer_on_disconnect (ENetPeer *); 594 | 595 | ENET_API void * enet_range_coder_create (void); 596 | ENET_API void enet_range_coder_destroy (void *); 597 | ENET_API size_t enet_range_coder_compress (void *, const ENetBuffer *, size_t, size_t, enet_uint8 *, size_t); 598 | ENET_API size_t enet_range_coder_decompress (void *, const enet_uint8 *, size_t, enet_uint8 *, size_t); 599 | 600 | extern size_t enet_protocol_command_size (enet_uint8); 601 | 602 | #ifdef __cplusplus 603 | } 604 | #endif 605 | 606 | #endif /* __ENET_ENET_H__ */ 607 | 608 | -------------------------------------------------------------------------------- /CPPBot/enet/include/list.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file list.h 3 | @brief ENet list management 4 | */ 5 | #ifndef __ENET_LIST_H__ 6 | #define __ENET_LIST_H__ 7 | 8 | #include 9 | 10 | typedef struct _ENetListNode 11 | { 12 | struct _ENetListNode * next; 13 | struct _ENetListNode * previous; 14 | } ENetListNode; 15 | 16 | typedef ENetListNode * ENetListIterator; 17 | 18 | typedef struct _ENetList 19 | { 20 | ENetListNode sentinel; 21 | } ENetList; 22 | 23 | extern void enet_list_clear (ENetList *); 24 | 25 | extern ENetListIterator enet_list_insert (ENetListIterator, void *); 26 | extern void * enet_list_remove (ENetListIterator); 27 | extern ENetListIterator enet_list_move (ENetListIterator, void *, void *); 28 | 29 | extern size_t enet_list_size (ENetList *); 30 | 31 | #define enet_list_begin(list) ((list) -> sentinel.next) 32 | #define enet_list_end(list) (& (list) -> sentinel) 33 | 34 | #define enet_list_empty(list) (enet_list_begin (list) == enet_list_end (list)) 35 | 36 | #define enet_list_next(iterator) ((iterator) -> next) 37 | #define enet_list_previous(iterator) ((iterator) -> previous) 38 | 39 | #define enet_list_front(list) ((void *) (list) -> sentinel.next) 40 | #define enet_list_back(list) ((void *) (list) -> sentinel.previous) 41 | 42 | #endif /* __ENET_LIST_H__ */ 43 | 44 | -------------------------------------------------------------------------------- /CPPBot/enet/include/protocol.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file protocol.h 3 | @brief ENet protocol 4 | */ 5 | #ifndef __ENET_PROTOCOL_H__ 6 | #define __ENET_PROTOCOL_H__ 7 | 8 | #include "types.h" 9 | 10 | enum 11 | { 12 | ENET_PROTOCOL_MINIMUM_MTU = 576, 13 | ENET_PROTOCOL_MAXIMUM_MTU = 4096, 14 | ENET_PROTOCOL_MAXIMUM_PACKET_COMMANDS = 32, 15 | ENET_PROTOCOL_MINIMUM_WINDOW_SIZE = 4096, 16 | ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE = 65536, 17 | ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT = 1, 18 | ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT = 255, 19 | ENET_PROTOCOL_MAXIMUM_PEER_ID = 0xFFF, 20 | ENET_PROTOCOL_MAXIMUM_FRAGMENT_COUNT = 1024 * 1024 21 | }; 22 | 23 | typedef enum _ENetProtocolCommand 24 | { 25 | ENET_PROTOCOL_COMMAND_NONE = 0, 26 | ENET_PROTOCOL_COMMAND_ACKNOWLEDGE = 1, 27 | ENET_PROTOCOL_COMMAND_CONNECT = 2, 28 | ENET_PROTOCOL_COMMAND_VERIFY_CONNECT = 3, 29 | ENET_PROTOCOL_COMMAND_DISCONNECT = 4, 30 | ENET_PROTOCOL_COMMAND_PING = 5, 31 | ENET_PROTOCOL_COMMAND_SEND_RELIABLE = 6, 32 | ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE = 7, 33 | ENET_PROTOCOL_COMMAND_SEND_FRAGMENT = 8, 34 | ENET_PROTOCOL_COMMAND_SEND_UNSEQUENCED = 9, 35 | ENET_PROTOCOL_COMMAND_BANDWIDTH_LIMIT = 10, 36 | ENET_PROTOCOL_COMMAND_THROTTLE_CONFIGURE = 11, 37 | ENET_PROTOCOL_COMMAND_SEND_UNRELIABLE_FRAGMENT = 12, 38 | ENET_PROTOCOL_COMMAND_COUNT = 13, 39 | 40 | ENET_PROTOCOL_COMMAND_MASK = 0x0F 41 | } ENetProtocolCommand; 42 | 43 | typedef enum _ENetProtocolFlag 44 | { 45 | ENET_PROTOCOL_COMMAND_FLAG_ACKNOWLEDGE = (1 << 7), 46 | ENET_PROTOCOL_COMMAND_FLAG_UNSEQUENCED = (1 << 6), 47 | 48 | ENET_PROTOCOL_HEADER_FLAG_COMPRESSED = (1 << 14), 49 | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME = (1 << 15), 50 | ENET_PROTOCOL_HEADER_FLAG_MASK = ENET_PROTOCOL_HEADER_FLAG_COMPRESSED | ENET_PROTOCOL_HEADER_FLAG_SENT_TIME, 51 | 52 | ENET_PROTOCOL_HEADER_SESSION_MASK = (3 << 12), 53 | ENET_PROTOCOL_HEADER_SESSION_SHIFT = 12 54 | } ENetProtocolFlag; 55 | 56 | #ifdef _MSC_VER 57 | #pragma pack(push, 1) 58 | #define ENET_PACKED 59 | #elif defined(__GNUC__) || defined(__clang__) 60 | #define ENET_PACKED __attribute__ ((packed)) 61 | #else 62 | #define ENET_PACKED 63 | #endif 64 | 65 | typedef struct _ENetProtocolHeader 66 | { 67 | enet_uint16 peerID; 68 | enet_uint16 sentTime; 69 | } ENET_PACKED ENetProtocolHeader; 70 | 71 | typedef struct _ENetProtocolHeaderUbisoft { 72 | enet_uint16 integrity[3]; 73 | enet_uint16 peerID; 74 | enet_uint16 sentTime; 75 | } ENET_PACKED ENetProtocolHeaderUbisoft; 76 | 77 | typedef struct _ENetProtocolCommandHeader 78 | { 79 | enet_uint8 command; 80 | enet_uint8 channelID; 81 | enet_uint16 reliableSequenceNumber; 82 | } ENET_PACKED ENetProtocolCommandHeader; 83 | 84 | typedef struct _ENetProtocolAcknowledge 85 | { 86 | ENetProtocolCommandHeader header; 87 | enet_uint16 receivedReliableSequenceNumber; 88 | enet_uint16 receivedSentTime; 89 | } ENET_PACKED ENetProtocolAcknowledge; 90 | 91 | typedef struct _ENetProtocolConnect 92 | { 93 | ENetProtocolCommandHeader header; 94 | enet_uint16 outgoingPeerID; 95 | enet_uint8 incomingSessionID; 96 | enet_uint8 outgoingSessionID; 97 | enet_uint32 mtu; 98 | enet_uint32 windowSize; 99 | enet_uint32 channelCount; 100 | enet_uint32 incomingBandwidth; 101 | enet_uint32 outgoingBandwidth; 102 | enet_uint32 packetThrottleInterval; 103 | enet_uint32 packetThrottleAcceleration; 104 | enet_uint32 packetThrottleDeceleration; 105 | enet_uint32 connectID; 106 | enet_uint32 data; 107 | } ENET_PACKED ENetProtocolConnect; 108 | 109 | typedef struct _ENetProtocolVerifyConnect 110 | { 111 | ENetProtocolCommandHeader header; 112 | enet_uint16 outgoingPeerID; 113 | enet_uint8 incomingSessionID; 114 | enet_uint8 outgoingSessionID; 115 | enet_uint32 mtu; 116 | enet_uint32 windowSize; 117 | enet_uint32 channelCount; 118 | enet_uint32 incomingBandwidth; 119 | enet_uint32 outgoingBandwidth; 120 | enet_uint32 packetThrottleInterval; 121 | enet_uint32 packetThrottleAcceleration; 122 | enet_uint32 packetThrottleDeceleration; 123 | enet_uint32 connectID; 124 | } ENET_PACKED ENetProtocolVerifyConnect; 125 | 126 | typedef struct _ENetProtocolBandwidthLimit 127 | { 128 | ENetProtocolCommandHeader header; 129 | enet_uint32 incomingBandwidth; 130 | enet_uint32 outgoingBandwidth; 131 | } ENET_PACKED ENetProtocolBandwidthLimit; 132 | 133 | typedef struct _ENetProtocolThrottleConfigure 134 | { 135 | ENetProtocolCommandHeader header; 136 | enet_uint32 packetThrottleInterval; 137 | enet_uint32 packetThrottleAcceleration; 138 | enet_uint32 packetThrottleDeceleration; 139 | } ENET_PACKED ENetProtocolThrottleConfigure; 140 | 141 | typedef struct _ENetProtocolDisconnect 142 | { 143 | ENetProtocolCommandHeader header; 144 | enet_uint32 data; 145 | } ENET_PACKED ENetProtocolDisconnect; 146 | 147 | typedef struct _ENetProtocolPing 148 | { 149 | ENetProtocolCommandHeader header; 150 | } ENET_PACKED ENetProtocolPing; 151 | 152 | typedef struct _ENetProtocolSendReliable 153 | { 154 | ENetProtocolCommandHeader header; 155 | enet_uint16 dataLength; 156 | } ENET_PACKED ENetProtocolSendReliable; 157 | 158 | typedef struct _ENetProtocolSendUnreliable 159 | { 160 | ENetProtocolCommandHeader header; 161 | enet_uint16 unreliableSequenceNumber; 162 | enet_uint16 dataLength; 163 | } ENET_PACKED ENetProtocolSendUnreliable; 164 | 165 | typedef struct _ENetProtocolSendUnsequenced 166 | { 167 | ENetProtocolCommandHeader header; 168 | enet_uint16 unsequencedGroup; 169 | enet_uint16 dataLength; 170 | } ENET_PACKED ENetProtocolSendUnsequenced; 171 | 172 | typedef struct _ENetProtocolSendFragment 173 | { 174 | ENetProtocolCommandHeader header; 175 | enet_uint16 startSequenceNumber; 176 | enet_uint16 dataLength; 177 | enet_uint32 fragmentCount; 178 | enet_uint32 fragmentNumber; 179 | enet_uint32 totalLength; 180 | enet_uint32 fragmentOffset; 181 | } ENET_PACKED ENetProtocolSendFragment; 182 | 183 | typedef union _ENetProtocol 184 | { 185 | ENetProtocolCommandHeader header; 186 | ENetProtocolAcknowledge acknowledge; 187 | ENetProtocolConnect connect; 188 | ENetProtocolVerifyConnect verifyConnect; 189 | ENetProtocolDisconnect disconnect; 190 | ENetProtocolPing ping; 191 | ENetProtocolSendReliable sendReliable; 192 | ENetProtocolSendUnreliable sendUnreliable; 193 | ENetProtocolSendUnsequenced sendUnsequenced; 194 | ENetProtocolSendFragment sendFragment; 195 | ENetProtocolBandwidthLimit bandwidthLimit; 196 | ENetProtocolThrottleConfigure throttleConfigure; 197 | } ENET_PACKED ENetProtocol; 198 | 199 | #ifdef _MSC_VER 200 | #pragma pack(pop) 201 | #endif 202 | 203 | #endif /* __ENET_PROTOCOL_H__ */ 204 | 205 | -------------------------------------------------------------------------------- /CPPBot/enet/include/time2.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file time.h 3 | @brief ENet time constants and macros 4 | */ 5 | #ifndef __ENET_TIME_H__ 6 | #define __ENET_TIME_H__ 7 | 8 | #define ENET_TIME_OVERFLOW 86400000 9 | 10 | #define ENET_TIME_LESS(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW) 11 | #define ENET_TIME_GREATER(a, b) ((b) - (a) >= ENET_TIME_OVERFLOW) 12 | #define ENET_TIME_LESS_EQUAL(a, b) (! ENET_TIME_GREATER (a, b)) 13 | #define ENET_TIME_GREATER_EQUAL(a, b) (! ENET_TIME_LESS (a, b)) 14 | 15 | #define ENET_TIME_DIFFERENCE(a, b) ((a) - (b) >= ENET_TIME_OVERFLOW ? (b) - (a) : (a) - (b)) 16 | 17 | #endif /* __ENET_TIME_H__ */ 18 | 19 | -------------------------------------------------------------------------------- /CPPBot/enet/include/types.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file types.h 3 | @brief type definitions for ENet 4 | */ 5 | #ifndef __ENET_TYPES_H__ 6 | #define __ENET_TYPES_H__ 7 | 8 | typedef unsigned char enet_uint8; /**< unsigned 8-bit type */ 9 | typedef unsigned short enet_uint16; /**< unsigned 16-bit type */ 10 | typedef unsigned int enet_uint32; /**< unsigned 32-bit type */ 11 | 12 | #endif /* __ENET_TYPES_H__ */ 13 | 14 | -------------------------------------------------------------------------------- /CPPBot/enet/include/unix.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file unix.h 3 | @brief ENet Unix header 4 | */ 5 | #ifndef _WIN32 6 | #ifndef __ENET_UNIX_H__ 7 | #define __ENET_UNIX_H__ 8 | 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | 17 | #ifdef MSG_MAXIOVLEN 18 | #define ENET_BUFFER_MAXIMUM MSG_MAXIOVLEN 19 | #endif 20 | 21 | typedef int ENetSocket; 22 | 23 | #define ENET_SOCKET_NULL -1 24 | 25 | #define ENET_HOST_TO_NET_16(value) (htons (value)) /**< macro that converts host to net byte-order of a 16-bit value */ 26 | #define ENET_HOST_TO_NET_32(value) (htonl (value)) /**< macro that converts host to net byte-order of a 32-bit value */ 27 | 28 | #define ENET_NET_TO_HOST_16(value) (ntohs (value)) /**< macro that converts net to host byte-order of a 16-bit value */ 29 | #define ENET_NET_TO_HOST_32(value) (ntohl (value)) /**< macro that converts net to host byte-order of a 32-bit value */ 30 | 31 | typedef struct 32 | { 33 | void * data; 34 | size_t dataLength; 35 | } ENetBuffer; 36 | 37 | #define ENET_CALLBACK 38 | 39 | #define ENET_API extern 40 | 41 | typedef fd_set ENetSocketSet; 42 | 43 | #define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset)) 44 | #define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset)) 45 | #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset)) 46 | #define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset)) 47 | 48 | #endif /* __ENET_UNIX_H__ */ 49 | #endif -------------------------------------------------------------------------------- /CPPBot/enet/include/utility.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file utility.h 3 | @brief ENet utility header 4 | */ 5 | #ifndef __ENET_UTILITY_H__ 6 | #define __ENET_UTILITY_H__ 7 | 8 | #define ENET_MAX(x, y) ((x) > (y) ? (x) : (y)) 9 | #define ENET_MIN(x, y) ((x) < (y) ? (x) : (y)) 10 | 11 | #endif /* __ENET_UTILITY_H__ */ 12 | 13 | -------------------------------------------------------------------------------- /CPPBot/enet/include/win32.h: -------------------------------------------------------------------------------- 1 | /** 2 | @file win32.h 3 | @brief ENet Win32 header 4 | */ 5 | #ifdef _WIN32 6 | #ifndef __ENET_WIN32_H__ 7 | #define __ENET_WIN32_H__ 8 | 9 | #ifdef _MSC_VER 10 | #ifdef ENET_BUILDING_LIB 11 | #pragma warning (disable: 4267) // size_t to int conversion 12 | #pragma warning (disable: 4244) // 64bit to 32bit int 13 | #pragma warning (disable: 4018) // signed/unsigned mismatch 14 | #pragma warning (disable: 4146) // unary minus operator applied to unsigned type 15 | #endif 16 | #endif 17 | 18 | #include 19 | #include 20 | #include 21 | 22 | typedef SOCKET ENetSocket; 23 | 24 | #define ENET_SOCKET_NULL INVALID_SOCKET 25 | 26 | #define ENET_HOST_TO_NET_16(value) (htons (value)) 27 | #define ENET_HOST_TO_NET_32(value) (htonl (value)) 28 | 29 | #define ENET_NET_TO_HOST_16(value) (ntohs (value)) 30 | #define ENET_NET_TO_HOST_32(value) (ntohl (value)) 31 | 32 | typedef struct 33 | { 34 | size_t dataLength; 35 | void * data; 36 | } ENetBuffer; 37 | 38 | #define ENET_CALLBACK __cdecl 39 | 40 | #ifdef ENET_DLL 41 | #ifdef ENET_BUILDING_LIB 42 | #define ENET_API __declspec( dllexport ) 43 | #else 44 | #define ENET_API __declspec( dllimport ) 45 | #endif /* ENET_BUILDING_LIB */ 46 | #else /* !ENET_DLL */ 47 | #define ENET_API extern 48 | #endif /* ENET_DLL */ 49 | 50 | typedef fd_set ENetSocketSet; 51 | 52 | #define ENET_SOCKETSET_EMPTY(sockset) FD_ZERO (& (sockset)) 53 | #define ENET_SOCKETSET_ADD(sockset, socket) FD_SET (socket, & (sockset)) 54 | #define ENET_SOCKETSET_REMOVE(sockset, socket) FD_CLR (socket, & (sockset)) 55 | #define ENET_SOCKETSET_CHECK(sockset, socket) FD_ISSET (socket, & (sockset)) 56 | 57 | #endif /* __ENET_WIN32_H__ */ 58 | #endif -------------------------------------------------------------------------------- /CPPBot/enet/list.c: -------------------------------------------------------------------------------- 1 | /** 2 | @file list.c 3 | @brief ENet linked list functions 4 | */ 5 | #define ENET_BUILDING_LIB 1 6 | #include "include/enet.h" 7 | 8 | /** 9 | @defgroup list ENet linked list utility functions 10 | @ingroup private 11 | @{ 12 | */ 13 | void 14 | enet_list_clear (ENetList * list) 15 | { 16 | list -> sentinel.next = & list -> sentinel; 17 | list -> sentinel.previous = & list -> sentinel; 18 | } 19 | 20 | ENetListIterator 21 | enet_list_insert (ENetListIterator position, void * data) 22 | { 23 | ENetListIterator result = (ENetListIterator) data; 24 | 25 | result -> previous = position -> previous; 26 | result -> next = position; 27 | 28 | result -> previous -> next = result; 29 | position -> previous = result; 30 | 31 | return result; 32 | } 33 | 34 | void * 35 | enet_list_remove (ENetListIterator position) 36 | { 37 | position -> previous -> next = position -> next; 38 | position -> next -> previous = position -> previous; 39 | 40 | return position; 41 | } 42 | 43 | ENetListIterator 44 | enet_list_move (ENetListIterator position, void * dataFirst, void * dataLast) 45 | { 46 | ENetListIterator first = (ENetListIterator) dataFirst, 47 | last = (ENetListIterator) dataLast; 48 | 49 | first -> previous -> next = last -> next; 50 | last -> next -> previous = first -> previous; 51 | 52 | first -> previous = position -> previous; 53 | last -> next = position; 54 | 55 | first -> previous -> next = first; 56 | position -> previous = last; 57 | 58 | return first; 59 | } 60 | 61 | size_t 62 | enet_list_size (ENetList * list) 63 | { 64 | size_t size = 0; 65 | ENetListIterator position; 66 | 67 | for (position = enet_list_begin (list); 68 | position != enet_list_end (list); 69 | position = enet_list_next (position)) 70 | ++ size; 71 | 72 | return size; 73 | } 74 | 75 | /** @} */ 76 | -------------------------------------------------------------------------------- /CPPBot/enet/packet.c: -------------------------------------------------------------------------------- 1 | /** 2 | @file packet.c 3 | @brief ENet packet management functions 4 | */ 5 | #include 6 | #define ENET_BUILDING_LIB 1 7 | #include "include/enet.h" 8 | 9 | /** @defgroup Packet ENet packet functions 10 | @{ 11 | */ 12 | 13 | /** Creates a packet that may be sent to a peer. 14 | @param data initial contents of the packet's data; the packet's data will remain uninitialized if data is NULL. 15 | @param dataLength size of the data allocated for this packet 16 | @param flags flags for this packet as described for the ENetPacket structure. 17 | @returns the packet on success, NULL on failure 18 | */ 19 | ENetPacket * 20 | enet_packet_create (const void * data, size_t dataLength, enet_uint32 flags) 21 | { 22 | ENetPacket * packet = (ENetPacket *) enet_malloc (sizeof (ENetPacket)); 23 | if (packet == NULL) 24 | return NULL; 25 | 26 | if (flags & ENET_PACKET_FLAG_NO_ALLOCATE) 27 | packet -> data = (enet_uint8 *) data; 28 | else 29 | if (dataLength <= 0) 30 | packet -> data = NULL; 31 | else 32 | { 33 | packet -> data = (enet_uint8 *) enet_malloc (dataLength); 34 | if (packet -> data == NULL) 35 | { 36 | enet_free (packet); 37 | return NULL; 38 | } 39 | 40 | if (data != NULL) 41 | memcpy (packet -> data, data, dataLength); 42 | } 43 | 44 | packet -> referenceCount = 0; 45 | packet -> flags = flags; 46 | packet -> dataLength = dataLength; 47 | packet -> freeCallback = NULL; 48 | packet -> userData = NULL; 49 | 50 | return packet; 51 | } 52 | 53 | /** Destroys the packet and deallocates its data. 54 | @param packet packet to be destroyed 55 | */ 56 | void 57 | enet_packet_destroy (ENetPacket * packet) 58 | { 59 | if (packet == NULL) 60 | return; 61 | 62 | if (packet -> freeCallback != NULL) 63 | (* packet -> freeCallback) (packet); 64 | if (! (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE) && 65 | packet -> data != NULL) 66 | enet_free (packet -> data); 67 | enet_free (packet); 68 | } 69 | 70 | /** Attempts to resize the data in the packet to length specified in the 71 | dataLength parameter 72 | @param packet packet to resize 73 | @param dataLength new size for the packet data 74 | @returns 0 on success, < 0 on failure 75 | */ 76 | int 77 | enet_packet_resize (ENetPacket * packet, size_t dataLength) 78 | { 79 | enet_uint8 * newData; 80 | 81 | if (dataLength <= packet -> dataLength || (packet -> flags & ENET_PACKET_FLAG_NO_ALLOCATE)) 82 | { 83 | packet -> dataLength = dataLength; 84 | 85 | return 0; 86 | } 87 | 88 | newData = (enet_uint8 *) enet_malloc (dataLength); 89 | if (newData == NULL) 90 | return -1; 91 | 92 | memcpy (newData, packet -> data, packet -> dataLength); 93 | enet_free (packet -> data); 94 | 95 | packet -> data = newData; 96 | packet -> dataLength = dataLength; 97 | 98 | return 0; 99 | } 100 | 101 | static int initializedCRC32 = 0; 102 | static enet_uint32 crcTable [256]; 103 | 104 | static enet_uint32 105 | reflect_crc (int val, int bits) 106 | { 107 | int result = 0, bit; 108 | 109 | for (bit = 0; bit < bits; bit ++) 110 | { 111 | if(val & 1) result |= 1 << (bits - 1 - bit); 112 | val >>= 1; 113 | } 114 | 115 | return result; 116 | } 117 | 118 | static void 119 | initialize_crc32 (void) 120 | { 121 | int byte; 122 | 123 | for (byte = 0; byte < 256; ++ byte) 124 | { 125 | enet_uint32 crc = reflect_crc (byte, 8) << 24; 126 | int offset; 127 | 128 | for(offset = 0; offset < 8; ++ offset) 129 | { 130 | if (crc & 0x80000000) 131 | crc = (crc << 1) ^ 0x04c11db7; 132 | else 133 | crc <<= 1; 134 | } 135 | 136 | crcTable [byte] = reflect_crc (crc, 32); 137 | } 138 | 139 | initializedCRC32 = 1; 140 | } 141 | 142 | enet_uint32 143 | enet_crc32 (const ENetBuffer * buffers, size_t bufferCount) 144 | { 145 | enet_uint32 crc = 0xFFFFFFFF; 146 | 147 | if (! initializedCRC32) initialize_crc32 (); 148 | 149 | while (bufferCount -- > 0) 150 | { 151 | const enet_uint8 * data = (const enet_uint8 *) buffers -> data, 152 | * dataEnd = & data [buffers -> dataLength]; 153 | 154 | while (data < dataEnd) 155 | { 156 | crc = (crc >> 8) ^ crcTable [(crc & 0xFF) ^ *data++]; 157 | } 158 | 159 | ++ buffers; 160 | } 161 | 162 | return ENET_HOST_TO_NET_32 (~ crc); 163 | } 164 | 165 | /** @} */ 166 | -------------------------------------------------------------------------------- /CPPBot/enet/unix.c: -------------------------------------------------------------------------------- 1 | /** 2 | @file unix.c 3 | @brief ENet Unix system specific functions 4 | */ 5 | #ifndef _WIN32 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | #define ENET_BUILDING_LIB 1 19 | #include "include/enet.h" 20 | 21 | #ifdef __APPLE__ 22 | #ifdef HAS_POLL 23 | #undef HAS_POLL 24 | #endif 25 | #ifndef HAS_FCNTL 26 | #define HAS_FCNTL 1 27 | #endif 28 | #ifndef HAS_INET_PTON 29 | #define HAS_INET_PTON 1 30 | #endif 31 | #ifndef HAS_INET_NTOP 32 | #define HAS_INET_NTOP 1 33 | #endif 34 | #ifndef HAS_MSGHDR_FLAGS 35 | #define HAS_MSGHDR_FLAGS 1 36 | #endif 37 | #ifndef HAS_SOCKLEN_T 38 | #define HAS_SOCKLEN_T 1 39 | #endif 40 | #ifndef HAS_GETADDRINFO 41 | #define HAS_GETADDRINFO 1 42 | #endif 43 | #ifndef HAS_GETNAMEINFO 44 | #define HAS_GETNAMEINFO 1 45 | #endif 46 | #endif 47 | 48 | #ifdef HAS_FCNTL 49 | #include 50 | #endif 51 | 52 | #ifdef HAS_POLL 53 | #include 54 | #endif 55 | 56 | #ifndef MSG_NOSIGNAL 57 | #define MSG_NOSIGNAL 0 58 | #endif 59 | 60 | static enet_uint32 timeBase = 0; 61 | 62 | int 63 | enet_initialize (void) 64 | { 65 | return 0; 66 | } 67 | 68 | void 69 | enet_deinitialize (void) 70 | { 71 | } 72 | 73 | enet_uint32 74 | enet_host_random_seed (void) 75 | { 76 | return (enet_uint32) time (NULL); 77 | } 78 | 79 | enet_uint32 80 | enet_time_get (void) 81 | { 82 | struct timeval timeVal; 83 | 84 | gettimeofday (& timeVal, NULL); 85 | 86 | return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase; 87 | } 88 | 89 | void 90 | enet_time_set (enet_uint32 newTimeBase) 91 | { 92 | struct timeval timeVal; 93 | 94 | gettimeofday (& timeVal, NULL); 95 | 96 | timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase; 97 | } 98 | 99 | int 100 | enet_address_set_host_ip (ENetAddress * address, const char * name) 101 | { 102 | #ifdef HAS_INET_PTON 103 | if (! inet_pton (AF_INET, name, & address -> host)) 104 | #else 105 | if (! inet_aton (name, (struct in_addr *) & address -> host)) 106 | #endif 107 | return -1; 108 | 109 | return 0; 110 | } 111 | 112 | int 113 | enet_address_set_host (ENetAddress * address, const char * name) 114 | { 115 | #ifdef HAS_GETADDRINFO 116 | struct addrinfo hints, * resultList = NULL, * result = NULL; 117 | 118 | memset (& hints, 0, sizeof (hints)); 119 | hints.ai_family = AF_INET; 120 | 121 | if (getaddrinfo (name, NULL, NULL, & resultList) != 0) 122 | return -1; 123 | 124 | for (result = resultList; result != NULL; result = result -> ai_next) 125 | { 126 | if (result -> ai_family == AF_INET && result -> ai_addr != NULL && result -> ai_addrlen >= sizeof (struct sockaddr_in)) 127 | { 128 | struct sockaddr_in * sin = (struct sockaddr_in *) result -> ai_addr; 129 | 130 | address -> host = sin -> sin_addr.s_addr; 131 | 132 | freeaddrinfo (resultList); 133 | 134 | return 0; 135 | } 136 | } 137 | 138 | if (resultList != NULL) 139 | freeaddrinfo (resultList); 140 | #else 141 | struct hostent * hostEntry = NULL; 142 | #ifdef HAS_GETHOSTBYNAME_R 143 | struct hostent hostData; 144 | char buffer [2048]; 145 | int errnum; 146 | 147 | #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) 148 | gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum); 149 | #else 150 | hostEntry = gethostbyname_r (name, & hostData, buffer, sizeof (buffer), & errnum); 151 | #endif 152 | #else 153 | hostEntry = gethostbyname (name); 154 | #endif 155 | 156 | if (hostEntry != NULL && hostEntry -> h_addrtype == AF_INET) 157 | { 158 | address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0]; 159 | 160 | return 0; 161 | } 162 | #endif 163 | 164 | return enet_address_set_host_ip (address, name); 165 | } 166 | 167 | int 168 | enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength) 169 | { 170 | #ifdef HAS_INET_NTOP 171 | if (inet_ntop (AF_INET, & address -> host, name, nameLength) == NULL) 172 | #else 173 | char * addr = inet_ntoa (* (struct in_addr *) & address -> host); 174 | if (addr != NULL) 175 | { 176 | size_t addrLen = strlen(addr); 177 | if (addrLen >= nameLength) 178 | return -1; 179 | memcpy (name, addr, addrLen + 1); 180 | } 181 | else 182 | #endif 183 | return -1; 184 | return 0; 185 | } 186 | 187 | int 188 | enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength) 189 | { 190 | #ifdef HAS_GETNAMEINFO 191 | struct sockaddr_in sin; 192 | int err; 193 | 194 | memset (& sin, 0, sizeof (struct sockaddr_in)); 195 | 196 | sin.sin_family = AF_INET; 197 | sin.sin_port = ENET_HOST_TO_NET_16 (address -> port); 198 | sin.sin_addr.s_addr = address -> host; 199 | 200 | err = getnameinfo ((struct sockaddr *) & sin, sizeof (sin), name, nameLength, NULL, 0, NI_NAMEREQD); 201 | if (! err) 202 | { 203 | if (name != NULL && nameLength > 0 && ! memchr (name, '\0', nameLength)) 204 | return -1; 205 | return 0; 206 | } 207 | if (err != EAI_NONAME) 208 | return -1; 209 | #else 210 | struct in_addr in; 211 | struct hostent * hostEntry = NULL; 212 | #ifdef HAS_GETHOSTBYADDR_R 213 | struct hostent hostData; 214 | char buffer [2048]; 215 | int errnum; 216 | 217 | in.s_addr = address -> host; 218 | 219 | #if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) 220 | gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & hostEntry, & errnum); 221 | #else 222 | hostEntry = gethostbyaddr_r ((char *) & in, sizeof (struct in_addr), AF_INET, & hostData, buffer, sizeof (buffer), & errnum); 223 | #endif 224 | #else 225 | in.s_addr = address -> host; 226 | 227 | hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET); 228 | #endif 229 | 230 | if (hostEntry != NULL) 231 | { 232 | size_t hostLen = strlen (hostEntry -> h_name); 233 | if (hostLen >= nameLength) 234 | return -1; 235 | memcpy (name, hostEntry -> h_name, hostLen + 1); 236 | return 0; 237 | } 238 | #endif 239 | 240 | return enet_address_get_host_ip (address, name, nameLength); 241 | } 242 | 243 | int 244 | enet_socket_bind (ENetSocket socket, const ENetAddress * address) 245 | { 246 | struct sockaddr_in sin; 247 | 248 | memset (& sin, 0, sizeof (struct sockaddr_in)); 249 | 250 | sin.sin_family = AF_INET; 251 | 252 | if (address != NULL) 253 | { 254 | sin.sin_port = ENET_HOST_TO_NET_16 (address -> port); 255 | sin.sin_addr.s_addr = address -> host; 256 | } 257 | else 258 | { 259 | sin.sin_port = 0; 260 | sin.sin_addr.s_addr = INADDR_ANY; 261 | } 262 | 263 | return bind (socket, 264 | (struct sockaddr *) & sin, 265 | sizeof (struct sockaddr_in)); 266 | } 267 | 268 | int 269 | enet_socket_get_address (ENetSocket socket, ENetAddress * address) 270 | { 271 | struct sockaddr_in sin; 272 | socklen_t sinLength = sizeof (struct sockaddr_in); 273 | 274 | if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1) 275 | return -1; 276 | 277 | address -> host = (enet_uint32) sin.sin_addr.s_addr; 278 | address -> port = ENET_NET_TO_HOST_16 (sin.sin_port); 279 | 280 | return 0; 281 | } 282 | 283 | int 284 | enet_socket_listen (ENetSocket socket, int backlog) 285 | { 286 | return listen (socket, backlog < 0 ? SOMAXCONN : backlog); 287 | } 288 | 289 | ENetSocket 290 | enet_socket_create (ENetSocketType type) 291 | { 292 | return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0); 293 | } 294 | 295 | int 296 | enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value) 297 | { 298 | int result = -1; 299 | switch (option) 300 | { 301 | case ENET_SOCKOPT_NONBLOCK: 302 | #ifdef HAS_FCNTL 303 | result = fcntl (socket, F_SETFL, (value ? O_NONBLOCK : 0) | (fcntl (socket, F_GETFL) & ~O_NONBLOCK)); 304 | #else 305 | result = ioctl (socket, FIONBIO, & value); 306 | #endif 307 | break; 308 | 309 | case ENET_SOCKOPT_BROADCAST: 310 | result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int)); 311 | break; 312 | 313 | case ENET_SOCKOPT_REUSEADDR: 314 | result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int)); 315 | break; 316 | 317 | case ENET_SOCKOPT_RCVBUF: 318 | result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int)); 319 | break; 320 | 321 | case ENET_SOCKOPT_SNDBUF: 322 | result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int)); 323 | break; 324 | 325 | case ENET_SOCKOPT_RCVTIMEO: 326 | { 327 | struct timeval timeVal; 328 | timeVal.tv_sec = value / 1000; 329 | timeVal.tv_usec = (value % 1000) * 1000; 330 | result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & timeVal, sizeof (struct timeval)); 331 | break; 332 | } 333 | 334 | case ENET_SOCKOPT_SNDTIMEO: 335 | { 336 | struct timeval timeVal; 337 | timeVal.tv_sec = value / 1000; 338 | timeVal.tv_usec = (value % 1000) * 1000; 339 | result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & timeVal, sizeof (struct timeval)); 340 | break; 341 | } 342 | 343 | case ENET_SOCKOPT_NODELAY: 344 | result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int)); 345 | break; 346 | 347 | default: 348 | break; 349 | } 350 | return result == -1 ? -1 : 0; 351 | } 352 | 353 | int 354 | enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value) 355 | { 356 | int result = -1; 357 | socklen_t len; 358 | switch (option) 359 | { 360 | case ENET_SOCKOPT_ERROR: 361 | len = sizeof (int); 362 | result = getsockopt (socket, SOL_SOCKET, SO_ERROR, value, & len); 363 | break; 364 | 365 | default: 366 | break; 367 | } 368 | return result == -1 ? -1 : 0; 369 | } 370 | 371 | int 372 | enet_socket_connect (ENetSocket socket, const ENetAddress * address) 373 | { 374 | struct sockaddr_in sin; 375 | int result; 376 | 377 | memset (& sin, 0, sizeof (struct sockaddr_in)); 378 | 379 | sin.sin_family = AF_INET; 380 | sin.sin_port = ENET_HOST_TO_NET_16 (address -> port); 381 | sin.sin_addr.s_addr = address -> host; 382 | 383 | result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in)); 384 | if (result == -1 && errno == EINPROGRESS) 385 | return 0; 386 | 387 | return result; 388 | } 389 | 390 | ENetSocket 391 | enet_socket_accept (ENetSocket socket, ENetAddress * address) 392 | { 393 | int result; 394 | struct sockaddr_in sin; 395 | socklen_t sinLength = sizeof (struct sockaddr_in); 396 | 397 | result = accept (socket, 398 | address != NULL ? (struct sockaddr *) & sin : NULL, 399 | address != NULL ? & sinLength : NULL); 400 | 401 | if (result == -1) 402 | return ENET_SOCKET_NULL; 403 | 404 | if (address != NULL) 405 | { 406 | address -> host = (enet_uint32) sin.sin_addr.s_addr; 407 | address -> port = ENET_NET_TO_HOST_16 (sin.sin_port); 408 | } 409 | 410 | return result; 411 | } 412 | 413 | int 414 | enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how) 415 | { 416 | return shutdown (socket, (int) how); 417 | } 418 | 419 | void 420 | enet_socket_destroy (ENetSocket socket) 421 | { 422 | if (socket != -1) 423 | close (socket); 424 | } 425 | 426 | int 427 | enet_socket_send (ENetSocket socket, 428 | const ENetAddress * address, 429 | const ENetBuffer * buffers, 430 | size_t bufferCount) 431 | { 432 | struct msghdr msgHdr; 433 | struct sockaddr_in sin; 434 | int sentLength; 435 | 436 | memset (& msgHdr, 0, sizeof (struct msghdr)); 437 | 438 | if (address != NULL) 439 | { 440 | memset (& sin, 0, sizeof (struct sockaddr_in)); 441 | 442 | sin.sin_family = AF_INET; 443 | sin.sin_port = ENET_HOST_TO_NET_16 (address -> port); 444 | sin.sin_addr.s_addr = address -> host; 445 | 446 | msgHdr.msg_name = & sin; 447 | msgHdr.msg_namelen = sizeof (struct sockaddr_in); 448 | } 449 | 450 | msgHdr.msg_iov = (struct iovec *) buffers; 451 | msgHdr.msg_iovlen = bufferCount; 452 | 453 | sentLength = sendmsg (socket, & msgHdr, MSG_NOSIGNAL); 454 | 455 | if (sentLength == -1) 456 | { 457 | if (errno == EWOULDBLOCK) 458 | return 0; 459 | 460 | return -1; 461 | } 462 | 463 | return sentLength; 464 | } 465 | 466 | int 467 | enet_socket_receive (ENetSocket socket, 468 | ENetAddress * address, 469 | ENetBuffer * buffers, 470 | size_t bufferCount) 471 | { 472 | struct msghdr msgHdr; 473 | struct sockaddr_in sin; 474 | int recvLength; 475 | 476 | memset (& msgHdr, 0, sizeof (struct msghdr)); 477 | 478 | if (address != NULL) 479 | { 480 | msgHdr.msg_name = & sin; 481 | msgHdr.msg_namelen = sizeof (struct sockaddr_in); 482 | } 483 | 484 | msgHdr.msg_iov = (struct iovec *) buffers; 485 | msgHdr.msg_iovlen = bufferCount; 486 | 487 | recvLength = recvmsg (socket, & msgHdr, MSG_NOSIGNAL); 488 | 489 | if (recvLength == -1) 490 | { 491 | if (errno == EWOULDBLOCK) 492 | return 0; 493 | 494 | return -1; 495 | } 496 | 497 | #ifdef HAS_MSGHDR_FLAGS 498 | if (msgHdr.msg_flags & MSG_TRUNC) 499 | return -1; 500 | #endif 501 | 502 | if (address != NULL) 503 | { 504 | address -> host = (enet_uint32) sin.sin_addr.s_addr; 505 | address -> port = ENET_NET_TO_HOST_16 (sin.sin_port); 506 | } 507 | 508 | return recvLength; 509 | } 510 | 511 | int 512 | enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout) 513 | { 514 | struct timeval timeVal; 515 | 516 | timeVal.tv_sec = timeout / 1000; 517 | timeVal.tv_usec = (timeout % 1000) * 1000; 518 | 519 | return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal); 520 | } 521 | 522 | int 523 | enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout) 524 | { 525 | #ifdef HAS_POLL 526 | struct pollfd pollSocket; 527 | int pollCount; 528 | 529 | pollSocket.fd = socket; 530 | pollSocket.events = 0; 531 | 532 | if (* condition & ENET_SOCKET_WAIT_SEND) 533 | pollSocket.events |= POLLOUT; 534 | 535 | if (* condition & ENET_SOCKET_WAIT_RECEIVE) 536 | pollSocket.events |= POLLIN; 537 | 538 | pollCount = poll (& pollSocket, 1, timeout); 539 | 540 | if (pollCount < 0) 541 | { 542 | if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT) 543 | { 544 | * condition = ENET_SOCKET_WAIT_INTERRUPT; 545 | 546 | return 0; 547 | } 548 | 549 | return -1; 550 | } 551 | 552 | * condition = ENET_SOCKET_WAIT_NONE; 553 | 554 | if (pollCount == 0) 555 | return 0; 556 | 557 | if (pollSocket.revents & POLLOUT) 558 | * condition |= ENET_SOCKET_WAIT_SEND; 559 | 560 | if (pollSocket.revents & POLLIN) 561 | * condition |= ENET_SOCKET_WAIT_RECEIVE; 562 | 563 | return 0; 564 | #else 565 | fd_set readSet, writeSet; 566 | struct timeval timeVal; 567 | int selectCount; 568 | 569 | timeVal.tv_sec = timeout / 1000; 570 | timeVal.tv_usec = (timeout % 1000) * 1000; 571 | 572 | FD_ZERO (& readSet); 573 | FD_ZERO (& writeSet); 574 | 575 | if (* condition & ENET_SOCKET_WAIT_SEND) 576 | FD_SET (socket, & writeSet); 577 | 578 | if (* condition & ENET_SOCKET_WAIT_RECEIVE) 579 | FD_SET (socket, & readSet); 580 | 581 | selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal); 582 | 583 | if (selectCount < 0) 584 | { 585 | if (errno == EINTR && * condition & ENET_SOCKET_WAIT_INTERRUPT) 586 | { 587 | * condition = ENET_SOCKET_WAIT_INTERRUPT; 588 | 589 | return 0; 590 | } 591 | 592 | return -1; 593 | } 594 | 595 | * condition = ENET_SOCKET_WAIT_NONE; 596 | 597 | if (selectCount == 0) 598 | return 0; 599 | 600 | if (FD_ISSET (socket, & writeSet)) 601 | * condition |= ENET_SOCKET_WAIT_SEND; 602 | 603 | if (FD_ISSET (socket, & readSet)) 604 | * condition |= ENET_SOCKET_WAIT_RECEIVE; 605 | 606 | return 0; 607 | #endif 608 | } 609 | 610 | #endif 611 | 612 | -------------------------------------------------------------------------------- /CPPBot/enet/win32.c: -------------------------------------------------------------------------------- 1 | /** 2 | @file win32.c 3 | @brief ENet Win32 system specific functions 4 | */ 5 | #ifdef _WIN32 6 | 7 | #define ENET_BUILDING_LIB 1 8 | #include "include/enet.h" 9 | #include 10 | #include 11 | 12 | #pragma warning(disable : 4996) 13 | 14 | static enet_uint32 timeBase = 0; 15 | 16 | int 17 | enet_initialize (void) 18 | { 19 | WORD versionRequested = MAKEWORD (1, 1); 20 | WSADATA wsaData; 21 | 22 | if (WSAStartup (versionRequested, & wsaData)) 23 | return -1; 24 | 25 | if (LOBYTE (wsaData.wVersion) != 1|| 26 | HIBYTE (wsaData.wVersion) != 1) 27 | { 28 | WSACleanup (); 29 | 30 | return -1; 31 | } 32 | 33 | timeBeginPeriod (1); 34 | 35 | return 0; 36 | } 37 | 38 | void 39 | enet_deinitialize (void) 40 | { 41 | timeEndPeriod (1); 42 | 43 | WSACleanup (); 44 | } 45 | 46 | enet_uint32 47 | enet_host_random_seed (void) 48 | { 49 | return (enet_uint32) timeGetTime (); 50 | } 51 | 52 | enet_uint32 53 | enet_time_get (void) 54 | { 55 | return (enet_uint32) timeGetTime () - timeBase; 56 | } 57 | 58 | void 59 | enet_time_set (enet_uint32 newTimeBase) 60 | { 61 | timeBase = (enet_uint32) timeGetTime () - newTimeBase; 62 | } 63 | 64 | int 65 | enet_address_set_host_ip (ENetAddress * address, const char * name) 66 | { 67 | enet_uint8 vals [4] = { 0, 0, 0, 0 }; 68 | int i; 69 | 70 | for (i = 0; i < 4; ++ i) 71 | { 72 | const char * next = name + 1; 73 | if (* name != '0') 74 | { 75 | long val = strtol (name, (char **) & next, 10); 76 | if (val < 0 || val > 255 || next == name || next - name > 3) 77 | return -1; 78 | vals [i] = (enet_uint8) val; 79 | } 80 | 81 | if (* next != (i < 3 ? '.' : '\0')) 82 | return -1; 83 | name = next + 1; 84 | } 85 | 86 | memcpy (& address -> host, vals, sizeof (enet_uint32)); 87 | return 0; 88 | } 89 | 90 | int 91 | enet_address_set_host (ENetAddress * address, const char * name) 92 | { 93 | struct hostent * hostEntry; 94 | 95 | hostEntry = gethostbyname (name); 96 | if (hostEntry == NULL || 97 | hostEntry -> h_addrtype != AF_INET) 98 | return enet_address_set_host_ip (address, name); 99 | 100 | address -> host = * (enet_uint32 *) hostEntry -> h_addr_list [0]; 101 | 102 | return 0; 103 | } 104 | 105 | int 106 | enet_address_get_host_ip (const ENetAddress * address, char * name, size_t nameLength) 107 | { 108 | char * addr = inet_ntoa (* (struct in_addr *) & address -> host); 109 | if (addr == NULL) 110 | return -1; 111 | else 112 | { 113 | size_t addrLen = strlen(addr); 114 | if (addrLen >= nameLength) 115 | return -1; 116 | memcpy (name, addr, addrLen + 1); 117 | } 118 | return 0; 119 | } 120 | 121 | int 122 | enet_address_get_host (const ENetAddress * address, char * name, size_t nameLength) 123 | { 124 | struct in_addr in; 125 | struct hostent * hostEntry; 126 | 127 | in.s_addr = address -> host; 128 | 129 | hostEntry = gethostbyaddr ((char *) & in, sizeof (struct in_addr), AF_INET); 130 | if (hostEntry == NULL) 131 | return enet_address_get_host_ip (address, name, nameLength); 132 | else 133 | { 134 | size_t hostLen = strlen (hostEntry -> h_name); 135 | if (hostLen >= nameLength) 136 | return -1; 137 | memcpy (name, hostEntry -> h_name, hostLen + 1); 138 | } 139 | 140 | return 0; 141 | } 142 | 143 | int 144 | enet_socket_bind (ENetSocket socket, const ENetAddress * address) 145 | { 146 | struct sockaddr_in sin; 147 | 148 | memset (& sin, 0, sizeof (struct sockaddr_in)); 149 | 150 | sin.sin_family = AF_INET; 151 | 152 | if (address != NULL) 153 | { 154 | sin.sin_port = ENET_HOST_TO_NET_16 (address -> port); 155 | sin.sin_addr.s_addr = address -> host; 156 | } 157 | else 158 | { 159 | sin.sin_port = 0; 160 | sin.sin_addr.s_addr = INADDR_ANY; 161 | } 162 | 163 | return bind (socket, 164 | (struct sockaddr *) & sin, 165 | sizeof (struct sockaddr_in)) == SOCKET_ERROR ? -1 : 0; 166 | } 167 | 168 | int 169 | enet_socket_get_address (ENetSocket socket, ENetAddress * address) 170 | { 171 | struct sockaddr_in sin; 172 | int sinLength = sizeof (struct sockaddr_in); 173 | 174 | if (getsockname (socket, (struct sockaddr *) & sin, & sinLength) == -1) 175 | return -1; 176 | 177 | address -> host = (enet_uint32) sin.sin_addr.s_addr; 178 | address -> port = ENET_NET_TO_HOST_16 (sin.sin_port); 179 | 180 | return 0; 181 | } 182 | 183 | int 184 | enet_socket_listen (ENetSocket socket, int backlog) 185 | { 186 | return listen (socket, backlog < 0 ? SOMAXCONN : backlog) == SOCKET_ERROR ? -1 : 0; 187 | } 188 | 189 | ENetSocket 190 | enet_socket_create (ENetSocketType type) 191 | { 192 | return socket (PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0); 193 | } 194 | 195 | int 196 | enet_socket_set_option (ENetSocket socket, ENetSocketOption option, int value) 197 | { 198 | int result = SOCKET_ERROR; 199 | switch (option) 200 | { 201 | case ENET_SOCKOPT_NONBLOCK: 202 | { 203 | u_long nonBlocking = (u_long) value; 204 | result = ioctlsocket (socket, FIONBIO, & nonBlocking); 205 | break; 206 | } 207 | 208 | case ENET_SOCKOPT_BROADCAST: 209 | result = setsockopt (socket, SOL_SOCKET, SO_BROADCAST, (char *) & value, sizeof (int)); 210 | break; 211 | 212 | case ENET_SOCKOPT_REUSEADDR: 213 | result = setsockopt (socket, SOL_SOCKET, SO_REUSEADDR, (char *) & value, sizeof (int)); 214 | break; 215 | 216 | case ENET_SOCKOPT_RCVBUF: 217 | result = setsockopt (socket, SOL_SOCKET, SO_RCVBUF, (char *) & value, sizeof (int)); 218 | break; 219 | 220 | case ENET_SOCKOPT_SNDBUF: 221 | result = setsockopt (socket, SOL_SOCKET, SO_SNDBUF, (char *) & value, sizeof (int)); 222 | break; 223 | 224 | case ENET_SOCKOPT_RCVTIMEO: 225 | result = setsockopt (socket, SOL_SOCKET, SO_RCVTIMEO, (char *) & value, sizeof (int)); 226 | break; 227 | 228 | case ENET_SOCKOPT_SNDTIMEO: 229 | result = setsockopt (socket, SOL_SOCKET, SO_SNDTIMEO, (char *) & value, sizeof (int)); 230 | break; 231 | 232 | case ENET_SOCKOPT_NODELAY: 233 | result = setsockopt (socket, IPPROTO_TCP, TCP_NODELAY, (char *) & value, sizeof (int)); 234 | break; 235 | 236 | default: 237 | break; 238 | } 239 | return result == SOCKET_ERROR ? -1 : 0; 240 | } 241 | 242 | int 243 | enet_socket_get_option (ENetSocket socket, ENetSocketOption option, int * value) 244 | { 245 | int result = SOCKET_ERROR, len; 246 | switch (option) 247 | { 248 | case ENET_SOCKOPT_ERROR: 249 | len = sizeof(int); 250 | result = getsockopt (socket, SOL_SOCKET, SO_ERROR, (char *) value, & len); 251 | break; 252 | 253 | default: 254 | break; 255 | } 256 | return result == SOCKET_ERROR ? -1 : 0; 257 | } 258 | 259 | int 260 | enet_socket_connect (ENetSocket socket, const ENetAddress * address) 261 | { 262 | struct sockaddr_in sin; 263 | int result; 264 | 265 | memset (& sin, 0, sizeof (struct sockaddr_in)); 266 | 267 | sin.sin_family = AF_INET; 268 | sin.sin_port = ENET_HOST_TO_NET_16 (address -> port); 269 | sin.sin_addr.s_addr = address -> host; 270 | 271 | result = connect (socket, (struct sockaddr *) & sin, sizeof (struct sockaddr_in)); 272 | if (result == SOCKET_ERROR && WSAGetLastError () != WSAEWOULDBLOCK) 273 | return -1; 274 | 275 | return 0; 276 | } 277 | 278 | ENetSocket 279 | enet_socket_accept (ENetSocket socket, ENetAddress * address) 280 | { 281 | SOCKET result; 282 | struct sockaddr_in sin; 283 | int sinLength = sizeof (struct sockaddr_in); 284 | 285 | result = accept (socket, 286 | address != NULL ? (struct sockaddr *) & sin : NULL, 287 | address != NULL ? & sinLength : NULL); 288 | 289 | if (result == INVALID_SOCKET) 290 | return ENET_SOCKET_NULL; 291 | 292 | if (address != NULL) 293 | { 294 | address -> host = (enet_uint32) sin.sin_addr.s_addr; 295 | address -> port = ENET_NET_TO_HOST_16 (sin.sin_port); 296 | } 297 | 298 | return result; 299 | } 300 | 301 | int 302 | enet_socket_shutdown (ENetSocket socket, ENetSocketShutdown how) 303 | { 304 | return shutdown (socket, (int) how) == SOCKET_ERROR ? -1 : 0; 305 | } 306 | 307 | void 308 | enet_socket_destroy (ENetSocket socket) 309 | { 310 | if (socket != INVALID_SOCKET) 311 | closesocket (socket); 312 | } 313 | 314 | int 315 | enet_socket_send (ENetSocket socket, 316 | const ENetAddress * address, 317 | const ENetBuffer * buffers, 318 | size_t bufferCount) 319 | { 320 | struct sockaddr_in sin; 321 | DWORD sentLength; 322 | 323 | if (address != NULL) 324 | { 325 | memset (& sin, 0, sizeof (struct sockaddr_in)); 326 | 327 | sin.sin_family = AF_INET; 328 | sin.sin_port = ENET_HOST_TO_NET_16 (address -> port); 329 | sin.sin_addr.s_addr = address -> host; 330 | } 331 | 332 | if (WSASendTo (socket, 333 | (LPWSABUF) buffers, 334 | (DWORD) bufferCount, 335 | & sentLength, 336 | 0, 337 | address != NULL ? (struct sockaddr *) & sin : NULL, 338 | address != NULL ? sizeof (struct sockaddr_in) : 0, 339 | NULL, 340 | NULL) == SOCKET_ERROR) 341 | { 342 | if (WSAGetLastError () == WSAEWOULDBLOCK) 343 | return 0; 344 | 345 | return -1; 346 | } 347 | 348 | return (int) sentLength; 349 | } 350 | 351 | int 352 | enet_socket_receive (ENetSocket socket, 353 | ENetAddress * address, 354 | ENetBuffer * buffers, 355 | size_t bufferCount) 356 | { 357 | INT sinLength = sizeof (struct sockaddr_in); 358 | DWORD flags = 0, 359 | recvLength; 360 | struct sockaddr_in sin; 361 | 362 | if (WSARecvFrom (socket, 363 | (LPWSABUF) buffers, 364 | (DWORD) bufferCount, 365 | & recvLength, 366 | & flags, 367 | address != NULL ? (struct sockaddr *) & sin : NULL, 368 | address != NULL ? & sinLength : NULL, 369 | NULL, 370 | NULL) == SOCKET_ERROR) 371 | { 372 | switch (WSAGetLastError ()) 373 | { 374 | case WSAEWOULDBLOCK: 375 | case WSAECONNRESET: 376 | return 0; 377 | } 378 | 379 | return -1; 380 | } 381 | 382 | if (flags & MSG_PARTIAL) 383 | return -1; 384 | 385 | if (address != NULL) 386 | { 387 | address -> host = (enet_uint32) sin.sin_addr.s_addr; 388 | address -> port = ENET_NET_TO_HOST_16 (sin.sin_port); 389 | } 390 | 391 | return (int) recvLength; 392 | } 393 | 394 | int 395 | enet_socketset_select (ENetSocket maxSocket, ENetSocketSet * readSet, ENetSocketSet * writeSet, enet_uint32 timeout) 396 | { 397 | struct timeval timeVal; 398 | 399 | timeVal.tv_sec = timeout / 1000; 400 | timeVal.tv_usec = (timeout % 1000) * 1000; 401 | 402 | return select (maxSocket + 1, readSet, writeSet, NULL, & timeVal); 403 | } 404 | 405 | int 406 | enet_socket_wait (ENetSocket socket, enet_uint32 * condition, enet_uint32 timeout) 407 | { 408 | fd_set readSet, writeSet; 409 | struct timeval timeVal; 410 | int selectCount; 411 | 412 | timeVal.tv_sec = timeout / 1000; 413 | timeVal.tv_usec = (timeout % 1000) * 1000; 414 | 415 | FD_ZERO (& readSet); 416 | FD_ZERO (& writeSet); 417 | 418 | if (* condition & ENET_SOCKET_WAIT_SEND) 419 | FD_SET (socket, & writeSet); 420 | 421 | if (* condition & ENET_SOCKET_WAIT_RECEIVE) 422 | FD_SET (socket, & readSet); 423 | 424 | selectCount = select (socket + 1, & readSet, & writeSet, NULL, & timeVal); 425 | 426 | if (selectCount < 0) 427 | return -1; 428 | 429 | * condition = ENET_SOCKET_WAIT_NONE; 430 | 431 | if (selectCount == 0) 432 | return 0; 433 | 434 | if (FD_ISSET (socket, & writeSet)) 435 | * condition |= ENET_SOCKET_WAIT_SEND; 436 | 437 | if (FD_ISSET (socket, & readSet)) 438 | * condition |= ENET_SOCKET_WAIT_RECEIVE; 439 | 440 | return 0; 441 | } 442 | 443 | #endif 444 | 445 | -------------------------------------------------------------------------------- /CPPBot/packet.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #pragma pack(push, 1) 5 | struct gameupdatepacket_t { 6 | uint8_t m_type; 7 | uint8_t m_netid; 8 | uint8_t m_jump_amount; 9 | uint8_t m_count; 10 | int32_t m_player_flags; 11 | int32_t m_item; 12 | int32_t m_packet_flags; 13 | float m_struct_flags; 14 | int32_t m_int_data; 15 | float m_vec_x; 16 | float m_vec_y; 17 | float m_vec2_x; 18 | float m_vec2_y; 19 | float m_particle_time; 20 | uint32_t m_state1; 21 | uint32_t m_state2; 22 | uint32_t m_data_size; 23 | uint32_t m_data; 24 | }; 25 | typedef struct gametankpacket_t { 26 | int32_t m_type; 27 | char m_data; 28 | } gametextpacket_t; 29 | #pragma pack(pop) 30 | enum { 31 | PACKET_STATE = 0, 32 | PACKET_CALL_FUNCTION, 33 | PACKET_UPDATE_STATUS, 34 | PACKET_TILE_CHANGE_REQUEST, 35 | PACKET_SEND_MAP_DATA, 36 | PACKET_SEND_TILE_UPDATE_DATA, 37 | PACKET_SEND_TILE_UPDATE_DATA_MULTIPLE, 38 | PACKET_TILE_ACTIVATE_REQUEST, 39 | PACKET_TILE_APPLY_DAMAGE, 40 | PACKET_SEND_INVENTORY_STATE, 41 | PACKET_ITEM_ACTIVATE_REQUEST, 42 | PACKET_ITEM_ACTIVATE_OBJECT_REQUEST, 43 | PACKET_SEND_TILE_TREE_STATE, 44 | PACKET_MODIFY_ITEM_INVENTORY, 45 | PACKET_ITEM_CHANGE_OBJECT, 46 | PACKET_SEND_LOCK, 47 | PACKET_SEND_ITEM_DATABASE_DATA, 48 | PACKET_SEND_PARTICLE_EFFECT, 49 | PACKET_SET_ICON_STATE, 50 | PACKET_ITEM_EFFECT, 51 | PACKET_SET_CHARACTER_STATE, 52 | PACKET_PING_REPLY, 53 | PACKET_PING_REQUEST, 54 | PACKET_GOT_PUNCHED, 55 | PACKET_APP_CHECK_RESPONSE, 56 | PACKET_APP_INTEGRITY_FAIL, 57 | PACKET_DISCONNECT, 58 | PACKET_BATTLE_JOIN, 59 | PACKET_BATTLE_EVEN, 60 | PACKET_USE_DOOR, 61 | PACKET_SEND_PARENTAL, 62 | PACKET_GONE_FISHIN, 63 | PACKET_STEAM, 64 | PACKET_PET_BATTLE, 65 | PACKET_NPC, 66 | PACKET_SPECIAL, 67 | PACKET_SEND_PARTICLE_EFFECT_V2, 68 | GAME_ACTIVE_ARROW_TO_ITEM, 69 | GAME_SELECT_TILE_INDEX 70 | }; 71 | enum { 72 | NET_MESSAGE_UNKNOWN = 0, 73 | NET_MESSAGE_SERVER_HELLO, 74 | NET_MESSAGE_GENERIC_TEXT, 75 | NET_MESSAGE_GAME_MESSAGE, 76 | NET_MESSAGE_GAME_PACKET, 77 | NET_MESSAGE_ERROR, 78 | NET_MESSAGE_TRACK, 79 | NET_MESSAGE_CLIENT_LOG_REQUEST, 80 | NET_MESSAGE_CLIENT_LOG_RESPONSE, 81 | }; 82 | -------------------------------------------------------------------------------- /CPPBot/pch.cpp: -------------------------------------------------------------------------------- 1 | // pch.cpp: source file corresponding to pre-compiled header; necessary for compilation to succeed 2 | 3 | #include "pch.h" 4 | 5 | // In general, ignore this file, but keep it around if you are using pre-compiled headers. 6 | -------------------------------------------------------------------------------- /CPPBot/pch.h: -------------------------------------------------------------------------------- 1 | // Tips for Getting Started: 2 | // 1. Use the Solution Explorer window to add/manage files 3 | // 2. Use the Team Explorer window to connect to source control 4 | // 3. Use the Output window to see build output and other messages 5 | // 4. Use the Error List window to view errors 6 | // 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project 7 | // 6. In the future, to open this project again, go to File > Open > Project and select the .sln file 8 | 9 | #ifndef PCH_H 10 | #define PCH_H 11 | 12 | // TODO: add headers that you want to pre-compile here 13 | 14 | #endif //PCH_H 15 | -------------------------------------------------------------------------------- /CPPBot/proton/hash.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | 4 | #pragma warning(disable : 4307) 5 | 6 | #ifdef _WIN32 7 | #define INLINE __forceinline 8 | #else //for gcc/clang 9 | #define INLINE __attribute__((always_inline)) 10 | #endif 11 | 12 | 13 | template 14 | class cexpr { 15 | public: 16 | static constexpr t value = val; 17 | }; 18 | namespace hs { 19 | constexpr uint32_t val_32_const = 0x811c9dc5u; 20 | constexpr uint32_t prime_32_const = 0x1000193u; 21 | constexpr uint64_t val_64_const = 0xcbf29ce484222325u; 22 | constexpr uint64_t prime_64_const = 0x100000001b3u; 23 | INLINE constexpr uint32_t hash32(const char* const str, const uint32_t value = val_32_const) noexcept { 24 | return (str[0] == '\0') ? value : hash32(&str[1], (value ^ uint32_t(str[0])) * prime_32_const); 25 | } 26 | INLINE constexpr uint64_t hash64(const char* const str, const uint64_t value = val_64_const) noexcept { 27 | return (str[0] == '\0') ? value : hash64(&str[1], (value ^ uint64_t(str[0])) * prime_64_const); 28 | } 29 | } // namespace hs 30 | #define fnv32(s) (cexpr::value) 31 | #define fnv64(s) (cexpr::value) 32 | -------------------------------------------------------------------------------- /CPPBot/proton/rtparam.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | class rtvar { 8 | public: 9 | class pair { 10 | public: 11 | std::string m_key{}; 12 | std::vector m_values{}; 13 | std::string m_value; 14 | pair() { 15 | } 16 | pair(std::string key, std::initializer_list values) : m_key(key), m_values(values) { 17 | } 18 | bool operator==( const rtvar::pair& rst) { 19 | return m_key == rst.m_key && m_values[0] == rst.m_values[0]; 20 | } 21 | static pair parse(std::string str) { 22 | pair ret{}; 23 | if (!str.length()) { // we dont want to parse empty string so m_pairs vector wont make the app crash 24 | ret.m_value.append("[EMPTY]"); 25 | ret.m_values.push_back("[EMPTY]"); 26 | return ret; 27 | } 28 | std::string token; 29 | std::stringstream ss(str); 30 | bool key = true, first = true; 31 | while (std::getline(ss, token, '|')) { 32 | if (key) { 33 | ret.m_key = token; 34 | key = false; 35 | } else { 36 | if (!first) 37 | ret.m_value.append("|"); 38 | ret.m_value.append(token); 39 | ret.m_values.push_back(token); 40 | first = false; 41 | } 42 | } 43 | return ret; 44 | } 45 | std::string serialize() { 46 | std::string ret{}; 47 | ret.append(m_key); 48 | for (auto& val : m_values) { 49 | ret.append("|"); 50 | ret.append(val); 51 | } 52 | return ret; 53 | } 54 | }; 55 | rtvar() { 56 | } 57 | rtvar(std::initializer_list pairs) : m_pairs(pairs) { 58 | } 59 | static rtvar parse(std::string str) { 60 | rtvar ret{}; 61 | std::stringstream ss(str); 62 | std::string token{}; 63 | while (std::getline(ss, token, '\n')) 64 | ret.append(token); 65 | return ret; 66 | } 67 | pair& append(std::string str) { 68 | pair p = pair::parse(str); 69 | m_pairs.push_back(p); 70 | return m_pairs.back(); 71 | } 72 | pair& get(int i) { 73 | if ((unsigned)i >= m_pairs.size()) 74 | return m_pairs[0]; 75 | return m_pairs[i]; 76 | } 77 | bool valid() { 78 | if (m_pairs.size() < 1) 79 | return false; 80 | 81 | if (m_pairs[0].m_values.size() < 1) 82 | return false; 83 | 84 | return true; 85 | } 86 | pair* find(const std::string& key) { 87 | int inx = 0; 88 | for (auto pair : m_pairs) { 89 | if (pair.m_key == key) //we cant return local pairs addr 90 | return &m_pairs[inx]; 91 | inx++; 92 | } 93 | return nullptr; 94 | } 95 | 96 | std::string get(const std::string& key) { 97 | auto pair = find(key); 98 | if (pair) 99 | return pair->m_value; 100 | return ""; 101 | } 102 | void set(const std::string& key, std::string value) { 103 | auto pair = find(key); 104 | if (pair && pair->m_values.size() >= 1) 105 | pair->m_values[0] = value; 106 | } 107 | std::string serialize() { 108 | std::string ret{}; 109 | for (auto& val : m_pairs) { 110 | ret.append(val.serialize()); 111 | ret.append("\n"); 112 | } 113 | if (ret != "") 114 | ret.erase(ret.end()); 115 | return ret; 116 | } 117 | /* bool validate_ints(std::vector vals) { 118 | for (auto str : vals) { 119 | auto pair = this->find(str); 120 | if (!pair) 121 | return false; 122 | if (!utils::is_number(pair->m_value)) 123 | return false; 124 | } 125 | return true; 126 | } 127 | bool validate_int(std::string str) { 128 | auto pair = this->find(str); 129 | if (!pair) 130 | return false; 131 | if (!utils::is_number(pair->m_value)) 132 | return false; 133 | return true; 134 | }*/ 135 | inline int get_int(const std::string& key) { //this does not chekc if it exists, it assumes validate_ints has been consulated beforehand 136 | return atoi(find(key)->m_value.c_str()); 137 | } 138 | inline long long get_long(const std::string& key) { //assumes validate_ints 139 | return atoll(find(key)->m_value.c_str()); 140 | } 141 | size_t size() const { 142 | return m_pairs.size(); 143 | } 144 | void remove(const std::string& key) { 145 | auto pair = find(key); 146 | if (pair) { 147 | auto& ref = *pair; 148 | m_pairs.erase(std::remove(m_pairs.begin(), m_pairs.end(), ref), m_pairs.end()); 149 | } 150 | } 151 | 152 | private: 153 | //i could use std::map but for the sake of simplicity i dont, i want the code to be as readable as possible 154 | std::vector m_pairs{}; 155 | }; 156 | class rtvar_opt { //optimized version of rtvars (really nothing more than a container) when only needing to append strings 157 | private: 158 | std::string m_var{}; 159 | 160 | public: 161 | rtvar_opt() { 162 | } 163 | rtvar_opt(std::string start) { 164 | m_var = start; 165 | } 166 | void append(std::string str) { 167 | m_var = m_var.append("\n" + str); 168 | } 169 | std::string get() { 170 | return m_var; 171 | } 172 | }; 173 | -------------------------------------------------------------------------------- /CPPBot/proton/variant.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include "vector.hpp" 7 | 8 | #define C_VAR_SPACE_BYTES 16 9 | class variant_t { 10 | public: 11 | enum class vartype_t { TYPE_UNUSED, TYPE_FLOAT, TYPE_STRING, TYPE_VECTOR2, TYPE_VECTOR3, TYPE_UINT32, TYPE_ENTITY, TYPE_COMPONENT, TYPE_RECT, TYPE_INT32 }; 12 | variant_t() { set_defaults(); } 13 | variant_t(const variant_t& v) { 14 | set_defaults(); 15 | *this = v; 16 | } 17 | variant_t(int32_t var) { 18 | set_defaults(); 19 | set(var); 20 | } 21 | variant_t(uint32_t var) { 22 | set_defaults(); 23 | set(var); 24 | } 25 | variant_t(float var) { 26 | set_defaults(); 27 | set(var); 28 | } 29 | variant_t(float x, float y) { 30 | set_defaults(); 31 | set(vector2_t(x, y)); 32 | } 33 | variant_t(float x, float y, float z) { 34 | set_defaults(); 35 | set(vector3_t(x, y, z)); 36 | } 37 | variant_t(const vector2_t& v2) { 38 | set_defaults(); 39 | set(v2); 40 | } 41 | variant_t(const vector3_t& v3) { 42 | set_defaults(); 43 | set(v3); 44 | } 45 | variant_t(const rect_t& r) { 46 | set_defaults(); 47 | set(r); 48 | } 49 | variant_t(const std::string& var) { 50 | set_defaults(); 51 | set(var); 52 | } 53 | 54 | void reset() { m_type = vartype_t::TYPE_UNUSED; } 55 | void set(const variant_t& v) { 56 | switch (v.get_type()) { 57 | case vartype_t::TYPE_FLOAT: set(v.get_float()); break; 58 | case vartype_t::TYPE_STRING: set(v.get_string()); break; 59 | case vartype_t::TYPE_VECTOR2: set(v.get_vector2()); break; 60 | case vartype_t::TYPE_VECTOR3: set(v.get_vector3()); break; 61 | case vartype_t::TYPE_UINT32: set(v.get_uint32()); break; 62 | case vartype_t::TYPE_INT32: set(v.get_int32()); break; 63 | case vartype_t::TYPE_RECT: set(v.get_rect()); break; 64 | case vartype_t::TYPE_ENTITY: 65 | case vartype_t::TYPE_COMPONENT: 66 | default: break; 67 | } 68 | } 69 | void set(float var) { 70 | m_type = vartype_t::TYPE_FLOAT; 71 | *((float*)m_var) = var; 72 | } 73 | void set(uint32_t var) { 74 | m_type = vartype_t::TYPE_UINT32; 75 | *((uint32_t*)m_var) = var; 76 | } 77 | void set(int32_t var) { 78 | m_type = vartype_t::TYPE_INT32; 79 | *((int32_t*)m_var) = var; 80 | } 81 | void operator=(float var) { 82 | set(var); 83 | } 84 | void operator=(int32_t var) { 85 | set(var); 86 | } 87 | void operator=(uint32_t var) { 88 | set(var); 89 | } 90 | void operator=(std::string const& var) { 91 | set(var); 92 | } 93 | void set(std::string const& var) { 94 | m_type = vartype_t::TYPE_STRING; 95 | m_string = var; 96 | } 97 | void operator=(vector2_t const& var) { 98 | set(var); 99 | } 100 | void set(vector2_t const& var) { 101 | m_type = vartype_t::TYPE_VECTOR2; 102 | *((vector2_t*)m_var) = var; 103 | } 104 | void set(float x, float y) { set(vector2_t(x, y)); } 105 | void operator=(vector3_t const& var) { 106 | set(var); 107 | } 108 | void operator=(rect_t const& var) { 109 | set(var); 110 | } 111 | void set(vector3_t const& var) { 112 | m_type = vartype_t::TYPE_VECTOR3; 113 | *((vector3_t*)m_var) = var; 114 | } 115 | void set(rect_t const& var) { 116 | m_type = vartype_t::TYPE_RECT; 117 | *((rect_t*)m_var) = var; 118 | } 119 | void set(float x, float y, float z) { set(vector3_t(x, y, z)); } 120 | 121 | float& get_float() { 122 | if (m_type == vartype_t::TYPE_UNUSED) 123 | set(float(0)); 124 | return *((float*)m_var); 125 | } 126 | int32_t& get_int32() { 127 | if (m_type == vartype_t::TYPE_UNUSED) 128 | set(int32_t(0)); 129 | return *((int32_t*)m_var); 130 | } 131 | uint32_t& get_uint32() { 132 | if (m_type == vartype_t::TYPE_UNUSED) 133 | set(uint32_t(0)); 134 | return *((uint32_t*)m_var); 135 | } 136 | std::string& get_string() { return m_string; } 137 | vector2_t& get_vector2() { 138 | if (m_type == vartype_t::TYPE_UNUSED) 139 | set(vector2_t(0, 0)); 140 | return *((vector2_t*)m_var); 141 | } 142 | vector3_t& get_vector3() { 143 | if (m_type == vartype_t::TYPE_UNUSED) 144 | set(vector3_t(0, 0, 0)); 145 | return *((vector3_t*)m_var); 146 | } 147 | rect_t& get_rect() { 148 | if (m_type == vartype_t::TYPE_UNUSED) 149 | set(rect_t(0, 0, 0, 0)); 150 | return *((rect_t*)m_var); 151 | } 152 | 153 | const float& get_float() const { return *((float*)m_var); } 154 | const int32_t& get_int32() const { return *((int32_t*)m_var); } 155 | const uint32_t& get_uint32() const { return *((uint32_t*)m_var); } 156 | const std::string& get_string() const { return m_string; } 157 | const vector2_t& get_vector2() const { return *((vector2_t*)m_var); } 158 | const vector3_t& get_vector3() const { return *((vector3_t*)m_var); } 159 | const rect_t& get_rect() const { return *((rect_t*)m_var); } 160 | 161 | vartype_t get_type() const { return m_type; } 162 | 163 | std::string print() { 164 | switch (get_type()) { 165 | case vartype_t::TYPE_FLOAT: return std::to_string(get_float()); 166 | case vartype_t::TYPE_STRING: return get_string(); 167 | case vartype_t::TYPE_VECTOR2: return "x: " + std::to_string(get_vector2().m_x) + " y: " + std::to_string(get_vector2().m_y); 168 | case vartype_t::TYPE_VECTOR3: 169 | return "x: " + std::to_string(get_vector3().m_x) + " y: " + std::to_string(get_vector3().m_y) + " z: " + std::to_string(get_vector3().m_z); 170 | case vartype_t::TYPE_UINT32: return std::to_string(get_uint32()); 171 | case vartype_t::TYPE_INT32: return std::to_string(get_int32()); 172 | case vartype_t::TYPE_RECT: 173 | return "x: " + std::to_string(get_rect().m_x) + " y: " + std::to_string(get_rect().m_y) + " w: " + std::to_string(get_rect().m_w) + 174 | " h: " + std::to_string(get_rect().m_h); 175 | case vartype_t::TYPE_ENTITY: 176 | case vartype_t::TYPE_COMPONENT: 177 | case vartype_t::TYPE_UNUSED: return "unused"; break; 178 | default: break; 179 | } 180 | return "unknown"; 181 | } 182 | variant_t& operator=(const variant_t& rhs) { 183 | m_type = rhs.m_type; 184 | m_pointer = rhs.m_pointer; 185 | memcpy(m_var, rhs.m_var, C_VAR_SPACE_BYTES); 186 | m_string = rhs.m_string; 187 | return *this; 188 | } 189 | variant_t& operator+=(const variant_t& rhs) { 190 | if (get_type() == rhs.get_type()) { 191 | switch (get_type()) { 192 | case vartype_t::TYPE_FLOAT: set(get_float() + rhs.get_float()); break; 193 | case vartype_t::TYPE_STRING: set(get_string() + rhs.get_string()); break; 194 | case vartype_t::TYPE_VECTOR2: set(get_vector2() + rhs.get_vector2()); break; 195 | case vartype_t::TYPE_VECTOR3: set(get_vector3() + rhs.get_vector3()); break; 196 | case vartype_t::TYPE_UINT32: set(get_uint32() + rhs.get_uint32()); break; 197 | case vartype_t::TYPE_INT32: set(get_int32() + rhs.get_int32()); break; 198 | default: break; 199 | } 200 | } 201 | return *this; 202 | } 203 | variant_t& operator-=(const variant_t& rhs) { 204 | if (get_type() == rhs.get_type()) { 205 | switch (get_type()) { 206 | case vartype_t::TYPE_FLOAT: set(get_float() - rhs.get_float()); break; 207 | case vartype_t::TYPE_VECTOR2: set(get_vector2() - rhs.get_vector2()); break; 208 | case vartype_t::TYPE_VECTOR3: set(get_vector3() - rhs.get_vector3()); break; 209 | case vartype_t::TYPE_UINT32: set(get_uint32() - rhs.get_uint32()); break; 210 | case vartype_t::TYPE_INT32: set(get_int32() - rhs.get_int32()); break; 211 | default: break; 212 | } 213 | } 214 | return *this; 215 | } 216 | bool operator==(const variant_t& rhs) const { 217 | if (get_type() != rhs.get_type()) 218 | return false; 219 | switch (get_type()) { 220 | case vartype_t::TYPE_UNUSED: return true; 221 | case vartype_t::TYPE_FLOAT: return get_float() == rhs.get_float(); 222 | case vartype_t::TYPE_STRING: return get_string() == rhs.get_string(); 223 | case vartype_t::TYPE_VECTOR2: return get_vector2() == rhs.get_vector2(); 224 | case vartype_t::TYPE_VECTOR3: return get_vector3() == rhs.get_vector3(); 225 | case vartype_t::TYPE_UINT32: return get_uint32() == rhs.get_uint32(); 226 | case vartype_t::TYPE_RECT: return get_rect() == rhs.get_rect(); 227 | case vartype_t::TYPE_INT32: return get_int32() == rhs.get_int32(); 228 | case vartype_t::TYPE_ENTITY: 229 | case vartype_t::TYPE_COMPONENT: 230 | default: return false; 231 | } 232 | } 233 | bool operator!=(const variant_t& rhs) const { return !operator==(rhs); } 234 | friend class variantlist_t; 235 | 236 | private: 237 | void set_defaults() { m_type = vartype_t::TYPE_UNUSED; } 238 | vartype_t m_type; 239 | void* m_pointer; 240 | union { 241 | uint8_t m_var[C_VAR_SPACE_BYTES]; 242 | float m_as_floats[4]; 243 | uint32_t m_as_uint32s[4]; 244 | int32_t m_as_int32s[4]; 245 | }; 246 | std::string m_string; 247 | }; 248 | inline variant_t operator+(variant_t lhs, const variant_t& rhs) { 249 | lhs += rhs; 250 | return lhs; 251 | } 252 | inline variant_t operator-(variant_t lhs, const variant_t& rhs) { 253 | lhs -= rhs; 254 | return lhs; 255 | } 256 | #define C_MAX_VARIANT_LIST_PARMS 7 257 | class variantlist_t { 258 | int size_of_variant(variant_t::vartype_t type) { 259 | switch (type) { 260 | case variant_t::vartype_t::TYPE_UNUSED: 261 | case variant_t::vartype_t::TYPE_COMPONENT: 262 | case variant_t::vartype_t::TYPE_ENTITY: return 0; 263 | case variant_t::vartype_t::TYPE_UINT32: 264 | case variant_t::vartype_t::TYPE_INT32: 265 | case variant_t::vartype_t::TYPE_FLOAT: return 4; 266 | case variant_t::vartype_t::TYPE_VECTOR2: return sizeof(vector2_t); 267 | case variant_t::vartype_t::TYPE_VECTOR3: return sizeof(vector3_t); 268 | case variant_t::vartype_t::TYPE_RECT: return sizeof(rect_t); 269 | default: return 0; 270 | } 271 | } 272 | 273 | public: 274 | variantlist_t(){}; 275 | variant_t& get(int parmNum) { return m_variant[parmNum]; } 276 | variant_t& operator[](int num) { 277 | return m_variant[num]; 278 | } 279 | variantlist_t(const std::string& string) { 280 | m_variant[0] = variant_t(string); 281 | } 282 | variantlist_t(variant_t v0) { m_variant[0] = v0; } 283 | variantlist_t(variant_t v0, variant_t v1) { 284 | m_variant[0] = v0; 285 | m_variant[1] = v1; 286 | } 287 | variantlist_t(variant_t v0, variant_t v1, variant_t v2) { 288 | m_variant[0] = v0; 289 | m_variant[1] = v1; 290 | m_variant[2] = v2; 291 | } 292 | variantlist_t(variant_t v0, variant_t v1, variant_t v2, variant_t v3) { 293 | m_variant[0] = v0; 294 | m_variant[1] = v1; 295 | m_variant[2] = v2; 296 | m_variant[3] = v3; 297 | } 298 | variantlist_t(variant_t v0, variant_t v1, variant_t v2, variant_t v3, variant_t v4) { 299 | m_variant[0] = v0; 300 | m_variant[1] = v1; 301 | m_variant[2] = v2; 302 | m_variant[3] = v3; 303 | m_variant[4] = v4; 304 | } 305 | variantlist_t(variant_t v0, variant_t v1, variant_t v2, variant_t v3, variant_t v4, variant_t v5) { 306 | m_variant[0] = v0; 307 | m_variant[1] = v1; 308 | m_variant[2] = v2; 309 | m_variant[3] = v3; 310 | m_variant[4] = v4; 311 | m_variant[5] = v5; 312 | } 313 | void reset() { 314 | for (int i = 0; i < C_MAX_VARIANT_LIST_PARMS; i++) m_variant[i].reset(); 315 | } 316 | uint32_t get_mem_needed() { 317 | int vars_used = 0; 318 | int mem_needed = 0; 319 | int var_size; 320 | for (int i = 0; i < C_MAX_VARIANT_LIST_PARMS; i++) { 321 | if (m_variant[i].get_type() == variant_t::vartype_t::TYPE_STRING) 322 | var_size = m_variant[i].get_string().size() + 4; 323 | else 324 | var_size = size_of_variant(m_variant[i].get_type()); 325 | if (var_size > 0) { 326 | vars_used++; 327 | mem_needed += var_size; 328 | } 329 | } 330 | int total = mem_needed + 1 + (vars_used * 2); 331 | return total; 332 | } 333 | uint8_t* serialize_to_mem(uint32_t* size, uint8_t* data) { 334 | int vars_used = 0; 335 | int mem_needed = 0; 336 | int var_size; 337 | for (int i = 0; i < C_MAX_VARIANT_LIST_PARMS; i++) { 338 | if (m_variant[i].get_type() == variant_t::vartype_t::TYPE_STRING) 339 | var_size = m_variant[i].get_string().size() + 4; 340 | else 341 | var_size = size_of_variant(m_variant[i].get_type()); 342 | if (var_size > 0) { 343 | vars_used++; 344 | mem_needed += var_size; 345 | } 346 | } 347 | int total = mem_needed + 1 + (vars_used * 2); 348 | if (!data) 349 | data = new uint8_t[total]; 350 | uint8_t* p = data; 351 | *(p++) = uint8_t(vars_used); 352 | for (int idx = 0; idx < C_MAX_VARIANT_LIST_PARMS; idx++) { 353 | uint8_t type = uint8_t(m_variant[idx].get_type()); 354 | if (m_variant[idx].get_type() == variant_t::vartype_t::TYPE_STRING) { 355 | uint32_t len = m_variant[idx].get_string().size(); 356 | memcpy(p++, &idx, 1); 357 | memcpy(p++, &type, 1); 358 | memcpy(p, &len, 4); 359 | p += 4; 360 | memcpy(p, m_variant[idx].get_string().c_str(), len); 361 | p += len; 362 | } else { 363 | var_size = size_of_variant(m_variant[idx].get_type()); 364 | if (var_size > 0) { 365 | memcpy(p++, &idx, 1); 366 | memcpy(p++, &type, 1); 367 | memcpy(p, m_variant[idx].m_var, var_size); 368 | p += var_size; 369 | } 370 | } 371 | } 372 | if (size) 373 | *size = total; 374 | return data; 375 | } 376 | bool serialize_from_mem(uint8_t* data, int* read = 0) { //robinson way cuz i dont want to refactor this yet 377 | uint8_t* p = data; 378 | uint8_t count = *(p++); 379 | for (int i = 0; i < count; i++) { 380 | uint8_t index = *(p++); 381 | uint8_t type = *(p++); 382 | switch (variant_t::vartype_t(type)) { 383 | case variant_t::vartype_t::TYPE_STRING: { 384 | uint32_t len; 385 | memcpy(&len, p, 4); 386 | p += 4; 387 | std::string v; 388 | v.resize(len); 389 | memcpy(&v[0], p, len); 390 | p += len; 391 | m_variant[index].set(v); 392 | break; 393 | } 394 | case variant_t::vartype_t::TYPE_UINT32: { 395 | uint32_t v; 396 | memcpy(&v, p, sizeof(uint32_t)); 397 | p += sizeof(uint32_t); 398 | m_variant[index].set(v); 399 | break; 400 | } 401 | case variant_t::vartype_t::TYPE_INT32: { 402 | int32_t v; 403 | memcpy(&v, p, sizeof(int32_t)); 404 | p += sizeof(int32_t); 405 | m_variant[index].set(v); 406 | break; 407 | } 408 | case variant_t::vartype_t::TYPE_FLOAT: { 409 | float v; 410 | memcpy(&v, p, sizeof(float)); 411 | p += sizeof(float); 412 | m_variant[index].set(v); 413 | break; 414 | } 415 | case variant_t::vartype_t::TYPE_VECTOR2: { 416 | vector2_t v; 417 | memcpy(&v, p, sizeof(vector2_t)); 418 | p += sizeof(vector2_t); 419 | m_variant[index].set(v); 420 | break; 421 | } 422 | case variant_t::vartype_t::TYPE_VECTOR3: { 423 | vector3_t v; 424 | memcpy(&v, p, sizeof(vector3_t)); 425 | p += sizeof(vector3_t); 426 | m_variant[index].set(v); 427 | break; 428 | } 429 | case variant_t::vartype_t::TYPE_RECT: { 430 | rect_t v; 431 | memcpy(&v, p, sizeof(rect_t)); 432 | p += sizeof(rect_t); 433 | m_variant[index].set(v); 434 | break; 435 | } 436 | default: 437 | if (read) 438 | *read = 0; 439 | return false; 440 | } 441 | } 442 | if (read) 443 | *read = int(p - data); 444 | return true; 445 | } 446 | variant_t m_variant[C_MAX_VARIANT_LIST_PARMS]; 447 | std::string print() { 448 | std::stringstream ss; 449 | for (int i = 0; i < C_MAX_VARIANT_LIST_PARMS; i++) { 450 | if (m_variant[i].get_type() == variant_t::vartype_t::TYPE_UNUSED) 451 | continue; 452 | ss << "param " << std::to_string(i) << ": " << m_variant[i].print() + "\n"; 453 | } 454 | if (ss.str().empty()) 455 | ss.str("(none)"); 456 | return ss.str(); 457 | } 458 | }; 459 | -------------------------------------------------------------------------------- /CPPBot/proton/vector.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | class vector2_t { 4 | public: 5 | float m_x; 6 | float m_y; 7 | vector2_t() : m_x(0), m_y(0) {} 8 | vector2_t(float x, float y) : m_x(x), m_y(y) {} 9 | bool operator==(vector2_t& rhs) { return m_x == rhs.m_x && m_y == rhs.m_y; } 10 | bool operator==(const vector2_t& rhs) const { return m_x == rhs.m_x && m_y == rhs.m_y; } 11 | vector2_t operator+(const vector2_t& rhs) { return vector2_t(m_x + rhs.m_x, m_y + rhs.m_y); } 12 | vector2_t operator-(const vector2_t& rhs) { return vector2_t(m_x - rhs.m_x, m_y - rhs.m_y); } 13 | float distance(float x, float y) { 14 | float value_x = this->m_x - x; 15 | float value_y = this->m_y - y; 16 | return sqrt(value_x * value_x + value_y * value_y); 17 | } 18 | }; 19 | 20 | class vector2i_t { 21 | public: 22 | int m_x; 23 | int m_y; 24 | vector2i_t() : m_x(0), m_y(0) {} 25 | vector2i_t(int x, int y) : m_x(x), m_y(y) {} 26 | vector2i_t(uint32_t x, uint32_t y) : m_x(x), m_y(y) {} 27 | bool operator==(vector2i_t& rhs) { return m_x == rhs.m_x && m_y == rhs.m_y; } 28 | bool operator!=(vector2i_t& rhs) { 29 | return m_x != rhs.m_x || m_y != rhs.m_y; 30 | } 31 | bool operator==(const vector2i_t& rhs) const { return m_x == rhs.m_x && m_y == rhs.m_y; } 32 | vector2i_t operator+(const vector2i_t& rhs) { return vector2i_t(m_x + rhs.m_x, m_y + rhs.m_y); } 33 | vector2i_t operator-(const vector2i_t& rhs) { return vector2i_t(m_x - rhs.m_x, m_y - rhs.m_y); } 34 | float distance(int x, int y) { 35 | float value_x = float(this->m_x) - x; 36 | float value_y = float(this->m_y) - y; 37 | return sqrt(value_x * value_x + value_y * value_y); 38 | } 39 | }; 40 | 41 | class vector3_t { 42 | public: 43 | float m_x; 44 | float m_y; 45 | float m_z; 46 | vector3_t() : m_x(0), m_y(0), m_z(0) {} 47 | vector3_t(float x, float y, float z) : m_x(x), m_y(y), m_z(z) {} 48 | bool operator==(vector3_t& rhs) { return m_x == rhs.m_x && m_y == rhs.m_y && m_z == rhs.m_z; } 49 | bool operator==(const vector3_t& rhs) const { return m_x == rhs.m_x && m_y == rhs.m_y && m_z == rhs.m_z; } 50 | vector3_t operator+(const vector3_t& rhs) { return vector3_t(m_x + rhs.m_x, m_y + rhs.m_y, m_z + rhs.m_z); } 51 | vector3_t operator-(const vector3_t& rhs) { return vector3_t(m_x - rhs.m_x, m_y - rhs.m_y, m_z - rhs.m_z); } 52 | }; 53 | 54 | class rect_t { 55 | public: 56 | float m_x; 57 | float m_y; 58 | float m_w; 59 | float m_h; 60 | rect_t() : m_x(0), m_y(0), m_w(0), m_h(0) {} 61 | rect_t(float x, float y, float w, float h) : m_x(x), m_y(y), m_w(w), m_h(h) {} 62 | bool operator==(rect_t& rhs) { return m_x == rhs.m_x && m_y == rhs.m_y && m_w == rhs.m_w && m_h == rhs.m_h; } 63 | bool operator==(const rect_t& rhs) const { return m_x == rhs.m_x && m_y == rhs.m_y && m_w == rhs.m_w && m_h == rhs.m_h; } 64 | rect_t operator+(const rect_t& rhs) { return rect_t(m_x + rhs.m_x, m_y + rhs.m_y, m_w + rhs.m_w, m_h + rhs.m_h); } 65 | rect_t operator-(const rect_t& rhs) { return rect_t(m_x - rhs.m_x, m_y - rhs.m_y, m_w - rhs.m_w, m_h - rhs.m_h); } 66 | }; 67 | -------------------------------------------------------------------------------- /CPPBot/userfunc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | // Grotopia Bot 4 | // Copyright (C) 2018 Growtopia Noobs 5 | // 6 | // This program is free software: you can redistribute it and/or modify 7 | // it under the terms of the GNU Affero General Public License as published 8 | // by the Free Software Foundation, either version 3 of the License, or 9 | // (at your option) any later version. 10 | // 11 | // This program is distributed in the hope that it will be useful, 12 | // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 | // GNU Affero General Public License for more details. 15 | // 16 | // You should have received a copy of the GNU Affero General Public License 17 | // along with this program. If not, see . 18 | 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | 29 | #include "utilsfunc.h" 30 | #include "corefunc.h" 31 | #include "userfunc.h" 32 | #include "enet/include/enet.h" 33 | 34 | #include "proton/rtparam.hpp" 35 | //#define WORLD_GO 36 | 37 | using namespace std; 38 | 39 | char hexmap[] = { '0', '1', '2', '3', '4', '5', '6', '7', 40 | '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; 41 | 42 | std::string hexStr(unsigned char data) 43 | { 44 | std::string s(2, ' '); 45 | s[0] = hexmap[(data & 0xF0) >> 4]; 46 | s[1] = hexmap[data & 0x0F]; 47 | return s; 48 | } 49 | 50 | string generateMeta() 51 | { 52 | string x; 53 | for (int i = 0; i < 9; i++) 54 | { 55 | x += hexStr(rand()); 56 | } 57 | x += ".com"; 58 | return x; 59 | } 60 | 61 | string generateMac() 62 | { 63 | string x; 64 | for (int i = 0; i < 6; i++) 65 | { 66 | x += hexStr(rand()); 67 | if (i != 5) 68 | x += ":"; 69 | } 70 | return x; 71 | } 72 | 73 | string generateRid() 74 | { 75 | string x; 76 | for (int i = 0; i < 16; i++) 77 | { 78 | x += hexStr(rand()); 79 | } 80 | for (auto & c : x) c = toupper(c); 81 | return x; 82 | } 83 | 84 | string stripMessage(string msg) { 85 | regex e("\\x60[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]\\{};':\"\\\\|,.<>\\/?]"); 86 | string result = regex_replace(msg, e, ""); 87 | result.erase(std::remove(result.begin(), result.end(), '`'), result.end()); 88 | return result; 89 | } 90 | 91 | void GrowtopiaBot::onLoginRequested() 92 | { 93 | cout << "Logging on..." << endl; 94 | string token; 95 | if (!login_user && !login_token) { 96 | token = ""; 97 | } else { 98 | token = "\nuser|" + std::to_string(login_user) + "\ntoken|" + std::to_string(login_token); 99 | } 100 | string ver = gameVersion; 101 | string hash = std::to_string((unsigned int)rand()); 102 | string hash2 = std::to_string((unsigned int)rand()); 103 | string packet = "tankIDName|" + uname + "\ntankIDPass|" + upass + "\nrequestedName|SmileZero\nf|1\nprotocol|84\ngame_version|" + ver + "\nfz|5367464\nlmode|0\ncbits|0\nplayer_age|18\nGDPR|1\nhash2|" + hash2 + "\nmeta|" + generateMeta() + "\nfhash|-716928004\nrid|" + generateRid() + "\nplatformID|0\ndeviceVersion|0\ncountry|us\nhash|" + hash + "\nmac|" + generateMac() + "\nwk|" + generateRid() + "\nzf|-496303939" + token; 104 | cout << packet; 105 | SendPacket(2, "tankIDName|" + uname + "\ntankIDPass|" + upass + "\nrequestedName|SmileZero\nf|1\nprotocol|84\ngame_version|" + ver + "\nfz|5367464\nlmode|0\ncbits|0\nplayer_age|18\nGDPR|1\nhash2|" + hash2 + "\nmeta|" + generateMeta() + "\nfhash|-716928004\nrid|" + generateRid() + "\nplatformID|0\ndeviceVersion|0\ncountry|us\nhash|" + hash + "\nmac|" + generateMac() + "\nwk|" + generateRid() + "\nzf|-496303939" + token, peer); 106 | 107 | currentWorld = ""; 108 | } 109 | 110 | void GrowtopiaBot::packet_type3(string text) 111 | { 112 | dbgPrint("Some text is here: " + text); 113 | if (text.find("LOGON ATTEMPTS") != string::npos) 114 | { 115 | cout << "Wrong username / password!. (LOGON ATTEMPTS)"; 116 | } 117 | if (text.find("password is wrong") != string::npos) 118 | { 119 | cout << "Wrong password!"; 120 | } 121 | if (text.find("action|logon_fail") != string::npos) 122 | { 123 | connectClient(); 124 | objects.clear(); 125 | currentWorld = ""; 126 | } 127 | } 128 | 129 | void GrowtopiaBot::packet_type6(string text) 130 | { 131 | //dbgPrint("Some text is here: " + text); 132 | SendPacket(2, "action|enter_game\n", peer); 133 | enet_host_flush(client); 134 | } 135 | 136 | void GrowtopiaBot::packet_unknown(ENetPacket* packet) 137 | { 138 | dbgPrint("Got unknown packet type: " + std::to_string(GetMessageTypeFromPacket(packet))); 139 | dbgPrint("Packet size is " + std::to_string(packet->dataLength)); 140 | } 141 | 142 | void GrowtopiaBot::OnSendToServer(string address, int port, int userId, int token) 143 | { 144 | address = address.substr(0, address.size()-1); // remove | 145 | 146 | login_user = userId; 147 | login_token = token; 148 | connectClient(address, port); 149 | } 150 | 151 | void GrowtopiaBot::OnConsoleMessage(string message) { 152 | cout << "Found console message: " << endl; 153 | string strippedMessage = stripMessage(message); 154 | cout << strippedMessage << endl; 155 | 156 | if (strippedMessage.find("MSG") != std::string::npos) { 157 | cout << "Found message!" << endl; 158 | } 159 | 160 | cout << "------------------------" << endl; 161 | } 162 | 163 | void GrowtopiaBot::OnPlayPositioned(string sound) 164 | { 165 | 166 | } 167 | 168 | void GrowtopiaBot::OnSetFreezeState(int state) 169 | { 170 | 171 | } 172 | 173 | void GrowtopiaBot::OnRemove(string data) // "netID|x\n" 174 | { 175 | rtvar var = rtvar::parse(data) 176 | int netid = var.get_int("netID"); 177 | } 178 | 179 | void GrowtopiaBot::OnSpawn(string data) 180 | { 181 | 182 | rtvar var = rtvar::parse(data); 183 | 184 | ObjectData objectData; 185 | bool actuallyOwner = false; 186 | 187 | auto name = var.find("name"); 188 | auto netid = var.find("netID"); 189 | 190 | 191 | objectData.country = var.get("country"); 192 | 193 | if (stripMessage(var.get("name")) == ownerUsername) actuallyOwner = true; 194 | objectData.name = var.get("name"); 195 | 196 | if (actuallyOwner) owner = var.get_int("netID"); 197 | objectData.netId = var.get_int("netID"); 198 | objectData.userId = var.get_int("userID"); 199 | 200 | 201 | auto pos = var.find("posXY"); 202 | if (pos && pos->m_values.size() >= 2) { 203 | auto x = atoi(pos->m_values[0].c_str()); 204 | auto y = atoi(pos->m_values[1].c_str()); 205 | //ply.pos = vector2_t{ float(x), float(y) }; 206 | objectData.x = x; 207 | objectData.y = y; 208 | } 209 | 210 | 211 | if (data.find("type|local") != -1) { 212 | objectData.isLocal = true; 213 | localx = objectData.x; 214 | localy = objectData.y; 215 | localnetid = objectData.netId; 216 | } 217 | if (var.get("mstate") == "1" || var.get("smstate") == "1" ||var.get("invis")== "1"){ 218 | cout << "Some fishy boy is here: " << objectData.name << "; " << objectData.country << "; " << objectData.userId << "; " << objectData.netId << "; " << endl; 219 | objectData.isMod = true; 220 | } 221 | 222 | 223 | 224 | if (actuallyOwner) cout << "Owner netID has been updated to " << objectData.netId << " username is " << ownerUsername; 225 | objects.push_back(objectData); 226 | //SendPacket(2, "action|input\n|text|`3Hello " + name + " `3with id " + netid + " from " + country + "! Your Growtopia ID is "+uid, peer); 227 | } 228 | 229 | void GrowtopiaBot::OnAction(string command) 230 | { 231 | //SendPacket(2, "action|input\n|text|Why do you "+command.substr(1, command.length())+"?", peer); 232 | } 233 | 234 | void GrowtopiaBot::SetHasGrowID(int state, string name, string password) 235 | { 236 | 237 | } 238 | 239 | void GrowtopiaBot::SetHasAccountSecured(int state) 240 | { 241 | 242 | } 243 | 244 | void GrowtopiaBot::OnTalkBubble(int netID, string bubbleText, int type) 245 | { 246 | if (netID != owner) return; 247 | cout << bubbleText << endl; 248 | if (bubbleText.find("!pos") != string::npos) 249 | { 250 | for (ObjectData x : objects) 251 | { 252 | if (owner == x.netId) 253 | { 254 | SendPacket(2, "action|input\n|text|Owner pos is " + std::to_string(x.x) + ":" + std::to_string(x.y) + ".", peer); 255 | } 256 | } 257 | } 258 | if (bubbleText.find("!follow") != string::npos) 259 | { 260 | isFollowing = true; 261 | owner = netid; 262 | } 263 | if (bubbleText.find("!stop") != string::npos) 264 | { 265 | isFollowing = false; 266 | } 267 | if (bubbleText.find("!dance") != string::npos) 268 | { 269 | SendPacket(2, "action|input\n|text|/dance", peer); 270 | } 271 | if (bubbleText.find("!about") != string::npos || bubbleText.find("!help") != string::npos) 272 | { 273 | SendPacket(2, "action|input\n|text|This is bot from Growtopia Noobs. Modified my DrOreo002", peer); 274 | } 275 | } 276 | 277 | void GrowtopiaBot::SetRespawnPos(int respawnPos) 278 | { 279 | respawnX = respawnPos % 100; // hacky!!! TODO: get from world data (100) 280 | respawnY = respawnPos / 100; // hacky!!! TODO: get from world data (100) 281 | } 282 | 283 | void GrowtopiaBot::OnEmoticonDataChanged(int val1, string emoticons) 284 | { 285 | 286 | } 287 | 288 | void GrowtopiaBot::OnSetPos(float x, float y) 289 | { 290 | 291 | } 292 | 293 | void GrowtopiaBot::OnAddNotification(string image, string message, string audio, int val1) // You will see that when banned :( 294 | { 295 | 296 | } 297 | 298 | /* 299 | 300 | void GrowtopiaBot::OnFailedToEnterWorld() 301 | { 302 | 303 | } 304 | 305 | void GrowtopiaBot::OnSuperMainStartAcceptLogonFB211131ddf(int val1, string domain, string folder, string deniedApps, string settings) 306 | { 307 | 308 | } 309 | 310 | void GrowtopiaBot::OnSetBux(int val1, int val2, int val3) // missing params 311 | { 312 | 313 | } 314 | 315 | void GrowtopiaBot::OnZoomCamera(float val1, int val2) 316 | { 317 | 318 | } 319 | 320 | void GrowtopiaBot::OnGuildDataChanged(int val1, int val2, int val3, int val4) 321 | { 322 | 323 | } 324 | 325 | void GrowtopiaBot::OnFactionDataChanged(int val1, int val2, int val3, string data) 326 | { 327 | 328 | } 329 | 330 | void GrowtopiaBot::OnSetClothing(int hair, int shirt, int pants, int feet, int face, int hand, int back, int mask, int necklace, int val1, int val2, int val3, int val4) 331 | { 332 | 333 | }*/ 334 | 335 | void GrowtopiaBot::AtApplyTileDamage(int x, int y, int damge) 336 | { 337 | cout << "Damage " + std::to_string(damge) + " applied at X:" + std::to_string(x) + " Y: " + std::to_string(y) << endl; 338 | } 339 | 340 | void GrowtopiaBot::AtApplyLock(int x, int y, int itemId) // ApplyLockFromGamePacket TODO: *(int*)(data + 4) 341 | { 342 | SendPacket(2, "action|input\n|text|Lock " + std::to_string(itemId) + " applied at X:" + std::to_string(x) + " Y: " + std::to_string(y), peer); 343 | } 344 | 345 | void GrowtopiaBot::AtPlayerMoving(PlayerMoving* data) 346 | { 347 | int object = -1; 348 | //cout << std::hex << data->characterState << "; " << data->x << "; " << data->y << "; "<< data->XSpeed << "; "<< data->plantingTree << endl; 349 | for (int i = 0; i < objects.size(); i++) 350 | { 351 | if (objects.at(i).netId == data->netID) 352 | { 353 | object = i; 354 | } 355 | } 356 | if (object != -1) 357 | { 358 | objects[object].x = data->x; 359 | objects[object].y = data->y; 360 | } 361 | if (isFollowing && data->netID == owner && data->punchX == -1 && data->punchY == -1 && data->plantingTree == 0) // <--- bypass - can get banned from character state!!!, replacing isnt enought 362 | { 363 | if (backwardWalk) 364 | data->characterState ^= 0x10; 365 | if ((data->characterState & 0x800) && (data->characterState & 0x100)) { 366 | SendPacket(2, "action|respawn", peer); 367 | } 368 | for (int i = 0; i < objects.size(); i++) 369 | if (objects.at(i).isLocal) { 370 | objects.at(i).x = data->x; 371 | objects.at(i).y = data->y; 372 | } 373 | SendPacketRaw(4, packPlayerMoving(data), 56, 0, peer, ENET_PACKET_FLAG_RELIABLE); 374 | } 375 | } 376 | 377 | void GrowtopiaBot::AtAvatarSetIconState(int netID, int state) // if player goes BRB, etc... 378 | { 379 | 380 | } 381 | 382 | void GrowtopiaBot::WhenConnected() 383 | { 384 | cout << "Connected to server!" << endl; 385 | } 386 | 387 | void GrowtopiaBot::WhenDisconnected() 388 | { 389 | cout << "Disconnected from server..." << endl; 390 | connectClient(); 391 | } 392 | 393 | int counter = 0; // 10ms per step 394 | 395 | vector explode(const string &delimiter, const string &str) 396 | { 397 | vector arr; 398 | 399 | int strleng = str.length(); 400 | int delleng = delimiter.length(); 401 | if (delleng == 0) 402 | return arr;//no change 403 | 404 | int i = 0; 405 | int k = 0; 406 | while (i < strleng) 407 | { 408 | int j = 0; 409 | while (i + j < strleng && j < delleng && str[i + j] == delimiter[j]) 410 | j++; 411 | if (j == delleng)//found delimiter 412 | { 413 | arr.push_back(str.substr(k, i - k)); 414 | i += delleng; 415 | k = i; 416 | } 417 | else 418 | { 419 | i++; 420 | } 421 | } 422 | arr.push_back(str.substr(k, i - k)); 423 | return arr; 424 | } 425 | 426 | void GrowtopiaBot::userLoop() { 427 | if (timeFromWorldEnter > 200 && currentWorld != worldName) { 428 | if (worldName == "" || worldName == "-") { 429 | timeFromWorldEnter = 0; 430 | } else { 431 | SendPacket(3, "action|join_request\nname|" + worldName, peer); // MARRKS 432 | objects.clear(); 433 | } 434 | timeFromWorldEnter = 0; 435 | currentWorld = worldName; 436 | } 437 | timeFromWorldEnter++; 438 | counter++; 439 | if ((counter % 1800) == 0) 440 | { 441 | string name = ""; 442 | float distance = std::numeric_limits::infinity(); 443 | float ownerX; 444 | float ownerY; 445 | for (ObjectData x : objects) 446 | { 447 | if (x.netId == owner) 448 | { 449 | ownerX = x.x; 450 | ownerY = x.y; 451 | } 452 | } 453 | } 454 | } 455 | 456 | void GrowtopiaBot::userInit() { 457 | connectClient(); 458 | cout << flush; 459 | } 460 | 461 | void GrowtopiaBot::respawn() 462 | { 463 | PlayerMoving data; 464 | data.characterState = 0x924; // animation 465 | SendPacket(2, "action|respawn", peer); // respawn request 466 | for (int i = 0; i < objects.size(); i++) 467 | if (objects.at(i).isLocal) 468 | { 469 | data.x = objects.at(i).x; 470 | data.y = objects.at(i).y; 471 | data.netID = objects.at(i).netId; 472 | SendPacketRaw(4, packPlayerMoving(&data), 56, 0, peer, ENET_PACKET_FLAG_RELIABLE); 473 | cout << "Send" << endl; 474 | break; 475 | } 476 | } 477 | -------------------------------------------------------------------------------- /CPPBot/utilsfunc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | using namespace std; 7 | 8 | namespace patch 9 | { 10 | template < typename T > std::string to_string(const T& n) 11 | { 12 | std::ostringstream stm; 13 | stm << n; 14 | return stm.str(); 15 | } 16 | } 17 | 18 | int GetApp() 19 | { 20 | return 0xA2Cu; 21 | } 22 | 23 | unsigned int HashString(const char *str, int len) 24 | { 25 | if (!str) return 0; 26 | 27 | unsigned char *n = (unsigned char *)str; 28 | unsigned int acc = 0x55555555; 29 | 30 | if (len == 0) 31 | { 32 | while (*n) 33 | acc = (acc >> 27) + (acc << 5) + *n++; 34 | } 35 | else 36 | { 37 | for (int i = 0; i < len; i++) 38 | { 39 | acc = (acc >> 27) + (acc << 5) + *n++; 40 | } 41 | } 42 | return acc; 43 | } 44 | 45 | int GetDeviceHash(string deviceId) 46 | { 47 | string v8 = deviceId; 48 | int v3; 49 | v8 += patch::to_string(GetApp() + 2280); 50 | v8 += "RT"; 51 | v3 = HashString(v8.c_str(), 0); 52 | return v3; 53 | } 54 | 55 | 56 | int GetDeviceSecondaryHash(string macAddr) 57 | { 58 | int v1; 59 | string v3 = ""; 60 | for (std::string::size_type i = 0; i < macAddr.length(); ++i) 61 | v3 += tolower(macAddr[i]); 62 | v3 += "RT"; 63 | v1 = HashString(v3.c_str(), 0); 64 | return v1; 65 | } 66 | 67 | string createLoginData(string swearFilter, string protocol, string gameVer, string fz, string lmode, string 68 | 69 | cbits, string hash2, string meta, string fhash, string rid, string platformID, string deviceVersion, string 70 | 71 | country, string hash, string mac, string wk) 72 | { 73 | string loginPacket; 74 | loginPacket = "f|"; 75 | loginPacket += swearFilter; 76 | loginPacket += "\n"; 77 | loginPacket += "protocol|"; 78 | loginPacket += protocol; 79 | loginPacket += "\n"; 80 | loginPacket += "game_version|"; 81 | loginPacket += gameVer; 82 | loginPacket += "\n"; 83 | loginPacket += "fz|"; 84 | loginPacket += fz; 85 | loginPacket += "\n"; 86 | loginPacket += "lmode|"; 87 | loginPacket += lmode; 88 | loginPacket += "\n"; 89 | loginPacket += "cbits|"; 90 | loginPacket += cbits; 91 | loginPacket += "\n"; 92 | loginPacket += "hash2|"; 93 | loginPacket += hash2; 94 | loginPacket += "\n"; 95 | loginPacket += "meta|"; 96 | loginPacket += meta; 97 | loginPacket += "\n"; 98 | loginPacket += "fhash|"; 99 | loginPacket += fhash; 100 | loginPacket += "\n"; 101 | loginPacket += "rid|"; 102 | loginPacket += rid; 103 | loginPacket += "\n"; 104 | loginPacket += "platformID|"; 105 | loginPacket += platformID; 106 | loginPacket += "\n"; 107 | loginPacket += "deviceVersion|"; 108 | loginPacket += deviceVersion; 109 | loginPacket += "\n"; 110 | loginPacket += "country|"; 111 | loginPacket += country; 112 | loginPacket += "\n"; 113 | loginPacket += "hash|"; 114 | loginPacket += hash; 115 | loginPacket += "\n"; 116 | loginPacket += "mac|"; 117 | loginPacket += mac; 118 | loginPacket += "\n"; 119 | loginPacket += "wk|"; 120 | loginPacket += wk; 121 | loginPacket += "\n"; 122 | return loginPacket; 123 | } 124 | 125 | /*void SendPacketRaw(int a1, void *a2, size_t a3, void *a4, ENetPeer* a5, int a6) 126 | { 127 | ENetPacket *v6; 128 | ENetPacket *v7; 129 | 130 | if (a5) 131 | { 132 | if (a1 == 4 && *((BYTE *)a2 + 12) & 8) 133 | { 134 | v7 = enet_packet_create(0, a3 + *((DWORD *)a2 + 13) + 5, a6); 135 | *(DWORD *)v7->data = 4; 136 | memcpy((char *)v7->data + 4, a2, a3); 137 | memcpy((char *)v7->data + a3 + 4, a4, *((DWORD *)a2 + 13)); 138 | enet_peer_send(a5, 0, v7); 139 | } 140 | else 141 | { 142 | v6 = enet_packet_create(0, a3 + 5, a6); 143 | *(DWORD *)v6->data = a1; 144 | memcpy((char *)v6->data + 4, a2, a3); 145 | enet_peer_send(a5, 0, v6); 146 | } 147 | } 148 | }*/ 149 | 150 | 151 | char* CreateGameUpdatePacketWithExtraDataAtEnd(int a1) 152 | { 153 | char* result = new char[a1 + 56]; 154 | 155 | *(DWORD *)result = 0; 156 | *(DWORD *)(result + 4) = 0; 157 | *(DWORD *)(result + 8) = 0; 158 | *(DWORD *)(result + 12) = 8; 159 | *(DWORD *)(result + 16) = 0; 160 | *(DWORD *)(result + 20) = 0; 161 | *(DWORD *)(result + 24) = 0; 162 | *(DWORD *)(result + 28) = 0; 163 | *(DWORD *)(result + 32) = 0; 164 | *(DWORD *)(result + 36) = 0; 165 | *(DWORD *)(result + 40) = 0; 166 | *(DWORD *)(result + 44) = 0; 167 | *(DWORD *)(result + 48) = 0; 168 | *(DWORD *)(result + 52) = a1; 169 | return result; 170 | } 171 | 172 | 173 | 174 | std::string colorstr(string str) 175 | { 176 | string chrs = "0123456789bwpo^$#@!qertas"; 177 | string s; 178 | for (int i = 0; i < str.length(); i++) 179 | { 180 | s += "`"; 181 | char* x; 182 | x = (char*)malloc(2); 183 | x[0] = chrs[rand() % chrs.length()]; 184 | x[1] = 0; 185 | string y = x; 186 | s += y; 187 | free(x); 188 | s += str[i]; 189 | } 190 | return s; 191 | } 192 | 193 | std::string colorstr2(string str) 194 | { 195 | string chrs = "0123456789bwpo^$#@!qertas"; 196 | char* x; 197 | x = (char*)malloc(2); 198 | x[0] = chrs[rand() % chrs.length()]; 199 | x[1] = 0; 200 | string y = x; 201 | free(x); 202 | return "`" + y + str; 203 | } 204 | 205 | 206 | /*string text_encode(char* text) 207 | { 208 | string ret = ""; 209 | while (text[0] != 0) 210 | { 211 | switch (text[0]) 212 | { 213 | case '\n': 214 | ret += "\\n"; 215 | break; 216 | case '\t': 217 | ret += "\\t"; 218 | break; 219 | case '\b': 220 | ret += "\\b"; 221 | break; 222 | case '\\': 223 | ret += "\\\\"; 224 | break; 225 | case '\r': 226 | ret += "\\r"; 227 | break; 228 | default: 229 | ret += text[0]; 230 | break; 231 | } 232 | text++; 233 | } 234 | return ret; 235 | }*/ 236 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # gtcppbot 2 | 3 | updated version of https://github.com/DrOreo002/GrowtopiaBot 4 | --------------------------------------------------------------------------------