Pesquisar na Comunidade

MEUS CANAIS DE VÍDEOS HC CURSOS E TUTORIAIS 🎬 ▶️ PLAYLIST DO MEU CANAL NO YOUTUBE 🎬 ▶️ VEICARECA GAMES 🎬 ▶️ PLAYLIST DO MEU CANAL NO YOUTUBE 🎬 ▶️

HC CURSOS E TUTORIAIS 🎬 ▶️ PLAYLIST DO MEU CANAL NO YOUTUBE 🎬 ▶️ 📝 Descrição: 🛡️ Proteção Máxima no WYD! 🚀 E aí, pessoal! No vídeo de hoje, vou mostrar passo a passo como criei um sistema de segurança ultraeficiente para o game WYD! 🎮💻 Esse sistema inclui validação de GM por nome do personagem e IP de acesso, garantindo que apenas usuários autorizados tenham controle total! 🔒🤖 👉 O que você vai ver no vídeo: ✅ Como implementar o "Muro de Proteção" 🏰 - uma camada extra de segurança que todo servidor deveria ter! ✅ Validação dupla: por IP de acesso 🌐 e nome do char 🧙, evitando invasões e brechas! ✅ Dicas de otimização para manter seu servidor seguro sem perder performance! ⚡ ✅ Por que esse sistema é essencial para evitar hacks e golpes? 🔥 📌 Se você é dono de servidor WYD, não pode perder essa! Esse sistema pode salvar seu jogo de invasões e trapaças! 💪 👉 Não se esqueça: Deixe seu like 👍, 🔔inscreva-se no canal e ative o sininho 🔔 👉para não perder os próximos tutoriais! 💬 Comente abaixo: O que você faz para proteger seu servidor? Vamos trocar ideias! 🗨️ [Hidden Content]

Fala pessoal, estou em buscar de ampliar meus conhecimentos, sobre programação. Uma parte que estou bastante impressionado é a área sobre criação de cheats e engenharia reversa, achei muito legal e quero me aprofundar nesse mundo pois acho muito interessante e acho que isso é mais para pessoas curiosas igual eu né kkk mais, então quem tiver tutoriais, materiais para aprender aqui no fórum e quiser me recomendar, agradeço pessoal. Agora to "aprendendo" porque não sei tudo né mais em C++ to aprendendo na marra pois vim do Python. Criei meu primeiro "HACKER", leitor de memoria para ler a vida de um personagem em um jogo multi-player, onde não tem como ver a vida do personagem, ai quando deu certo, vem aquela sensação boaa e curti muito to querendo aprender mais e mais nessa área que sei que muitos de vocês domina e quero chegar lá também. Abraços

C++ é uma linguagem de programação poderosa e complexa, conhecida por sua eficiência e controle preciso sobre os recursos do sistema. Com uma trajetória de 15 anos dedicados a essa linguagem, tenho uma visão abrangente e profunda sobre seus desafios e recompensas. Neste artigo, compartilho meus insights e conselhos para aqueles que estão começando sua jornada em C++. Começando a Programar: Não Se Limite Quando se inicia em programação, é fácil ficar preso em "qual a melhor linguagem para aprender". No entanto, é importante lembrar que o mais importante é simplesmente começar. C++, apesar de suas complexidades, pode ser uma excelente escolha para iniciar. A aprendizagem de suas nuances pode proporcionar uma base sólida para entender conceitos fundamentais de programação. A Jornada é Mais Importante do que o Destino Durante meus primeiros anos de programação, percebi a importância de focar no processo de aprendizagem, em vez de buscar a perfeição desde o início. Escrever "códigos ruins" e cometer erros é parte essencial do processo de aprendizagem. Cada erro é uma oportunidade para melhorar e compreender mais profundamente a linguagem. Desenvolvendo a Mentalidade Certa A mentalidade de um programador bem-sucedido é moldada pela persistência e curiosidade. Enfrentar desafios e resolver problemas complexos é o cerne da programação. Em C++, você encontrará desafios únicos que testarão sua capacidade de pensar criticamente e de forma inovadora. A Importância da Prática A prática constante é crucial. Trabalhar em projetos reais, mesmo que pequenos, ajuda a consolidar os conhecimentos adquiridos. Essa experiência prática é inestimável, pois a programação é uma habilidade que se aprimora com a aplicação contínua. Conclusão Ao olhar para trás, nos meus 15 anos de experiência em C++, reconheço que cada desafio enfrentado foi uma oportunidade de crescimento. Para os novos programadores, minha principal dica é mergulhar de cabeça na linguagem que escolherem e desfrutar da jornada de aprendizado. Com persistência e paixão, o caminho na programação pode ser incrivelmente gratificante.

Sei que esse conteudo é muito procurado no brasil, e por conta da escassez desse conteudo ensinado no brasil vou ta passando umas dicas de como começar! Lembrando, estou passando uma base para o começo de voces não é nada muito profissional. 1- Estude lógica de programação, algoritmos e etc , isso vc pode encontrar no canal "CURSO EM VIDEO" 2- De uma olhada no site Guidehacking, la eles tambem dão umas instruçoes (nao sei se posso deixar o link dos sites mas é só procurar pelos nomes) 3-Estude C++ que é a principal coisa! estude ela direitinho nem que seja por 1 bom tempo, o C++ é o pilar para o aprendizado de game hacking. Voce pode estudar C++ pelo canar do "Fessor Bruno" no YT! Tambem existe um site gringo chamado Learncpp que tambem é muito bom para aprender c++ 4-Estude C (opcional) C é quase a mesma coisa que C++ somente com algumas diferenças, mas voce pode aprender tambem, até pq muitos cheats são feitos com C tambem! Curso de C voce pode encontrar no canal "Papo binario" Agora voce ja pode avançar 1 pouco e começar a Estudar gamehacking Canais como GuideHacking, Smoll Ice, voce pode pegar 1 base e começar a estudar, Alguns canais são ingles, mas ligando a legenda da pra entender. Forums Como a unknowncheats, A propia webcheats pode te ajudar nisso. Procure, garimpa os conteudos em qualquer forum e site ou canal que achar !! "Ah mas eu não sei ingles" FDS Traduz! Faça algo corra atras do que vc quer! lembrando o ingles é muito importante no aprendizado de gamehacking querendo ou não voce precisa de 1 conhecimento Voce pode estudar 1 pouco mais avançado tambem, Como assemply, analise de malware online, Engenharia reversa e ETC, isso voces podem encontrar no canal "Papo Binario" e em sites como "Mente binaria" Lembrando isso que estou passando é o Básico Para começar, não é nada de muito demais! E se eu falei alguma merd* Podem corrigir e dar a opnião de vcs até pq não sou nenhum profissional! Boa Sorte nessa jornada Guerreiro! caso alguma duvida meu discord é gl0769 (desculpe meu portugues)

Recentemente estava trabalhando em um trainer interno para Grand Chase, mas acabei perdendo o interesse que tinha no jogo e comeceio outros projetos. Esta é a base do código que estava usando, também foi usada parcialmente em outro tópico que criei na área de CS:GO. Como acho que pode ser útil para outras pessoas, resolvi postar. Ele é baseado nos tutoriais encontrados na Guided Hacking e levemente modificado para atender minhas necessidades. Espero que possa servir de material de estudo para quem está tentando aprender. Se precisarem de alguma coisa relacionada a Game Hacking, meu Discord normalmente fica na minha assinatura e também no meu perfil. Espero que não esteja muito confuso, aqui está. #include "pch.h" #include "windows.h" #include <cstdio> #include <iostream> using namespace std; #define MakeJump(f, t) (int)(((int)t - (int)f) - 5) uintptr_t HackFunction = 0x871E3A; uintptr_t HackFunctionOriginalCode = 0x0F2F8230070000; int HackFunctionLen = 7; uintptr_t HackFreeze = 0x871E3A; //uintptr_t moduleBase = (uintptr_t)GetModuleHandle(L"game.exe"); uintptr_t moduleBase = (uintptr_t)GetModuleHandle(NULL); uintptr_t HackFunctionAddress = moduleBase + HackFunction; uintptr_t HackFunctionJmpBack = HackFunctionAddress + HackFunctionLen; uintptr_t HackFreezeAddress = moduleBase + HackFreeze; void __declspec(naked) HackFunctionCave(void) { __asm { push eax mov eax, 0x00000000 mov[edx + 0x0000730], eax pop eax comiss xmm0, [edx + 0x0000730] jmp HackFunctionJmpBack } } void doHook(uintptr_t CodeAddr, int len, uintptr_t HookAddr) { DWORD dwOldProtect = NULL; ::VirtualProtect((LPVOID)CodeAddr, len, PAGE_EXECUTE_READWRITE, &dwOldProtect); memset((BYTE*)(CodeAddr), 0x90, len); BYTE* btJmpCave = (BYTE*)CodeAddr; *(BYTE*)btJmpCave = 0xE9; *(int*)(btJmpCave + 1) = MakeJump(btJmpCave, HookAddr); ::VirtualProtect((LPVOID)CodeAddr, len, dwOldProtect, 0); } void doPatch(uintptr_t CodeAddr, int len, DWORD bytesToPatch) { DWORD dwOldProtect = NULL; ::VirtualProtect((LPVOID)CodeAddr, len, PAGE_EXECUTE_READWRITE, &dwOldProtect); *(int*)(CodeAddr) = bytesToPatch; ::VirtualProtect((LPVOID)CodeAddr, len, dwOldProtect, 0); } void doNop(uintptr_t CodeAddr, int len) { DWORD dwOldProtect = NULL; ::VirtualProtect((LPVOID)CodeAddr, len, PAGE_EXECUTE_READWRITE, &dwOldProtect); memset((BYTE*)(CodeAddr), 0x90, len); ::VirtualProtect((LPVOID)CodeAddr, len, dwOldProtect, 0); } void ActivateHack() { doHook(HackFunctionAddress, HackFunctionLen, (uintptr_t)HackFunctionCave); } void DeActivateHack() { doPatch(HackFunctionAddress, HackFunctionLen, HackFunctionOriginalCode); } void ConstantValues() { /* if (somehack == true) { charPosX = func(1, -1, maxMapX, 0, pointerPosX); charPosY = func(1, -1, 4, -0.5, pointerPosY); } */ } void FreezeValues() { *(float*)(HackFreezeAddress + 1) = (float)999; } DWORD WINAPI HackThread(HMODULE hModule) { while (true) { if (GetAsyncKeyState(VK_END) & 1) { ActivateHack(); } ConstantValues(); FreezeValues(); } FreeLibraryAndExitThread(hModule, 0); return 0; } BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved ) { switch (ul_reason_for_call) { case DLL_PROCESS_ATTACH: CloseHandle(CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)HackThread, hModule, 0, nullptr)); case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: case DLL_PROCESS_DETACH: break; } return TRUE; } O post mencionado no início do tópico é este, e ele contém a source específica para o CSGO.

Engine : Source EntList : nó de ponteiros AntCheat: não tem (desculpe pelo português não é minha língua original) Olá , ultimamente estou tentando criar um "radar" , algo que converta a posição x , y dos meus enimig e jogue em um plano cartesiano 2d 100 por 100 (Quadrado) desenhado com o direct X algo bem simples porém com minha falta de conhecimento acabei me metendo em alguns problemas matematicos... Teoria: injetar a dll (OK) hookar o end scene (OK) Desenhar um quadrado 2d 100 por 100 (ok) pegar a list da entidades (OK) Calcular a distancia entre o player e o enimig (ok) Converter a distancia para 2d no meu quadrado 100 por 100(Problemas...) desenhar uma pequena box vermelha que vai ser o meu enemig. desenhar a box vermelha na tela (boxEnemigDraw= centroQuadrado + distancia) Sei que a teoria ainda não esta boa e gostaria que alguém me ajudasse a melhorar ela. bom alguém de bom coração poderia me explicar se minha ideia esta correta e como eu poderia pegar essa distancia entre o player e o enimig e jogar nesse quadrado 100x100 apenas uma ajuda teórica e math.h Deis de já agradecido !

Introdução Como o site que eu uso está sem a função do Encrypt Xor . Eu resolvi fazer a minha, tem algumas limitações mas funciona de boa. Programado em C++. Imagem Classe #ifndef XOR_H #define XOR_H #pragma once template < int XORSTART, int BUFLEN, int XREFKILLER> class XorStr { private: XorStr(); public: char s[bUFLEN]; XorStr(const char * xs); ~XorStr() { for (int i = 0; i < BUFLEN; i++) s[i] = 0; } }; template < int XORSTART, int BUFLEN, int XREFKILLER> XorStr < XORSTART, BUFLEN, XREFKILLER>::XorStr(const char * xs) { int xvalue = XORSTART; int i = 0; for (; i < (BUFLEN - 1); i++) { s[i] = xs[i - XREFKILLER] ^ xvalue; xvalue += 1; xvalue %= 256; } s[bUFLEN - 1] = 0; } #endif Download/Scan Mega VirusTotal Jotti

Estou estudando C++ e encontrei uma grande dificuldade em achar conteúdo sobre C++ relacionado a Game Hacking, e imagino que outro programadores e estudantes por aí também, então resolvi compartilhar este canal no YouTube que tem me ajudado bastante, com contúdo sobre C++, Cheat Engine e Assembly! [Hidden Content] Basta ir na aba de playlists que vai encontrar tudo que precisa pra fazer seu primeiro cheat! LEMBRANDO QUE O CONTEÚDO NÃO É MEU, SÓ RESOLVI COMPARTILHAR POIS IMAGINEI QUE PODE AJUDAR OUTRAS PESSOAS

Eai galera, decidi compartilhar um jogo que eu fiz no começo do ano como um trabalho na faculdade, ele é o jogo do Nim. Provavelmente poucas pessoas conhecem, mas é um jogo que se baseia em fileiras com uma quantidade x de algum item ( pedra, palito.. ), as pessoas devem retirar esses itens das fileiras até elas ficarem vazias, ai vence quem retirar o último item. Na realidade o jogo é bem flexível, você pode fazer as suas próprias regras, não existe uma regra "fixa", mas as que eu adotei foram as seguintes: - O jogo possui três fileiras, essas fileiras podem variar de 8 palitos a 20 ( para não ficar muito extenso ). - O jogador pode retirar quantos palitos quiser, porém deve escolher apenas 1 fileira para realizar a jogada ( não pode tirar de 2 ou 3 ao mesmo tempo ). - Quem tirar o(s) último(s) palito(s) ( você ou o computador ), vence. Algumas informações sobre o jogo / código : Caso você conheça o jogo e a sua lógica pra ganhar, eu não fiz usando a lógica da soma dos binários. O jogo é feito em C++ usando windows form ( CLR ). O jogo foi feito para Jogador X Computador, porém você pode facilmente alterar para ser Jogador X Jogador. Existe uma forma de ganhar nesse jeito que eu fiz, mas se eu falasse de cara não ia ter graça rs Os números em cima das imagens dos palitos é a quantidade de palitos restantes em cada fileira ( 1, 2 e 3 ). Valores diferentes de 1, 2 e 3 para as fileiras e valores <= 0 ou > quantidade de palitos, não serão contabilizados. Para jogar é simples : Apenas coloque o número da fileira ( 1, 2 ou 3 ), em seguida coloque a quantidade de palitos que você quer retirar e aperte no botão retirar. Imagem do Jogo : Download da source Scan Bom é isso galera, qualquer coisa só comentar ai ( coisas que podiam ser diferentes e tudo mais ). Flws.

Uma forma simples de injeção de DLL escrita em c++ Por : NiceGuy [Hidden Content]

Aqui tenho uma pasta de código fonte completa , ela precisara de uma atualização e exigirá um "bypass" "injetor" não detectado para o BattlEye . È um código fonte pra quem cria código internos em c++ OBS : Não me pergunte como usa , é especifico para quem usa c++ ou seja quem entende. BAIXAR [HIDE][Hidden Content]] Scan [Hidden Content] ------------------------------------------------------------------------------------------------------------------------------------------------ English : Posting a full source code for Fortnite. Obviously will likely need updating, and will require a working undetected bypass for BattlEye. Enjoy! Don't ask questions like "how to use this". This is source code for an internal C++ cheat, if you don't know C++, don't even bother . ------------------------------------------------------------------------------------------------------------------------------------------------ ESPERO AJUDAR

((Stride == 20) && NumVertices == 961 || NumVertices == 1773) || ((Stride == 36) && NumVertices == 557 || NumVertices == 1299 || NumVertices == 1773 || NumVertices == 1843 || NumVertices == 1839 || NumVertices == 2068) || ((Stride == 108) && NumVertices == 1561 || NumVertices == 1435 || NumVertices == 1358 || NumVertices == 4233 || NumVertices == 1253 || NumVertices == 2068 || NumVertices == 2369 || NumVertices == 1558 || NumVertices == 1459) SmoLL_iCe by the function of reading the strides, numvertices etc.

Salve galera, vou deixar aqui uma base Overlay que me ajudou muito, tem jogos que você não pode hookar uma Endscene ou Present, então oque nos resta é uma External Overlay, encontrei essa em um dos foruns gringos famoso que não irei citar o nome, e o bacana dele que a gente pode fazer meio que um Internal Overlay, ou seja ele ainda será overlay mas vai ser chamada dentro de sua DLL Link no GitHub [Aqui] (Baixe o projeto do github) Para usar é facil: Adicione a pasta "includes" no seu includes do projeto (No mesmo lugar onde voce adiciona os Includes do SDK do directX), e adicione os arquivos da pasta src no seu Projeto menos o arquivo main.cpp pois ele seria um entry point, mas como no meu caso e no de voces provavelmente será uma DLL, então pronto. Agora vamos adicionar o overlay no codigo, seguindo os passos da main.cpp, a gente tem : #include <render/Device2D.hpp> #include <render/Device3D9.hpp> using namespace render; std::unique_ptr<Overlay> create_overlay(const EDeviceType type, const std::string& window_title) { auto overlay = Overlay::New(type); if (!overlay) { return nullptr; } if (!overlay->create(window_title)) { return nullptr; } auto surface = overlay->get_surface(); if (!surface) { return nullptr; } const auto is_d3d9 = type == EDeviceType::Direct3D9; if (!surface->add_font( "default", "Segoe UI", is_d3d9 ? 60 : 60, is_d3d9 ? FW_NORMAL : DWRITE_FONT_WEIGHT_NORMAL, /// or DEFAULT_QUALITY instead of PROOF_QUALITY for anti aliasing is_d3d9 ? PROOF_QUALITY : DWRITE_FONT_STRETCH_NORMAL )) { return nullptr; } return std::move(overlay); } void tOverlay() { std::unique_ptr<Overlay> overlay = nullptr; overlay = create_overlay(EDeviceType::Direct3D9, "Plants vs. Zombies"); auto* callback = overlay->add_callback( "test", [](Surface* D3D) { D3D->text(5, 5, "default", 0xFFFFFFFF, "Plants vs Zombie Test"); //Desenhos } ); if (!callback) { exit(1); } while (overlay->render()) { //time std::this_thread::sleep_for(std::chrono::milliseconds(100)); } overlay->shutdown(); } Para chamar a funçao acima é facil, la no seu DLLMain voce Adiciona uma linha para criar a uma thread da funçao tOverlay() como : CreateThread(0, 0, (LPTHREAD_START_ROUTINE)tOverlay, 0, 0, 0); E pronto agora é só desenhar suas ESP ou Fazer seu menu, aqui um simples teste meu: kkk o Teste foi no plants vs zombie, caso queiram saber como peguei a Pos dos zombie, eu criei uma hook nesse endereço 0x544B58 o valor de ecx é onde passa os endereços dos zombies: __declspec(naked) HRESULT WINAPI HookZombies { static DWORD dZombie = 0x0; __asm { mov eax, [edi + 0x6C] fadd dword ptr[esp + 0x30] xor ebx, ebx mov dZombie, ecx PUSHAD } if (dZombie != 0x0) AdicionarZombie(dZombie); __asm { POPAD JMP dwFimHook } } class cZombie { public: DWORD Base; DWORD dwPosX; DWORD dwPosY; cZombie(DWORD ptr) { Base = ptr; dwPosX = Base + 0x2C; dwPosY = Base + 0x30; } Vec2 GetPos() { return Vec2(*(float*)(dwPosX), *(float*)(dwPosY)); } void SetPos(Vec2 pos) { *(float*)dwPosX = pos.X; *(float*)dwPosY = pos.Y; } }; É isso pessoas até mais!

Olá galera, tudo bom? Então, trago-lhes vários vídeos para você começar a criar seu menu D3D! [Hidden Content]

Vim trazer uma sere de conteúdos para quem ta querendo uma direção em Game Hackng. vendo que vieram me pergunta sobre o assunto. OBS: Estão em ingles mas quem ta interessado não liga Se tiver bastante acesso ou LIKE no post trago em português ^^ Bons estudos !!! [HIDE-THANKS] #1 Introdução / Como começar, Endereços e estruturas de memória #2 Introdução / Como começar, Endereços e estruturas de memória #3 Leitura e escrita / Alteração de valores de endereço de memória #4 Como fazer um "Bunny Hop" para CS:GO Hack Tutorial #5 Como fazer um Triggerbot para CS:GO Hack Tutorial #6 Como fazer um ESP Glow para CS:GO Hack Tutorial ( Testado ) Memoria a partir da qui !!! #7 Como encontrar endereços e offsets estáticos da memória com o Cheat Engine para qualquer jogo #8 Como fazer um trainer ( memory ) para qualquer jogo #9 Como fazer Pointer Scan Memory para qualquer jogo com Cheat Engine EP1 #10 Como fazer Pointer Scan Memory para qualquer jogo com Cheat Engine EP2[/HIDE-THANKS][HIDE-THANKS] [/HIDE-THANKS] Depois trago um para quem quer fazer ambot para FPS ( First Person Shooter ) Para esses tutoras tenha ao menos noções bascas de programação !!! (ADMs se estiver algo errado ou fora das regras avise aqui que estarei editando ou removendo algo) Quem quiser aulas de C#, C++, VB.net entre outros todos em português brasileiro por um professor pede aqui e já da aquela voadora no peito do LIKE !!!

Tutorial: uma pequena introdução ao C ++ INTRODUÇÃO Este tutorial abrangerá apenas alguns dos principais conhecimentos. Depois de lê-lo completamente você deve ser capaz de criar seus próprios programas pequenos, conhecer os conceitos básicos de codificação C ++, e poder usar essa base para continuar e experimentar mais a linguagem Então, definitivamente não vou entrar em detalhes, como sobre quantos bytes um certo tipo de dados usa. REQUISITOS Para compilar o código C ++, você precisará de um debugger, os dois mais conhecidos são Borland e Visual Studio, você pode encontrá-los na net. INICIO 1. Tipos de dados Como qualquer outra linguagem de programação, o C ++ usa tipos de dados para armazenar valores e informações. Aqui você pode encontrar uma pequena lista dos tipos de dados mais usados. Int (valor inteiro) Float (valor decimal) Char (apode ser utilizado para criar strings de caracteres) Bool (boolean, e o topo mais simples pode armazena apenas dois valores verdadeiro ou falso "true and false") OBS: Não vou discutir Vector e String aqui, pois existem infinitas possibilidades com eles e Seria preciso algum tempo para escrever tudo isso. Quando você codifica e deseja armazenar um valor, você terá que conhecer duas coisas. Em primeiro lugar, que tipo de dados a variável deve ser capaz de lidar? Segundo, Qual será a variável chamada? É assim que você declara esses quatro tipos de dados. int EsseEumValorInteiro; float EsseEumValorDecimal; char EssaEumaVariavelDeCaracteres; bool EstaEumBooleano; Como você pode vê, primeiro escreva o tipo de dados, depois disso, é o nome e em seguida você tem que terminar a declaração com um " ; " Agora criamos um lugar em que podemos colocar dados, mas até agora ainda não colocamos nenhum. int EsseEumValorInteiro = 0; float EsseEumValorDecimal = 0.0; char EssaEumaVariavelDeCaracteres = "test"; bool EstaEumBooleano = False; 2. Declarações No próximo tópico, vou mostrar-lhe como escrever o seu primeiro programa com base nestas duas declarações. Além disso, a declaração ELSE, a afirmação IF pode ser autônoma e só pode ser usada de uma maneira. A declaração else também pode ser usada em uma combinação de ambas as afirmações. Estas são as duas possibilidades: if ( ... ) { } else { } & if ( ... ) { } else if ( ... ) { } else { } Quando você usa a declaração ELSE, as duas ações nunca serão executadas ao mesmo tempo. Como você pode ter adivinhado, o código que deve ser executado quando uma determinada ação retorna verdadeiro deve ser colocado entre os dois suportes. Então, agora sabemos onde colocar a ação, mas ainda não o que podemos fazer onde os pontos estão situados. Isto é um exemplo de como você usaria isso com um BOOLEANO. bool test=false; if ( test ) { // test is true /* test is true */ } else { // test is false /* test is false */ } O sinal "//" é usado para colocar comentários em seu código, como você pode ver, você também pode usar o sinal "/ *" e "* /". (Sem os espaços) O código acima é uma maneira de verificar se um booleano é verdadeiro ou falso. Compare todos os tipos de dados que foram construídos nos sinais que você pode usar, aqui eu dou uma lista muito pequena: == equal to != not equal to > bigger < smaller >= bigger or equal <= smaller or equal 2.2. For-loop Você pode usar este loop quando quiser que uma determinada ação seja executada várias vezes, ou use-a para loop através de várias variáveis. Este é um exemplo de como você o usa. for (int i=0; i<=10; i++) { } Como você pode ver, há três partes principais no loop. O primeiro "int i = 0" define a variável Isso mudará seu valor. A segunda parte "i <= 10" é onde você define o quão longe deve fazer o loop, aqui vai de 0 a 10, pois definimos a variável como 0. O último "i ++" é a contagem real Você também pode usar "i--" ou qualquer outra ação que você gostaria. 3. Funções As funções são muito importantes para escrever programas. Meu exemplo de função será chamado de "main". Estou escolhendo esse nome porque todos os programas, tudo o que você escreve, precisam de uma função main ou função principal se for traduzi-lo. Sem ele, você não pode execute o código do seu programa. Este é o exemplo: void main( ) { } A primeira palavra escrita é "void" ou vazia, afirma que a função não retorna nenhum valor. E como você pode saber, "main" é o nome da função. Agora vou mostrar um exemplo que contém vários aspectos novos. int testFunction( int temp ) { return temp; } Agora, a primeira palavra escrita é "int", que se refere ao valor inteiro. Isso significa que a função irá reter um valor inteiro. Fazemos isso usando o "return", e neste exemplo retornamos "temp". "temp" é a nossa contribuição, que recebemos quando a função é chamada. Este é um exemplo de uma função normal. int test = 0; testXFunction( test ); Como você pode ver nossa entrada agora é "test" que contém o valor 0. Agora, quando usamos uma função com um valor de retorno inteiro e deseja armazenar a saída dessa função. Então nossa chamada pode parecer assim: int test = 1; int output = testFunction( test ); 4. Exemplo de código float sum( float input1, float input2 ) { float temp = input1 + input2; return temp; } void main ( ) { float var1, var2; float outputValue; cout << "Input float value 1:" << endl; cin >> var1; cout << "Input float value 2:" << endl; cin >> var2; outputValue = sum( var1, var2 ); cout << "Sum: " << outputValue << endl; } Você deve poder ler e entender ambas as funções. As únicas coisas novas que ainda não expliquei basicamente são "cout", "cin" e "endl". O cout significa saída, você pode exibir texto, variáveis e todos os outros tipos de tipos de dados com ele. O segundo (cin) é usado para escrever entrada para variáveis. E o endl cmd apenas leva uma nova linha após o seu texto / variáveis foram exibidas. Você deve mexer com alguns desses pequenos códigos para tentar entender o código melhor e aprender com seus próprios erros. Se deixa seu CURTIR no tópico agradeço e também saberei que esse tópico esta ajudando os membro assim podendo fazer ate mesmo uma QuikList com vários recursos de estudos. Ate mais e bons estudos !!!

Ola, Gostaria de ajuda com o vbs2010, nececito montar uma call de loadlib com todas as dependencias do crossfire.exe. Apos pesquisar muito na internet, e tentar por diversos modos achei este e mais alguns modelos que estou tentando atualizar, porem nao estou conseguindo montar os cabecalhos stdio.h int _tmain(int argc, _TCHAR* argv[]) { return 0; } // A simple program that uses LoadLibrary and // GetProcAddress to access myPuts from Myputs.dll. #include <windows.h> #include <stdio.h> typedef int (__cdecl *MYPROC)(LPWSTR); int main( void ) { HINSTANCE hinstLib; MYPROC ProcAdd; BOOL fFreeResult, fRunTimeLinkSuccess = FALSE; // Get a handle to the DLL module. hinstLib = LoadLibrary(TEXT("crossfire.exe")); // If the handle is valid, try to get the function address. if (hinstLib != NULL) { ProcAdd = (MYPROC) GetProcAddress(hinstLib, "crossfire"); // If the function address is valid, call the function. if (NULL != ProcAdd) { fRunTimeLinkSuccess = TRUE; (ProcAdd) (L"Message sent to the DLL function\n"); } // Free the DLL module. fFreeResult = FreeLibrary(hinstLib); } // If unable to call the DLL function, use an alternative. if (! fRunTimeLinkSuccess) printf("Message printed from executable\n"); return 0; } sei que coisa de iniciante, porem eh exatamente essa minha situacao, e esse forum meu recurso.

[CENTER]Hello hehe Estou trazendo um programinha simples (Meu Primeiro) Peguei as aulas que o @HiroYuky postou e estou estudando... Para quem pretende conhecer C++ aconselho, o professor é foda pra krl kkk Eu mesmo não sabia NADA de C++ e olha ai já fiz um programa heheh [/CENTER] [CODE]#include <iostream> #include <cmath> using namespace std; int main(){ int a, b, c; int result; double Raiz; cout << "Resolutor de Formula de BHASKARA" << "\n\n"; cout << "Digite o valor de A: " << "\n"; cin >> a; cout << "Digite o valor de B: " << "\n"; cin >> b; cout << "Digite o varlod e C: " << "\n"; cin >> c; result = b * b +( - 4 * a * c); if (result >= 0){ Raiz = sqrt(result); result = -(b)+Raiz; result = result / (2 * (a)); cout << "Resultado: S:{" << -Raiz << ", " << +Raiz << "}" << "\n"; } else{ cout << "Nao e possivel solucionar uma raiz negativa: S = {" << result << "}" << "\n"; } system("pause"); return 0; }[/CODE] [CENTER]É um simples resolutor de formula de bhaskara ;)[/CENTER]

Segue um livro pra quem quer aprender a programar em C++. Info sobre o livro: Nome do Livro: Programando em C/C++ A Bíblia Páginas: 1.030 Autor: Kris J am s a , Ph .D. / Lars Klander Ano: 1998 Categoria: Programação Idioma: Português (Brasil) Formato/Tamanho: PDF/34,21 MB DOWNLOAD [HIDE-THANKS] [Hidden Content] [/HIDE-THANKS] Bons Estudos!

Pode ser utilizado para pausar processos para injetar Dll's ou pausar jogos para leitura da memória ,por exemplo. #include <Windows.h> #include <iostream> #include <TlHelp32.h> using namespace std; #pragma warning(disable:4996) int GetPID(char* Process_Name) { HANDLE hAndle; PROCESSENTRY32 pEntry32; hAndle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); ZeroMemory(&pEntry32, sizeof(PROCESSENTRY32)); pEntry32.dwSize = sizeof(PROCESSENTRY32); Process32First(hAndle, &pEntry32); char Name[40] = ""; do { wcstombs(Name, pEntry32.szExeFile, 40); if (!strcmp(Name, Process_Name)) { CloseHandle(hAndle); return pEntry32.th32ProcessID; } } while (Process32Next(hAndle, &pEntry32)); CloseHandle(hAndle); return 0; } int ThreadID(int PID,int *TIDs) // Retorna o número thread's { HANDLE hAndle; THREADENTRY32 tEntry32; hAndle = CreateToolhelp32Snapshot(TH32CS_SNAPALL, 0); ZeroMemory(&tEntry32, sizeof(THREADENTRY32)); tEntry32.dwSize = sizeof(THREADENTRY32); Thread32First(hAndle, &tEntry32); int i = 0; for (; Thread32Next(hAndle, &tEntry32);) { if (tEntry32.th32OwnerProcessID == PID) { if (TIDs != NULL) { TIDs[i] = tEntry32.th32ThreadID; } i++; } } CloseHandle(hAndle); return i; } int sSuspendThread(int * TIDs, int Numero_de_Threads) { for (int i = 0; i <= Numero_de_Threads; i++) { SuspendThread(OpenThread(THREAD_ALL_ACCESS, FALSE, TIDs[i])); } return 1; } int sResumeThread(int * TIDs, int Numero_de_Threads) { for (int i = 0; i <= Numero_de_Threads; i++) { ResumeThread(OpenThread(THREAD_ALL_ACCESS, FALSE, TIDs[i])); } return 1; } int main() { int TIDs[60]; int Length = ThreadID(GetPID("ProcessHacker.exe"), TIDs); bool OnOff = false; printf_s("Nome do processo: ProcessHacker.exe PID: %i Numero de Threads: %i \n", GetPID("ProcessHacker.exe"), ThreadID(GetPID("ProcessHacker.exe"), NULL)); while (true) { if (GetAsyncKeyState(VK_CONTROL) && OnOff == false) { Sleep(250); sSuspendThread(TIDs, Length); OnOff = !OnOff; cout << "Threads pausadas!" << endl; } if (GetAsyncKeyState(VK_CONTROL) && OnOff == true) { Sleep(250); sResumeThread(TIDs, Length); OnOff = !OnOff; cout << "Threads resumidas!" << endl; } } system("pause"); return 0; } Resultado:

An experienced programmer accumulates a set of tools, tricks, and techniques to make his or her programs better. C++ Hacker's Guide collects more than 120 of the best C++ veteran secrets and puts them in one accessible place. The techniques presented have all been used in actual programs, and more importantly, have made actual programs better. Full of real world, highly useful information, this book offers a career's worth of knowledge to round out any C++ programmer's repertoire. Topics include strategies to make code more memory safe, debuggable, efficient, and maintainable. [spoiler=Tradução Google] Um programador experiente acumula um conjunto de ferramentas, truques e técnicas para melhorar seus programas. C ++ Hacker's Guide recolhe mais de 120 dos melhores segredos do veterano C ++ e os coloca em um lugar acessível. As técnicas apresentadas foram usadas em programas reais, e mais importante, melhoraram os programas reais. Cheio do mundo real, informações altamente úteis, este livro oferece um valor de carreira de conhecimento para completar o repertório de um programador de C ++. Os tópicos incluem estratégias para tornar o código mais seguro da memória, devolvido, eficiente e sustentável. [HIDE-THANKS] [Hidden Content] [/HIDE-THANKS]

Essas aulas serão divididas em etapas hoje serão 10 aulas amanhã mais 10 depois mais 10 assim por diante todas em português. AVISO Observe que são aulas para aprender a programar em linguagem C/C++ da introdução ao avançado ou do Júnior passando pelo Pleno ate Sênior e todas são para estudos dependendo do seu conhecimento você e quem aplica em Game Hacking Bons estudos ^^ [HIDE-THANKS] Aula 03 - Estrutura básica de um programa em C++ Aula 04 - Variáveis em C++ Aula 05 - Declarações múltiplas de variáveis, Constantes #Define Aula 06 - Variáveis Globais e Locais, Operadores matemáticos Aula 07 - Incremento e Decremento de Variáveis, Operadores pós e pré-fixados Aula 08 - Invertendo valores de variáveis Aula 09 - Comando de decisão IF ELSE- Parte 1 Aula 10 - Comando de decisão IF ELSE e comando Goto - Parte 2 [/HIDE-THANKS] Espero que gostem e da LIKE se gosto do conteúdo ^^ quem gosta de web desenvolvimento deixa aqui nos comentários que trago conteúdo para CSS, HTML, HTML5 e PHP ^^ Votem para as próximas aulas Parte 2 click aqui

O source encontrado aqui e para estudos livre para seu estudo, uso de seus trechos ou modificá-lo para seus fins Não esta incluído o cabeçalho recomendo que tenha ao menos noções mais avançadas em c/c++ não iria adiantar nada entrar aqui sabendo 0% de c/c++ SOURCE cpp: #include <Windows.h> #include <Ntsecapi.h> #include "inj_defs.h" DWORD WINAPI InjectThread (LPVOID lpParam) { DllInjectData *pInfo = (DllInjectData*) lpParam; ExitThreadType pExitThread = (ExitThreadType)pInfo->pExitThread; GetStdHandleType pGetStdHandle = (GetStdHandleType)pInfo->pGetStdHandle; GetCurrentProcessIdType pGetCurrentProcessId = (GetCurrentProcessIdType)pInfo->pGetCurrentProcessId; CreateFileAType pCreateFileA = (CreateFileAType)pInfo->pCreateFileA; SleepType pSleep = (SleepType)pInfo->pSleep; itoaType pitoa = (itoaType)pInfo->pitoa; GetAsyncKeyStateType pGetAsyncKeyState = (GetAsyncKeyStateType)pInfo->pGetAsyncKeyState; sscanf_sType psscanf_s = (sscanf_sType)pInfo->psscanf_s; memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; bool Cyclefunc(DllInjectData *, HANDLE *, char*); void InitModules(DllInjectData *pInfo); void C_Config_LoadSettings(DllInjectData *); void _GetPrivateProfileStringF(DllInjectData *, LPCSTR , LPCSTR , float *, LPCSTR ); void _GetPrivateProfileStringI(DllInjectData *, LPCSTR , LPCSTR , int *, LPCSTR ); int elapsedTime(DWORD *sTimer, DWORD *sTaTimer, DWORD *eNtTimer, DllInjectData *pInfo); void Timer(DWORD *sTimer, DWORD *sTaTimer, DllInjectData *pInfo); void NormaaliAnglet( float angle[], DllInjectData *pInfo); bool arctg (float* arg, float *ret, DllInjectData *pInfo); bool arccos (float* arg, float *ret, DllInjectData *pInfo); bool GE (float* arg1, float* arg2, DllInjectData *pInfo ); bool IL (float* arg1, float* arg2, DllInjectData *pInfo ); bool IG (float* arg1, float* arg2, DllInjectData *pInfo ); int toInt (float* arg, DllInjectData *pInfo); bool toFloat(int arg, float *ret, DllInjectData *pInfo); //Classes class Vector { public: float x, y, z; memcpyType pmemcpy; Vector( void ) { } Vector( float *pX, float *pY, float *pZ, DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&(this->x),pX,sizeof(float)); pmemcpy(&(this->y),pY,sizeof(float)); pmemcpy(&(this->z),pZ,sizeof(float)); } Vector( float args[ 3 ] , DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&(this->x),&(args[ 0 ]),sizeof(float)); pmemcpy(&(this->y),&(args[ 1 ]),sizeof(float)); pmemcpy(&(this->z),&(args[ 2 ]),sizeof(float)); } Vector( Vector *v, DllInjectData *pInfo ) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&(this->x),&(v->x),sizeof(float)); pmemcpy(&(this->y),&(v->y),sizeof(float)); pmemcpy(&(this->z),&(v->z),sizeof(float)); } }; class CMath { public: void MakeVector(float *pfIn, float *pfOut, DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; float pitchasm; float yawasm; float tmpasm; float f180; pmemcpy(&f180,&(pInfo->t180),sizeof(float)); float pfIn0; pmemcpy(&pfIn0,&(pfIn[0]),sizeof(float)); float pfIn1; pmemcpy(&pfIn1,&(pfIn[1]),sizeof(float)); _asm { fldpi fmul pfIn0 fdiv f180 fstp pitchasm } _asm { fldpi fmul pfIn1 fdiv f180 fstp yawasm } _asm { fld pitchasm fcos fstp tmpasm } float pfOut0,pfOut1,pfOut2; float mone; pmemcpy(&mone,&(pInfo->n1),sizeof(float)); _asm { fld yawasm fcos fmul mone fstp pfOut0 fld tmpasm fmul mone fmul pfOut0 fstp pfOut0 } _asm { fld yawasm fsin fmul tmpasm fstp pfOut1 } _asm { fld pitchasm fsin fmul mone fstp pfOut2 } pmemcpy(&(pfOut[0]),&pfOut0,sizeof(float)); pmemcpy(&(pfOut[1]),&pfOut1,sizeof(float)); pmemcpy(&(pfOut[2]),&pfOut2,sizeof(float)); return; } void CalcAngle( float *src, float *dst, float *angles, DllInjectData *pInfo ) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; float delta0, delta1, delta2; float src0,src1,src2; pmemcpy(&src0,&(src[0]),sizeof(float)); pmemcpy(&src1,&(src[1]),sizeof(float)); pmemcpy(&src2,&(src[2]),sizeof(float)); float dst0,dst1,dst2; pmemcpy(&dst0,&(dst[0]),sizeof(float)); pmemcpy(&dst1,&(dst[1]),sizeof(float)); pmemcpy(&dst2,&(dst[2]),sizeof(float)); _asm { fld src0 fsub dst0 fstp delta0 fld src1 fsub dst1 fstp delta1 fld src2 fsub dst2 fstp delta2 } float hyp; _asm { fld delta0 fmul delta0 fstp hyp fld delta1 fmul delta1 fadd hyp fsqrt fstp hyp } float angles0; _asm { fld delta2 fdiv hyp fstp angles0 fpatan } arctg (&angles0, &angles0, pInfo); float M_RADPI; pmemcpy(&M_RADPI,&(pInfo->M_RADPI),sizeof(float)); _asm { fld angles0 fmul M_RADPI fstp angles0 } float angles1; _asm { fld delta1 fdiv delta0 fstp angles1 } arctg (&angles1, &angles1, pInfo); _asm { fld angles1 fmul M_RADPI fstp angles1 } float t0; _asm { fldz fstp t0 } if (GE(&delta0, &t0, pInfo)) { float t180; pmemcpy (&t180, &(pInfo->t180),sizeof(float)); _asm { fld angles1 fadd t180; fstp angles1 } } pmemcpy(&(angles[0]),&angles0,sizeof(float)); pmemcpy(&(angles[1]),&angles1,sizeof(float)); pmemcpy(&(angles[2]),&t0,sizeof(float)); return; } bool GetFOV( float *angle, float *src, float *dst, float* pFov, DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; float ang[3],aim[3]; float fov; CalcAngle(src, dst, ang, pInfo); MakeVector(angle, aim, pInfo); MakeVector(ang, ang, pInfo); float t0,t1; float mag_s; float aim0,aim1,aim2; pmemcpy(&aim0,&(aim[0]),sizeof(float)); pmemcpy(&aim1,&(aim[1]),sizeof(float)); pmemcpy(&aim2,&(aim[2]),sizeof(float)); _asm { fld aim0 fmul aim0 fstp t0 fld aim1 fmul aim1 fstp t1 fld aim2 fmul aim2 fadd t1 fadd t0 fsqrt fstp mag_s } float mag_d; pmemcpy(&mag_d,&mag_s,sizeof(float)); float u_dot_v; float ang0,ang1,ang2; pmemcpy(&ang0,&(ang[0]),sizeof(float)); pmemcpy(&ang1,&(ang[1]),sizeof(float)); pmemcpy(&ang2,&(ang[2]),sizeof(float)); _asm { fld aim0 fmul ang0 fstp u_dot_v fld aim1 fmul ang1 fadd u_dot_v fstp u_dot_v fld aim2 fmul ang2 fadd u_dot_v fstp u_dot_v } _asm { fld mag_s fmul mag_d fstp fov fld u_dot_v fdiv fov fstp fov } arccos(&fov, &fov, pInfo); float t180; float M_PI; pmemcpy(&M_PI,&(pInfo->M_PI),sizeof(float)); pmemcpy(&t180, &(pInfo->t180), sizeof(float)); _asm { fld t180 fdiv M_PI fmul fov fstp fov } pmemcpy(pFov, &fov, sizeof(float)); return true; } void Smooth(float *src, float *back, float *LocalAngles, int smooth, DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; float smoothdiff0,smoothdiff1; float src0,src1; pmemcpy(&src0,&(src[0]),sizeof(float)); pmemcpy(&src1,&(src[1]),sizeof(float)); float LocalAngles0,LocalAngles1; pmemcpy(&LocalAngles0,&(LocalAngles[0]),sizeof(float)); pmemcpy(&LocalAngles1,&(LocalAngles[1]),sizeof(float)); _asm { fld src0 fsub LocalAngles0 fstp src0 } _asm { fld src1 fsub LocalAngles1 fstp src1 } float f360; pmemcpy(&f360,&(pInfo->t360),sizeof(float)); float f180; pmemcpy(&f180,&(pInfo->t180),sizeof(float)); if (IG(&src0, &f180,pInfo)) { _asm { fld src0 fsub f360 fstp src0 } } if (IG(&src1, &f180,pInfo)) { _asm { fld src1 fsub f360 fstp src1 } } float n180; pmemcpy(&n180, &(pInfo->n180), sizeof(float)); if (IL(&src0, &n180,pInfo)) { _asm { fld src0 fadd f360 fstp src0 } } if (IL(&src1, &n180,pInfo)) { _asm { fld src1 fadd f360 fstp src1 } } float fsmooth; toFloat(smooth,&fsmooth,pInfo); _asm { fld src0 fdiv fsmooth fstp smoothdiff0 } _asm { fld src1 fdiv fsmooth fstp smoothdiff1 } float back0,back1,back2; _asm { fld LocalAngles0 fadd smoothdiff0 fstp back0 } _asm { fld LocalAngles1 fadd smoothdiff1 fstp back1 } if (IG(&back0, &f180,pInfo)) { _asm { fld back0 fsub f360 fstp back0 } } if (IG(&back1, &f180,pInfo)) { _asm { fld back1 fsub f360 fstp back1 } } if (IL(&back0, &n180,pInfo)) { _asm { fld back0 fadd f360 fstp back0 } } if (IL(&back1, &n180, pInfo)) { _asm { fld back1 fadd f360 fstp back1 } } pmemcpy(&(src[0]),&src0,sizeof(float)); pmemcpy(&(src[1]),&src1,sizeof(float)); pmemcpy(&(back[0]),&back0,sizeof(float)); pmemcpy(&(back[1]),&back1,sizeof(float)); pmemcpy(&(back[2]),&(LocalAngles[2]),sizeof(float)); return; } }; class C_LocalBase { public: DWORD dwEntity; C_LocalBase() { dwEntity = 0; } C_LocalBase(DllInjectData *pInfo) { dwEntity = 0; dwEntity = *(DWORD*)(pInfo->Client + Ad_LocalEntity); } int GetHealth() { int m_iHealth = 100; m_iHealth = *(int*)(dwEntity + Ad_Health); return m_iHealth; } int GetTeam() { int m_iTeam; m_iTeam = *(int*)(dwEntity + Ad_Team); return m_iTeam; } }; class C_EntityBase { public: DWORD dwEntity; C_EntityBase(int index,DllInjectData *pInfo) { dwEntity = 0; dwEntity = *(DWORD*)(pInfo->Client + Ad_Entity + index * 0x10); }; int GetHealth() { int m_iHealth; m_iHealth = *(int*)(dwEntity + Ad_Health); return m_iHealth; }; int GetTeam() { int m_iTeam; m_iTeam = *(int*)(dwEntity + Ad_Team); return m_iTeam; }; bool IsDormant() { bool m_bDormant; m_bDormant = *(bool*)(dwEntity + Ad_Dor); return m_bDormant; }; BYTE Getlifestate() { BYTE m_lifestate; m_lifestate = *(BYTE*)(dwEntity + Ad_Lifestate); return m_lifestate; }; }; class C_Aimbot { public: int ClosestFov(CMath *cMat,Vector *EntityPos,DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; C_LocalBase LocalEntity(pInfo); float MaxDist; int ClosestID = 0; if(!LocalEntity.dwEntity) return -1; pmemcpy (&MaxDist,&(pInfo->t_MaxDist),sizeof(float)); for(int i = 0; i < 64; i++) { C_EntityBase EntityList(i,pInfo); if(EntityList.dwEntity != NULL) { if(EntityList.dwEntity == LocalEntity.dwEntity) continue; if(EntityList.GetHealth() < 1) continue; if(EntityList.Getlifestate() != 0) continue; if(EntityList.IsDormant() != 0) continue; if(EntityList.GetTeam() == LocalEntity.GetTeam()) continue; float x,y,z,x2,y2,z2; Vector Bone( &(pInfo->t0),&(pInfo->t0),&(pInfo->t0),pInfo ); DWORD dwBone = *(DWORD*)(EntityList.dwEntity + 0xA78); pmemcpy(&x,(float*)(dwBone + (0x30 * (pInfo->C_Conf_Aim_Hitbox)) + 0x0C),sizeof(float)); pmemcpy(&y,(float*)(dwBone + (0x30 * (pInfo->C_Conf_Aim_Hitbox)) + 0x1C),sizeof(float)); pmemcpy(&z,(float*)(dwBone + (0x30 * (pInfo->C_Conf_Aim_Hitbox)) + 0x2C),sizeof(float)); toFloat(pInfo->C_Conf_Aim_Height, &z2,pInfo); _asm { fld z fadd z2 fstp z } Vector EntityPosTwo (&x, &y, &z,pInfo); Vector* MyPosOne =(Vector*) (LocalEntity.dwEntity+Ad_Origin); pmemcpy(&x, &(MyPosOne->x) ,sizeof(float)); pmemcpy(&y, &(MyPosOne->y) ,sizeof(float)); pmemcpy(&z, &(MyPosOne->z) ,sizeof(float)); Vector* MyPosTwo =(Vector*) (LocalEntity.dwEntity+Ad_ViewOrig); pmemcpy(&x2, &(MyPosTwo->x) ,sizeof(float)); pmemcpy(&y2, &(MyPosTwo->y) ,sizeof(float)); pmemcpy(&z2, &(MyPosTwo->z) ,sizeof(float)); _asm { fld x fadd x2 fstp x fld y fadd y2 fstp y fld z fadd z2 fstp z } Vector EyePosition(&x,&y,&z,pInfo); DWORD pEngine; pEngine = *(DWORD*)(pInfo->Engine + Ad_EnginePointer); Vector *t = (Vector*)(pEngine + Ad_ViewAngles); pmemcpy(&x, &(t->x), sizeof(float)); pmemcpy(&y, &(t->y), sizeof(float)); pmemcpy(&z, &(t->z), sizeof(float)); Vector MyAngles(&x,&y,&z,pInfo); float temp; float angle[3], src[3], dst[3]; pmemcpy(&(angle[0]), &(MyAngles.x),sizeof(float)); pmemcpy(&(angle[1]), &(MyAngles.y),sizeof(float)); pmemcpy(&(angle[2]), &(MyAngles.z),sizeof(float)); pmemcpy(&(src[0]), &(EyePosition.x),sizeof(float)); pmemcpy(&(src[1]), &(EyePosition.y),sizeof(float)); pmemcpy(&(src[2]), &(EyePosition.z),sizeof(float)); pmemcpy(&(dst[0]), &(EntityPosTwo.x),sizeof(float)); pmemcpy(&(dst[1]), &(EntityPosTwo.y),sizeof(float)); pmemcpy(&(dst[2]), &(EntityPosTwo.z),sizeof(float)); cMat->GetFOV(angle, src, dst, &temp, pInfo); float tC_Conf_Aim_Fov; toFloat(pInfo->C_Conf_Aim_Fov, &tC_Conf_Aim_Fov, pInfo); if( IG(&temp, &tC_Conf_Aim_Fov, pInfo) ) continue; if( IL(&temp, &MaxDist, pInfo) ) { ClosestID = i; pmemcpy (&MaxDist,&temp,sizeof(float)); pmemcpy (&(EntityPos->x),&(EntityPosTwo.x),sizeof(float)); pmemcpy (&(EntityPos->y),&(EntityPosTwo.y),sizeof(float)); pmemcpy (&(EntityPos->z),&(EntityPosTwo.z),sizeof(float)); } } } return ClosestID; } void Aimbot(CMath *cMat,Vector *EntityPos, Vector *AimAngles, DWORD *sTimer, DWORD *sTaTimer, DWORD *eNtTimer, DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; C_LocalBase LocalEntity(pInfo); if(!LocalEntity.dwEntity) return; GetAsyncKeyStateType pGetAsyncKeyState = (GetAsyncKeyStateType)pInfo->pGetAsyncKeyState; if(pGetAsyncKeyState(pInfo->C_Conf_Aim_Key)) { int EntityID = ClosestFov(cMat,EntityPos,pInfo); if(EntityID < 1) return; C_EntityBase Entity(EntityID,pInfo); if(!Entity.dwEntity) return; if (*sTimer == 0) Timer(sTimer, sTaTimer, pInfo); if (elapsedTime(sTimer, sTaTimer, eNtTimer, pInfo) > pInfo->C_Conf_Aim_Time ) return; float x,y,z,x2,y2,z2; Vector* MyPosOne =(Vector*) (LocalEntity.dwEntity+Ad_Origin); pmemcpy(&x, &(MyPosOne->x) ,sizeof(float)); pmemcpy(&y, &(MyPosOne->y) ,sizeof(float)); pmemcpy(&z, &(MyPosOne->z) ,sizeof(float)); Vector* MyPosTwo =(Vector*) (LocalEntity.dwEntity+Ad_ViewOrig); pmemcpy(&x2, &(MyPosTwo->x) ,sizeof(float)); pmemcpy(&y2, &(MyPosTwo->y) ,sizeof(float)); pmemcpy(&z2, &(MyPosTwo->z) ,sizeof(float)); _asm { fld x fadd x2 fstp x fld y fadd y2 fstp y fld z fadd z2 fstp z } Vector EyePosition(&x,&y,&z,pInfo); float angle[3]; float src[3], dst[3]; pmemcpy(&(src[0]), &(EyePosition.x),sizeof(float)); pmemcpy(&(src[1]), &(EyePosition.y),sizeof(float)); pmemcpy(&(src[2]), &(EyePosition.z),sizeof(float)); pmemcpy(&(dst[0]), &(EntityPos->x),sizeof(float)); pmemcpy(&(dst[1]), &(EntityPos->y),sizeof(float)); pmemcpy(&(dst[2]), &(EntityPos->z),sizeof(float)); cMat->CalcAngle(src,dst,angle,pInfo); pmemcpy(&(AimAngles->x), &(angle[0]),sizeof(float)); pmemcpy(&(AimAngles->y), &(angle[1]),sizeof(float)); pmemcpy(&(AimAngles->z), &(angle[2]),sizeof(float)); //RCS if(pInfo->C_Conf_Aim_RCS) { Vector* pAngles =(Vector*) (LocalEntity.dwEntity+ Ad_Local + Ad_PAngles); pmemcpy(&x, &(pAngles->x) ,sizeof(float)); pmemcpy(&y, &(pAngles->y) ,sizeof(float)); pmemcpy(&z, &(pAngles->z) ,sizeof(float)); pmemcpy(&x2, &(pInfo->t1dot96),sizeof(float)); pmemcpy(&y2, &(pInfo->t1dot96),sizeof(float)); _asm { fld x fmul x2 fstp x2 // x2 = Angles.x*1.96 fld y fmul y2 fstp y2 // y2 = Angles.y*1.96 } pmemcpy(&x, &(AimAngles->x) ,sizeof(float)); pmemcpy(&y, &(AimAngles->y) ,sizeof(float)); _asm { fld x fsub x2 fstp x // x = AimAngles.x = AimAngles.x - Angles.x*1.96 fld y fsub y2 fstp y } pmemcpy(&(AimAngles->x),&x,sizeof(float)); pmemcpy(&(AimAngles->y),&y,sizeof(float)); } DWORD pEngine; pEngine = *(DWORD*)(pInfo->Engine + Ad_EnginePointer); //Smooth if(pInfo->C_Conf_Aim_Smooth) { Vector *t = (Vector*)(pEngine + Ad_ViewAngles); pmemcpy(&x, &(t->x), sizeof(float)); pmemcpy(&y, &(t->y), sizeof(float)); pmemcpy(&z, &(t->z), sizeof(float)); Vector MyAngles(&x,&y,&z,pInfo); pmemcpy(&(dst[0]), &(MyAngles.x),sizeof(float)); pmemcpy(&(dst[1]), &(MyAngles.y),sizeof(float)); pmemcpy(&(dst[2]), &(MyAngles.z),sizeof(float)); pmemcpy(&(src[0]), &(AimAngles->x),sizeof(float)); pmemcpy(&(src[1]), &(AimAngles->y),sizeof(float)); pmemcpy(&(src[2]), &(AimAngles->z),sizeof(float)); cMat->Smooth(src, src, dst, pInfo->C_Conf_Aim_Smooth, pInfo); pmemcpy(&(AimAngles->x),&(src[0]),sizeof(float)); pmemcpy(&(AimAngles->y),&(src[1]),sizeof(float)); pmemcpy(&(AimAngles->z),&(src[2]),sizeof(float)); } else { pmemcpy(&(src[0]), &(AimAngles->x),sizeof(float)); pmemcpy(&(src[1]), &(AimAngles->y),sizeof(float)); pmemcpy(&(src[2]), &(AimAngles->z),sizeof(float)); } //NormaaliAnglet NormaaliAnglet(src,pInfo); pmemcpy(&(AimAngles->x),&(src[0]),sizeof(float)); pmemcpy(&(AimAngles->y),&(src[1]),sizeof(float)); pmemcpy(&(AimAngles->z),&(src[2]),sizeof(float)); //SetAngles Vector *CurAngles = (Vector*)(pEngine + Ad_ViewAngles); pmemcpy(&(CurAngles->x),&(AimAngles->x),sizeof(float)); pmemcpy(&(CurAngles->y),&(AimAngles->y),sizeof(float)); pmemcpy(&(CurAngles->z),&(AimAngles->z),sizeof(float)); } if(!(pGetAsyncKeyState(pInfo->C_Conf_Aim_Key)) && *sTimer == 1 ) { *sTimer = 0; } }; }; DWORD sTimer; sTimer = 0; DWORD sTaTimer; DWORD eNtTimer; float x,y,z; CMath cMat; Vector EntityPos(&(pInfo->t0),&(pInfo->t0),&(pInfo->t0),pInfo); Vector AimAngles(&(pInfo->t0),&(pInfo->t0),&(pInfo->t0),pInfo); C_Aimbot cAim; if(pInfo->bInit == false) { C_Config_LoadSettings(pInfo); InitModules(pInfo); pInfo->bInit = true; } while(pInfo->bInit == true) { C_LocalBase LocalEntity(pInfo); if(LocalEntity.dwEntity != NULL) { cAim.Aimbot(&cMat,&EntityPos,&AimAngles,&sTimer,&sTaTimer,&eNtTimer,pInfo); if(pGetAsyncKeyState(VK_DELETE)&1) { C_Config_LoadSettings(pInfo); } } } if (pExitThread) pExitThread (0); return 0; } void Timer(DWORD *sTimer, DWORD *sTaTimer, DllInjectData *pInfo) { GetTickCountType pGetTickCount = (GetTickCountType)pInfo->pGetTickCount; *sTaTimer = pGetTickCount(); *sTimer = 1; } int elapsedTime( DWORD *sTimer, DWORD *sTaTimer, DWORD *eNtTimer, DllInjectData *pInfo) { GetTickCountType pGetTickCount = (GetTickCountType)pInfo->pGetTickCount; *eNtTimer = pGetTickCount(); return (*eNtTimer - *sTaTimer); } bool toFloat(int arg, float *ret, DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; float res, junk; _asm { fild arg fstp res fstp junk } pmemcpy (ret, &res, sizeof(float)); return true; } int toInt(float *arg, DllInjectData *pInfo) { int re = 0; float farg; float junk; memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&farg, arg, sizeof(float)); _asm { fld farg fist re fstp junk } return re; } void InitModules(DllInjectData *pInfo) { DWORD mesD[10]; char *dll = (char*)mesD; dll[0]='c'; dll[1]='l'; dll[2]='i'; dll[3]='e'; dll[4]='n'; dll[5]='t'; dll[6]='.'; dll[7]='d'; dll[8]='l'; dll[9]='l'; dll[10]=0; GetModuleHandleAType pGetModuleHandleA = (GetModuleHandleAType)pInfo->pGetModuleHandleA; while(pInfo->Client == 0x0) { pInfo->Client = (DWORD)pGetModuleHandleA(dll); } while(pInfo->Engine == 0x0) { dll[0]='e'; dll[1]='n'; dll[2]='g'; dll[3]='i'; dll[4]='n'; dll[5]='e'; dll[6]='.'; dll[7]='d'; dll[8]='l'; dll[9]='l'; dll[10]=0; pInfo->Engine = (DWORD)pGetModuleHandleA(dll); } return; } void _GetPrivateProfileStringF(DllInjectData *pInfo, LPCSTR lpAppName, LPCSTR lpKeyName, float *lpFloat, LPCSTR szIniFile) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; DWORD mesD[40]; char *buffer = (char*)mesD; GetPrivateProfileStringAType pGetPrivateProfileStringA = (GetPrivateProfileStringAType)pInfo->pGetPrivateProfileStringA; sscanf_sType psscanf_s = (sscanf_sType)pInfo->psscanf_s; pGetPrivateProfileStringA(lpAppName, lpKeyName, 0, buffer, sizeof(buffer), szIniFile); int param = 0;float fparam; char szFormat[4]={'%','i','\0'}; psscanf_s(buffer, szFormat, &param); _asm { fild param fstp fparam } pmemcpy(lpFloat,&fparam,sizeof(float)); return; } void _GetPrivateProfileStringI(DllInjectData *pInfo, LPCSTR lpAppName, LPCSTR lpKeyName, int *pInt, LPCSTR szIniFile) { DWORD mesD[40]; char *buffer = (char*)mesD; GetPrivateProfileStringAType pGetPrivateProfileStringA = (GetPrivateProfileStringAType)pInfo->pGetPrivateProfileStringA; sscanf_sType psscanf_s = (sscanf_sType)pInfo->psscanf_s; pGetPrivateProfileStringA(lpAppName, lpKeyName, 0, buffer, sizeof(mesD), szIniFile); char szFormat[4]={'%','i','\0'}; psscanf_s(buffer, szFormat, pInt); return; } void C_Config_LoadSettings(DllInjectData *pInfo) { DWORD dwIniFile[60]; char *szIniFile = (char*)dwIniFile; DWORD dwAimbot[10]; char *szAimbot = (char*)dwAimbot; DWORD dwStr[20]; char *szStr = (char*)dwStr; szIniFile[0]='C'; szIniFile[1]=':'; szIniFile[2]='\\'; szIniFile[3]='W'; szIniFile[4]='i'; szIniFile[5]='n'; szIniFile[6]='d'; szIniFile[7]='o'; szIniFile[8]='w'; szIniFile[9]='s'; szIniFile[10]='\\'; szIniFile[11]='N'; szIniFile[12]='V'; szIniFile[13]='I'; szIniFile[14]='D'; szIniFile[15]='I'; szIniFile[16]='A'; szIniFile[17]='2'; szIniFile[18]='.'; szIniFile[19]='i'; szIniFile[20]='n'; szIniFile[21]='i'; szIniFile[22]=0; szAimbot[0]='A'; szAimbot[1]='i'; szAimbot[2]='m'; szAimbot[3]='b'; szAimbot[4]='o'; szAimbot[5]='t'; szAimbot[6]=0; szStr[0]='K'; szStr[1]='e'; szStr[2]='y'; szStr[3]=0;//"Key" _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Key), szIniFile); szStr[0]='F'; szStr[1]='o'; szStr[2]='v'; szStr[3]=0;//"Fov" _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Fov), szIniFile); szStr[0]='S'; szStr[1]='m'; szStr[2]='o'; szStr[3]='o'; szStr[4]='t'; szStr[5]='h';szStr[6]=0;//"Smooth" _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Smooth), szIniFile); szStr[0]='A'; szStr[1]='i'; szStr[2]='m'; szStr[3]='t'; szStr[4]='i'; szStr[5]='m'; szStr[6]='e'; szStr[7]=0;//"Aimtime" _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Time), szIniFile); szStr[0]='H'; szStr[1]='i'; szStr[2]='t'; szStr[3]='b'; szStr[4]='o'; szStr[5]='x';szStr[6]=0;//"Hitbox" _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Hitbox), szIniFile); szStr[0]='A'; szStr[1]='i'; szStr[2]='m'; szStr[3]='H'; szStr[4]='e'; szStr[5]='i'; szStr[6]='g'; szStr[7]='h'; szStr[8]='t'; szStr[9]=0;//"AimHeight" _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_Height), szIniFile); szStr[0]='R'; szStr[1]='C'; szStr[2]='S'; szStr[3]=0;//"RCS" _GetPrivateProfileStringI(pInfo, szAimbot, szStr, &(pInfo->C_Conf_Aim_RCS), szIniFile); } bool arctg (float* parg, float *ret, DllInjectData *pInfo) { float res; float junk; float arg; memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&arg,parg,sizeof(float)); _asm { fld arg fadd st(1),st(0) fld1 fpatan fldz fadd st(0), st(1) fstp res fstp junk fstp junk } pmemcpy(ret, &res, sizeof(float)); return true; } bool arccos(float* parg, float *ret, DllInjectData *pInfo) { float res; float arg; float junk; memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&arg,parg,sizeof(float)); _asm { fld1 fadd arg fstp res fld arg fld arg fmulp st(1), st(0) fld1 fsub st(0), st(1) fsqrt fdiv res fstp res fstp junk } arctg (&res, &res, pInfo); float two; pmemcpy(&two, &(pInfo->t2), sizeof(float)); _asm { fld res fmul two fstp res } pmemcpy(ret, &res, sizeof(float)); return true; } //Is greater bool IG (float* parg1, float* parg2,DllInjectData *pInfo ) { int iarg1 = 0, iarg2 = 0; float arg1,arg2,junk; memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&arg1,parg1,sizeof(float)); pmemcpy(&arg2,parg2,sizeof(float)); _asm { fld arg1 fistp iarg1 fld arg2 fistp iarg2 fstp junk fstp junk } if (iarg1 > iarg2) return true; else return false; } //Is lower bool IL (float* parg1, float* parg2,DllInjectData *pInfo ) { int iarg1 = 0, iarg2 = 0; float arg1,arg2,junk; memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&arg1,parg1,sizeof(float)); pmemcpy(&arg2,parg2,sizeof(float)); _asm { fld arg1 fistp iarg1 fld arg2 fistp iarg2 fstp junk fstp junk } if (iarg1 < iarg2) return true; else return false; } //Greater or equal bool GE (float *parg1, float *parg2,DllInjectData *pInfo ) { int iarg1 = 0, iarg2 = 0; float arg1,arg2,junk; memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; pmemcpy(&arg1,parg1,sizeof(float)); pmemcpy(&arg2,parg2,sizeof(float)); _asm { fld arg1 fistp iarg1 fld arg2 fistp iarg2 fstp junk fstp junk } if (iarg1 >= iarg2) return true; else return false; } void NormaaliAnglet( float angle[], DllInjectData *pInfo) { memcpyType pmemcpy = (memcpyType)pInfo->pmemcpy; float f180; pmemcpy (&f180, &(pInfo->t180), sizeof(float)); float f89; pmemcpy (&f89, &(pInfo->t89), sizeof(float)); float angle0,angle1; pmemcpy (&angle0, &(angle[0]), sizeof(float)); pmemcpy (&angle1, &(angle[1]), sizeof(float)); while( IG(&angle0,&f89,pInfo)) { _asm { fld angle0 fsub f180 fstp angle0 } } float n89 pmemcpy (&n89, &(pInfo->n89), sizeof(float)); while( IL(&angle0,&n89,pInfo)) { _asm { fld angle0 fadd f180 fstp angle0 } } float f360; pmemcpy (&f360, &(pInfo->t360), sizeof(float)); while( IG(&angle1,&f180,pInfo)) { _asm { fld angle1 fsub f360 fstp angle1 } } float n180; pmemcpy (&n180, &(pInfo->n180), sizeof(float)); while( IL(&angle1,&n180,pInfo)) { _asm { fld angle1 fadd f360 fstp angle1 } } pmemcpy (&(angle[0]), &angle0, sizeof(float)); pmemcpy (&(angle[1]), &angle1, sizeof(float)); return; } VOID WINAPI InjectThreadEnd () { }

Duvidas vejam a - parte 1 [HIDE-THANKS] Aula 11 - Operadores AND, OR, NOT Aula 12 - Operador ternário Aula 13 - Comando Switch Case Aula 14 - Comando de laço While Aula 15 - Comando Break Aula 16 - Comando de loop Do While Aula 17 - Comando de loop FOR Aula 18 - Array / Vetor Aula 19 - Array bidimensional / Matriz Aula 20 - Jogo da Forca [/HIDE-THANKS] By: Hiro Bons estudos !!!