Bem-vindo ao Fórum!

Registre-se agora mesmo e fique por dentro da maior comunidade de Cheats do Brasil!

Search the Community

Showing results for tags 'python'.



More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Forums

  • Anunciantes
    • silvaBR Cheats
    • Cheat Gamers Club
  • Anúncios/Eventos
    • Regras
    • Anúncios
    • Eventos do fórum
  • Feedback & Suporte
    • Tutoriais WC
    • Suporte
    • Denúncias e Reclamações
    • Sugestões
    • Depósito
  • Shooter Zone
    • Point Blank
    • Combat Arms
    • Cross Fire
    • Counter Strike
    • Battle Royale
    • Outros Shooters em Geral
    • Shooter Zone - Lixão
  • RPG/MOBA Zone
    • Grand Chase
    • Ragnarok
    • League of Legends
    • Tibia
    • Priston Tale
    • Mu Online
    • Perfect World
    • GunBound
    • Outros RPGs em Geral
    • RPG Zone - Lixão
  • Outros Games Zone
  • Design Zone
  • Info Zone
  • Video Games Zone
  • Entretenimento & Diversão

Find results in...

Find results that contain...


Date Created

  • Start

    End


Last Updated

  • Start

    End


Filter by number of...

Joined

  • Start

    End


Group


About Me


Discord

Found 39 results

  1. Alguém pode me ajudar com essa questão? Não estou conseguindo salvar dois números em um único nome, estou usando dicionário assim como foi pedido e não listas. """"Escreva um programa para armazenar uma agenda de telefones em um dicionário. Cada pessoa pode ter um ou mais telefones e a chave do dicionário é o nome da pessoa. Seu programa deve ter as seguintes funções:  incluirNovoNome: essa função acrescenta um novo nome na agenda, com um ou mais telefones. Ela deve receber como argumentos o nome e os telefones.  incluirTelefone: essa função acrescenta um telefone em um nome existente na agenda. Caso o nome não exista na agenda, você deve perguntar se a pessoa deseja incluílo. Caso a resposta seja afirmativa, use a função anterior para incluir o novo nome.  excluirTelefone: essa função exclui um telefone de uma pessoa que já está na agenda. Se a pessoa tiver apenas um telefone, ela deve ser excluída da agenda.  excluirNome: essa função exclui uma pessoa da agenda.  consultarTelefone: essa função retorna os telefones de uma pessoa na agenda."""
  2. Título Python Para Hackers Autor ???? Editora Udemy Gênero Vídeo-aula Ano 2017 INFORMAÇÕES DO UPLOAD Título do upload Curso Python Para Hackers [Videoaula] Tamanho do arquivo 304,00 MB Compressão RAR Formato de arquivo PDF, MP4/M4V Idioma Português (Brasil) Python é uma das linguagens mais utilizadas no mundo pela sua facilidade, praticidade e recursos. Nesse curso você irá aprender Python com foco em segurança computacional. O curso possui uma introdução a programação com Python e aborda o módulo scapy que é uma poderosa ferramenta em Python para manipulação de pacotes. ~By:Kyyo90~
  3. As 5 melhores linguagens de programação para desenvolvimento de IA Qual linguagem de programação você deve escolher para o seu aprendizado de máquina ou projeto de aprendizado profundo? Estas são suas melhores opções AI (inteligência artificial) abre um mundo de possibilidades para desenvolvedores de aplicativos. Aproveitando o aprendizado de máquina ou o aprendizado profundo, você pode produzir perfis de usuário, personalização e recomendações muito melhores, ou incorporar uma pesquisa mais inteligente, uma interface de voz ou assistência inteligente, ou melhorar seu aplicativo de várias outras maneiras. Você pode até criar aplicativos que ver, ouvir e reagir. Qual linguagem de programação você deve aprender a mergulhar nas profundezas da IA? Você desejará um idioma com muitas boas bibliotecas de aprendizado de máquina e aprendizagem profunda, é claro. Ele também deve apresentar bom desempenho em tempo de execução, bom suporte a ferramentas, uma grande comunidade de programadores e um ecossistema saudável de pacotes de suporte. Isso ainda deixa muitas boas opções. Aqui estão minhas escolhas para as cinco melhores linguagens de programação para desenvolvimento de IA, junto com três menções honrosas. Algumas dessas línguas estão em ascensão, enquanto outras parecem estar escorregando. Volte em alguns meses, e você pode achar que esses rankings mudaram. 1. Python No número um, é o Python. Como poderia ser qualquer outra coisa, realmente? Embora existam coisas enlouquecedoras sobre o Python - o espaço em branco, a divisão massiva entre o Python 2.xe o Python 3.x, os cinco sistemas de empacotamento diferentes que são todos quebrados de maneiras diferentes - se você está fazendo um trabalho de IA, quase certamente estar usando o Python em algum momento. As bibliotecas disponíveis no Python são praticamente inigualáveis em outros idiomas. O NumPy se tornou tão onipresente que é quase uma API padrão para operações de tensor, e o Pandas traz os poderosos e flexíveis quadros de dados do R para o Python. Para o processamento de linguagem natural (PNL), você tem o venerável NLTK e o incrivelmente rápido SpaCy. Para aprendizado de máquina, existe o Scikit-learn testado em batalha. E quando se trata de aprendizagem profunda, todas as bibliotecas atuais (TensorFlow, PyTorch, Chainer, Apache MXNet, Theano, etc.) são efetivamente projetos em Python. Se você está lendo uma pesquisa de aprendizado profundo de ponta sobre o arXiv, então certamente encontrará o código-fonte em Python. Depois, há as outras partes do ecossistema do Python. Embora o IPython tenha se tornado o Jupyter Notebook e menos centrado no Python, você ainda descobrirá que a maioria dos usuários do Jupyter Notebook e a maioria dos notebooks compartilhados on-line usam o Python. Não há como fugir disso. O Python é a linguagem na vanguarda da pesquisa de IA, aquela em que você encontrará a maioria das estruturas de aprendizado de máquina e aprendizagem profunda, e a que quase todo mundo no mundo da IA fala. Por esses motivos, o Python é o primeiro entre as linguagens de programação de IA, apesar do fato de que seu autor amaldiçoa os problemas de espaço em branco pelo menos uma vez por dia. 2. Java e amigos A família de linguagens JVM (Java, Scala, Kotlin, Clojure, etc.) também é uma ótima opção para o desenvolvimento de aplicativos de IA. Você tem diversas bibliotecas disponíveis para todas as partes do pipeline, seja o processamento de linguagem natural (CoreNLP), operações de tensor (ND4J) ou uma pilha de aprendizado profundo acelerada por GPU (DL4J). Além disso, você obtém acesso fácil a plataformas de Big Data, como o Apache Spark e o Apache Hadoop. Java é a língua franca da maioria das empresas e, com as novas construções de linguagem disponíveis no Java 8 e no Java 9, escrever código Java não é a experiência odiosa que muitos de nós lembramos. Escrever um aplicativo de AI em Java pode parecer um pouco chato, mas ele pode fazer o trabalho - e você pode usar toda a sua infraestrutura Java existente para desenvolvimento, implantação e monitoramento. 3. C / C ++ É improvável que C / C ++ seja sua primeira escolha ao desenvolver um aplicativo de AI, mas se você estiver trabalhando em um ambiente integrado e não puder arcar com a sobrecarga de um Java Virtual Machine ou um interpretador Python, C / C ++ é o responda. Quando você precisa torcer todo o desempenho do sistema, então você precisa voltar para o aterrorizante mundo dos ponteiros. Felizmente, o C / C ++ moderno pode ser agradável de escrever (honesto!). Você tem uma escolha de abordagens. Você pode mergulhar na parte inferior da pilha, usando bibliotecas como CUDA para escrever seu próprio código que roda diretamente em sua GPU, ou você pode usar o TensorFlow ou o Caffe para obter acesso a APIs flexíveis de alto nível. O último também permite que você importe modelos que seus cientistas de dados possam ter construído com o Python e, em seguida, os execute na produção com toda a velocidade que o C / C ++ oferece. Fique atento ao que Rust faz neste espaço no ano que está por vir. Combinando a velocidade do C / C ++ com o tipo e segurança de dados, o Rust é uma ótima opção para alcançar o desempenho de produção sem criar dores de cabeça de segurança. E uma ligação TensorFlow já está disponível para ela. 4. JavaScript JavaScript? O que diabos está acontecendo? Bem, o Google lançou recentemente o TensorFlow.js, uma biblioteca acelerada por WebGL que permite treinar e executar modelos de aprendizado de máquina em seu navegador da web. Também inclui a API Keras e a capacidade de carregar e usar modelos que foram treinados em TensorFlow regular. É provável que isso atraia um influxo massivo de desenvolvedores para o espaço da IA. Embora o JavaScript não tenha atualmente o mesmo acesso a bibliotecas de aprendizado de máquina das outras linguagens listadas aqui, os desenvolvedores logo adicionarão redes neurais a suas páginas da Web com a mesma indiferença que adicionam um componente React ou uma propriedade CSS. Simultaneamente fortalecedor e aterrorizante. TensorFlow.js ainda está em seus primeiros dias. No momento, ele funciona no navegador, mas não no Node.js. Ele ainda não implementa a API completa do TensorFlow. No entanto, espero que ambos os problemas sejam resolvidos em grande parte até o final de 2018 e a invasão de AI do JavaScript ocorrerá logo em seguida. 5. R O R aparece no fundo dos nossos cinco primeiros e está tendendo para baixo. R é a linguagem que os cientistas de dados adoram. No entanto, outros programadores acham R um pouco confuso quando o encontram pela primeira vez, devido à sua abordagem centrada no dataframe. Se você tem um grupo dedicado de desenvolvedores de R, então pode fazer sentido usar as integrações com TensorFlow, Keras ou H2O para pesquisa, prototipagem e experimentação, mas hesito em recomendar R para uso em produção. Outras opções de programação de AI É claro que Python, Java, C / C ++, JavaScript e R não são os únicos idiomas disponíveis para programação de IA. Vejamos três linguagens de programação que não chegaram ao nosso top cinco - duas em ascensão e uma em queda. Fonte: http://clusterdata.nl/bericht/news-item/the-5-best-programming-languages-for-ai-development/
  4. Bom dia pessoal, estou com uma certa dificuldade na questão abaixo: https://prnt.sc/jafnoy Eu não estou conseguindo ter o resultado igual demonstrado na imagem, meu código atualmente está assim: https://prnt.sc/jafokb Alguém pode me dar uma luz e mostrar o caminho para conseguir ficar igual o exemplo?
  5. Por conta de um novo e popular servidor, voltamos à época em que ainda era possível editar arquivos .kom pra ter autokill, monstervac, etc. Isso me alertou sobre a falta de tutoriais aqui no fórum sobre a edição desses arquivos e resolvi fazer eu mesmo. ATENÇÃO: Toda a informação aqui dada se baseia em testes feitos com o cliente da Season 2. Não necessariamente se mantém a mesma com relação às futuras seasons. Inclusive podem haver clientes da S2 que funcionam de maneira diferente, justamente pra evitar as alterações nos arquivos. O que são os arquivos .kom? São pacotes encontrados pelas pastas do Grand Chase que possuem dentro arquivos de áudio, imagem, modelos 3D e scripts em .stg e .lua. Onde encontrar e pelo que são responsáveis? .../Model: Modelos 3D dos personagens, NPCs, pets, etc. .../Motion: Animações vinculadas aos modelos 3d. .../Sound: Todos os arquivos de áudio. .../Texture: Texturas dos modelos, partículas de efeitos, animações e algumas imagens. .../Stage: Scripts de funcionamento de diversas coisas, dentre eles: playertemplate.kom: Status básicos das classes e a indexação de suas animações minigame.kom: Funcionamento dos minigames do Plaza fight_stg.kom: Funcionamento das stages das dungeons Material necessário pra manipulação dos arquivos .kom: [Hidden Content] Scan dos arquivos: kom mode.bms - VirusTotal.com kom_create2.py - VirusTotal.com Kompact (9n1p).bat - VirusTotal.com kpt.exe - VirusTotal.com python-2.6.msi - VirusTotal.com python-2.6.amd64.msi - VirusTotal.com Descompactando: Após extrair o conteúdo do GC Kom Tools.rar, execute o kpt.exe. Com o painel dele, abra o kom mode.bms, no próximo painel selecione o arquivo .kom a ser descompactado, e por último a pasta destino pro conteúdo extraído, que por padrão eu uso a Extracted no mesmo local que o kpt.exe. Depois do processo pode fechar o kpt.exe. Compactando: É necessário ter o Python 2.6 instalado. Caso não tenha, instale. Precisa ser o 2.6, não os mais atualizados, por não darem suporte à library usada no processo. Depois de toda a edição, coloque os arquivos a serem compactados dentro da pasta Compact e execute o Kompact (9n1p).bat. Coloquei por padrão alguns dos arquivos mais comumente alterados do Grand Chase como escolhas rápidas pro nome do arquivo a ser compactado, mas caso não seja nenhum deles, aperte 8 e digite o nome a ser dado pro novo kom. No final do processo o Kompact fechará automaticamente e o novo arquivo estará na mesma pasta que ele, com o nome selecionado. Substitua o original na pasta do Grand Chase e voilà! Como alterar e o que alterar nos arquivos com o intuito de criar cheats
  6. A source abaixo que fiz, simula esses sites de caixas da sorte que existem de CSGO. É apenas um exemplo em Python para aprendizado de lógica e algoritmo para quem já tem o basico de Python. Nesse script você aprende um pouco mais sobre: Listas Dicionários Loop (While e For) Remover dicionário de listas Criar menu dinamico Qualquer bug que der, só comentar. Mas tente usar o Google, é a primeira coisa que vou fazer, se eu não conhecer o erro de primeira. (É isso que os programadores fazem rsrs) Como jogar Copie e cole o codigo abaixo em algum arquivo, exemplo: csgoskins.py Vá com seu CMD/Terminal até o diretorio desse arquivo e digite: python csgoskins.py Pronto, só ler e jogar. Abs Código # -*- coding: utf-8 -*- import random import os import time #criando comando clear pra limpar console clear = lambda: os.system('cls') """ Na lista skinconfig_list, vamos colocar 3 dicionarios. Cada objeto vai ter o nome da skin, quantidade de itens dessa skin e o preco dela. O total de itens tem que dar 100. Dessa forma, conseguimos trabalhar tranquilo com porcentagem. No nosso caso, 80% de chance de conseguir pistola bosta, 15% de chance de conseguir ak47 e 5% de conseguir a karambit. """ skinconfig_list = [ { "name": "Karambit Cara", "quantity": 5, "price": 400.00, }, { "name": "AK47 Fodona", "quantity": 15, "price": 15.00, }, { "name": "Glock Bosta", "quantity": 80, "price": 5.00, } ] """ Agora vamos construir nosso "BAU DA SORTE". Para fazer isso, vamos fazer um looping passando nesses 3 dicionarios. Em cada objeto, vamos fazer OUTRO looping de acordo com a quantidade e vamos adicionar numa lista final (o bau) a quantidade de cada skin. Ou seja, vamos criar uma lista que tem 5 karambits, 15 ak47 e 80 glock bostas. Vou criar um DICIONARIO chamado BAU, onde terao 2 atributos nele: preço, e lista de items. """ bau_sorteio = { "price": 10.00, "items": [], # INICIANDO ESSA LISTA DAS SKINS VAZIAS PORQUE AINDA NAO COLOCAMOS NADA NELA. } for skin in skinconfig_list: for s in range(0, skin['quantity']): # O append, adiciona um objeto dentro da lista. bau_sorteio['items'].append({ "name": skin['name'], "price": skin['price'] }) """ Beleza, agora temos uma lista com 5 karambits, 15 ak47 e 80 pistolas. Agora é a parte facil! Vamos usar o random que é uma funcao nativa do Python (e em todas linguagens) para escolher UMA POSICAO dessa lista. Esse sera o sorteio. Mas para ficar bonitinho, vamos colocar umas mensagens so para ficar engraçado o jogo. Antes de iniciar o jogo, precisamos MOCAR(mock) as informacoes do usuario que está apostando, sacou? Entao vamos criar um dicionario que representa o nick do apostador e sua quantidade de moeda virtual. Com essa moeda ele vai comprar o bau, vai ser sorteado o item aleatoriamente e ele vai ter a opcao de ficar com o item ou vender. """ you = { "name": "Cr4cko", "money": 50.00, "my_items": [] } clear() #Limpando todo terminal antes de mais nada. print("\n") #Pulando 3 linha print("### BAU DAS SKINS MARAVILHOSAS ###") print("\n") #Pulando 2 linha print("Informacoes do BAU:\n") print(" - Karambit Cara (5%)\n - AK47 Fodona (15%)\n - Glock Bosta (80%)\n\n") """ Agora vamos criar o metodo ask_to_user, que vai ficar repetindo infinitamente, para ele ou comprar um item, ou vender um dos seus que ganhou ou sair do programa. Quando ele digitar 3, retornamos false e quebramos o looping. """ infinite_loop = True #inicia looping infinito def ask_to_user(): print("\n--------------\nSuas informações: \n") print(" - Nome: %s \n - Dinheiro: %s \n - Seus Items: %s" % (you['name'], you['money'], you['my_items']) ) print("\n## Comandos ## \n 1 - Comprar caixa e abrir\n 2 - Vender algum item seu\n 3 - Fechar programa.") # Vamos pegar oq o usuario digitar command = input("Digite o comando: ") if int(command) == 1: # se for 1, ele quer comprar result_price = you['money'] - bau_sorteio['price'] if result_price >= 0: # Beleza voce tem dinheiro para comprar o bau. # Debitar do seu money you['money'] = result_price # Selecionar randomicamente um item dos items do bau selected_skin = random.choice(bau_sorteio['items']) print("\nAbrindo o bau...") time.sleep(3) # 3 segundo de angustia print("Você ganhou a skin: %s ($%s)! Item adicionado em 'Seus Items'" % (selected_skin['name'], selected_skin['price']) ) #Adicionando no slot do teus itens you['my_items'].append({ "id": len(you['my_items']) + 1, "name": selected_skin['name'], "price": selected_skin['price'], }) else: print("\n(ERRO): Voce não tem dinheiro jovem :(") time.sleep(2) clear() elif int(command) == 2: # se for 2, ele quer vender um item if len(you['my_items']) > 0: #se o tamanho(len) da lista de seus items for maior que zero... # voce tem pelo menos 1 item # listando os seus items for item in you['my_items']: print("\n%s - %s ($%s)" % (item['id'], item['name'], item['price']) ) # pedindo pro jogador escolher 1 item e vender. selected_id = input("\nSelecione o ID do item que quer vender: ") selected_item_to_sell = False # por enquanto nenhum item foi selecionado (False) for item in you['my_items']: if selected_id == item['id']: selected_item_to_sell = item # guarda o item selecionado you['my_items'].remove(item) # remove o item das suas skins # e adiciona o dinheiro do item removido na sua conta you['money'] += selected_item_to_sell['price'] print("Item removido com sucesso! Agora você tem: $ %s" % you['money']) if not selected_item_to_sell: print("\n(ERRO): ID selecionado inexistente.") time.sleep(2) clear() else: print("\n(ERRO): Voce nao tem item pra vender.") time.sleep(2) clear() elif int(command) == 3: #Quebra o looping infinito print("\n ## BYE ##\n") return False elif not command or int(command) not in [1,2,3]: # se nao... print("\n(ERRO): Comando inexistente meu jovem.") time.sleep(2) clear() #continua retornando true pra continuar o looping return True while True: result = ask_to_user() if not result: # se retornar false, acaba o looping break Resultado
  7. Bom, trouxe aqui um Cheat em Python Open source para dar uma variada. Não fui eu quem fiz, o que fiz apenas foi atualizar os offsets e remover codigo inutil. Para quem não sabe, SoundEsp é um som que apita quando tiver inimigo próximo a você. Ele começa a apitar, exatamente igual aqueles sons de carro quando vai bater em algum lugar e o sensor começa a apitar. Para conseguir usar o hack, siga o tutorial abaixo: Você precisa estar com o Python 2.7 instalado. Depois de ter o Python 2.7, vai em seu terminal ou CMD se estiver no Windows e digite: python --version Verifique se realmente é o 2.7. Agora, você precisa instalar o PIP para adicionar algumas dependências do hack. Aqui tem um tutorial de como instalar Python e PIP. ( LINK ) Depois disso, vamos instalar uma dependencia para manipular memoria com Python. Digite no CMD/Terminal: pip install https://github.com/n1nj4sec/memorpy/archive/master.zip Beleza, agora vamos instalar outra dependencis: pip install pypiwin32 Agora acredito que teu PC ja está apto a rodar o cheat. Em algum lugar em teu computador, crie um arquivo chamado soundesp.py e jogue esse conteúdo dentro: # Créditos: https://www.unknowncheats.me/forum/members/656078.html # Atualização dos offsets: http://www.webcheats.com.br/members/cr4cko.3601364/ from ctypes import * from memorpy import * import time import win32api import random import thread import win32gui import math import winsound # OFFSET START # rossHairIDOffset = 0xB2A4 forceAttackOffset = 0x2EB9EA0 forceJumpOffset = 0x4F0ED94 clientStateOffset = 0x57D844 clientStateViewAnglesOffset = 0x4D10 aimPunchOffset = 0x301C clientStateInGameOffset = 0x00000180 flagsOffset = 0x100 vecOriginOffset = 0x134 shotsFiredOffset = 0xA2B0 entityListOffset = 0x4A77B2C localPlayerIndexOffset = 0x180 localPlayerOffset = 0xA9ADEC glowObjectOffset = 0x4F94970 glowIndexOffset = 0xA310 teamNumOffset = 0xF0 dormantOffset = 0x000000E9 healthOffset = 0xFC bSpottedOffset = 0x939 # OFFSET END # # OPTIONS START # soundESPEnabled = True maxSoundESPDistance = 780 # Default: 780, decent distance tbh foundProcess = False end = False csgoWindow = None def soundESP(process, client, localPlayer): global maxSoundESPDistance global end global csgoWindow while not end: time.sleep(0.01) if win32gui.GetForegroundWindow() == csgoWindow: closestPlayer = 99999.0 playerCount = Address((client + glowObjectOffset + 0x4), process).read('int') for i in range(0, playerCount): ent = Address((client + entityListOffset + ((i - 1) * 0x10)), process).read() # Get current entity based on for-loop variable i if ent is 0x0: break entDormant = Address((ent + dormantOffset), process).read('int') # Get boolean that states whether glowCurrentPlayer entity is dormant or not if entDormant != 0: continue myTeamID = Address((localPlayer + teamNumOffset), process).read('int') # Get the team ID of the localPlayer entityBaseTeamID = Address((ent + teamNumOffset), process).read('int') # Get the team ID of the ent entity if entityBaseTeamID != 2 and entityBaseTeamID != 3: continue localPlayerX = Address((localPlayer + vecOriginOffset), process).read('float') # Get the X coordinate of the vecOrigin of the localPlayer localPlayerY = Address((localPlayer + vecOriginOffset + 0x4), process).read('float') # Get the Y coordinate of the vecOrigin of the localPlayer localPlayerZ = Address((localPlayer + vecOriginOffset + 0x8), process).read('float') # Get the Z coordinate of the vecOrigin of the localPlayer entityX = Address((ent + vecOriginOffset), process).read('float') # Get the X coordinate of the vecOrigin of the ent entityY = Address((ent + vecOriginOffset + 0x4), process).read('float') # Get the Y coordinate of the vecOrigin of the ent entityZ = Address((ent + vecOriginOffset + 0x8), process).read('float') # Get the Z coordinate of the vecOrigin of the ent distance = math.sqrt((pow((entityX - localPlayerX), 2) + pow((entityY - localPlayerY), 2) + pow((entityZ - localPlayerZ), 2))) # Get the distance between localPlayer and ent if myTeamID != entityBaseTeamID and distance != 0 and closestPlayer > distance: # If not on localPlayer team and team is either 2 or 3 and distance isnt 0 and distance is less than closestPlayer closestPlayer = distance if closestPlayer != 99999.0 and closestPlayer < maxSoundESPDistance: # If closestPlayer isnt default value and closestPlayer is closer than maxSoundESPDistance durMath = 1.000/maxSoundESPDistance # Generate baseline mathematical thingy - use ur brain winsound.Beep(2500, int((durMath * closestPlayer) * 1000)) def getDLL(name, PID): hModule = CreateToolhelp32Snapshot(TH32CS_CLASS.SNAPMODULE, PID) if hModule is not None: module_entry = MODULEENTRY32() module_entry.dwSize = sizeof(module_entry) success = Module32First(hModule, byref(module_entry)) while success: if module_entry.th32ProcessID == PID: if module_entry.szModule == name: return module_entry.modBaseAddr success = Module32Next(hModule, byref(module_entry)) CloseHandle(hModule) return 0 def main(): global soundESPEnabled global end global csgoWindow processHandle = Process(name="csgo") if not processHandle: print("CSGO não encontrado. Encerrando.") exit(1) print("CSGO encontrado.") client = getDLL("client.dll", processHandle.pid) print("client.dll encontrado.") engine = getDLL("engine.dll", processHandle.pid) print("engine.dll encontrado.") print("SoundESP ON. Para sair, pressione o END!") clientState = Address((engine + clientStateOffset), processHandle).read() localPlayer = Address((client + localPlayerOffset), processHandle).read() csgoWindow = win32gui.FindWindow(None, "Counter-Strike: Global Offensive") if csgoWindow is None: print("Janela do CSGO não encontrada.") exit(1) if soundESPEnabled: try: thread.start_new_thread(soundESP, (processHandle, client, localPlayer, )) # Start soundESP function threaded except: print("Não foi possivel iniciar a thread playerCounter") while not win32api.GetAsyncKeyState(0x23): continue time.sleep(0.1) end = True if __name__ == "__main__": main() Fechou, agora é só ir com o CMD/Terminal no local do arquivo criado e executar: python soundesp.py Se aparecer que o SoundESP foi iniciado, ta tudo certo. É só chegar próximo de um BOT e escutar o som. Isso é uma pequena ajuda, nada demais. Só pra saber onde que o inimigo está. Qualquer dúvida ou erro poste aqui, para mim funcionou tranquilo :) Créditos no inicio do código.
  8. Consegui fazer funcionar pelo menos com BOTS o GlowESP em Python. Na linha 122, eu deixei igual a 0 pois funcionou com BOTS. Talvez, você precise alterar o valor se jogar em outras modalidades, enfim, eu deixei acima dessa linha um print como valor que realmente é. Você olha no seu CMD após entrar na sala e ligar o HACK para alterar o valor conforme ele pede. Tutorial de como executar: 1 - Verificar se os offsets estão atualizados de acordo com essa LISTA AQUI 2 - Seguir os mesmos passos do PIP install das dependencias DESSE TÓPICO AQUI (SoundESP). 3 - Criar arquivo glowesp.py e jogar a source abaixo 4 - Executar quando nascer dentro do jogo: python glowesp.py Source # -*- coding: UTF8 -*- from ctypes import * from memorpy import * import time import win32api import random import thread import win32gui import math import winsound crossHairIDOffset = 0xB2A4 forceAttackOffset = 0x2EB9EA0 forceJumpOffset = 0x4F0ED94 clientStateOffset = 0x57D844 clientStateViewAnglesOffset = 0x4D10 aimPunchOffset = 0x301C clientStateInGameOffset = 0x00000180 flagsOffset = 0x100 vecOriginOffset = 0x134 shotsFiredOffset = 0xA2B0 entityListOffset = 0x4A77B2C localPlayerIndexOffset = 0x180 localPlayerOffset = 0xA9ADEC glowObjectOffset = 0x4F94970 glowIndexOffset = 0xA310 teamNumOffset = 0xF0 dormantOffset = 0x000000E9 healthOffset = 0xFC bSpottedOffset = 0x939 glowESPEnabled = True foundProcess = False end = False csgoWindow = None def glowESP(process, client): glowLocalBase = Address((client + localPlayerOffset), process).read() glowPointer = Address((client + glowObjectOffset), process).read() myTeamID = Address((glowLocalBase + teamNumOffset), process).read('int') playerCount = Address((client + glowObjectOffset + 0x4), process).read('int') for i in range(1, playerCount): glowCurrentPlayer = Address((client + entityListOffset + ((i - 1) * 0x10)), process).read() if glowCurrentPlayer == 0x0: break glowCurrentPlayerDormant = Address((glowCurrentPlayer + dormantOffset), process).read('int') glowCurrentPlayerGlowIndex = Address((glowCurrentPlayer + glowIndexOffset), process).read('int') entityBaseTeamID = Address((glowCurrentPlayer + teamNumOffset), process).read('int') if entityBaseTeamID == 0 or glowCurrentPlayerDormant != 0: continue else: if myTeamID != entityBaseTeamID: Address((glowCurrentPlayer + bSpottedOffset), process).write(1, 'int') if entityBaseTeamID == 2: # Terrorist Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x4)), process).write(1.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x8)), process).write(0.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0xC)), process).write(0.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x10)), process).write(1.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x24)), process).write(1, 'int') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x25)), process).write(0, 'int') elif entityBaseTeamID == 3: # Counter-Terrorist Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x4)), process).write(0.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x8)), process).write(0.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0xC)), process).write(1.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x10)), process).write(1.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x24)), process).write(1, 'int') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x25)), process).write(0, 'int') else: Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x4)), process).write(0.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x8)), process).write(1.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0xC)), process).write(0.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x10)), process).write(1.0, 'float') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x24)), process).write(1, 'int') Address((glowPointer + ((glowCurrentPlayerGlowIndex * 0x38) + 0x25)), process).write(0, 'int') def getDLL(name, PID): hModule = CreateToolhelp32Snapshot(TH32CS_CLASS.SNAPMODULE, PID) if hModule is not None: module_entry = MODULEENTRY32() module_entry.dwSize = sizeof(module_entry) success = Module32First(hModule, byref(module_entry)) while success: if module_entry.th32ProcessID == PID: if module_entry.szModule == name: return module_entry.modBaseAddr success = Module32Next(hModule, byref(module_entry)) CloseHandle(hModule) return 0 def main(): global glowESPEnabled global end global csgoWindow processHandle = Process(name="csgo") # Get csgo process if not processHandle: # If handle is bad print("CSGO Não encontrado, saindo.") exit(1) client = getDLL("client.dll", processHandle.pid) engine = getDLL("engine.dll", processHandle.pid) print("GlowEsp iniciado. END para fechar.") clientState = Address((engine + clientStateOffset), processHandle).read() localPlayer = Address((client + localPlayerOffset), processHandle).read() csgoWindow = win32gui.FindWindow(None, "Counter-Strike: Global Offensive") if csgoWindow is None: print("The CSGO Window was not found.") exit(1) while not win32api.GetAsyncKeyState(0x23): # END para parar. print("IN GAME CLIENT: %s == 0?" % Address((clientState + clientStateInGameOffset), processHandle).read('int')) if Address((clientState + clientStateInGameOffset), processHandle).read('int') == 0: # 0 funcionou contra bots. if glowESPEnabled and win32gui.GetForegroundWindow() == csgoWindow: glowESP(processHandle, client) time.sleep(0.01) end = True time.sleep(0.01) if __name__ == "__main__": main() Não testei em competitivo nem casual, apenas com BOTS. Lembre-se de que quando testar, se não funcionar, olha o terminal e vê a linha que está sendo printada. Vai ter um print dessa forma: IN GAME CLIENT: X == 0? Você precisa verificar que número é esse X de acordo com o modo de jogo (competitivo, casual, etc) e alterar na linha abaixo. Créditos: Robater
  9. Olá, estou desenvolvendo um programa no Python que é mais ou menos assim: Tem varias opções e o usuário escolhe uma delas. Só que eis as minhas dúvidas: Como faço para essas opções ficarem repetindo? (P. Exm: Op 01 Op 02 Op 03 "Escolho a 02" >>>Aparece o conteúdo da 2 [Aqui novamente aparece as opções e assim sucessivamente, até o usuário encerrar de vez o programa). (Ps. Sou iniciante no Python mas tenho uma noção de como fazer isso). Outra dúvida é sobre retornar uma mensagem de erro quando o usuário digitar algo q não deve. Usei o Try // Except Exception mas n soube muito como usar.
  10. 7. Em um banco, o atendimento se dá normalmente através de filas e, como deve ser, respeitam as prioridades (idosos, deficientes, grávidas ou com bebê de colo. Para isso, a cada dois atendimentos não-prioritários, eles encaixam um atendimento prioritário (começam por um prioritário, se já existir). Escreva um programa que, usando filas, simule esse esquema de atendimento do banco. O programa deve pedir ao usuário os nomes das pessoas que estarão na fila e se são prioridade ou não. O usuário pode informar quantas pessoas quiser. Após isso, o programa vai “esvaziando” a fila a cada atendimento, imprimindo na tela o nome de quem foi atendido e se era prioridade ou não, e os nomes dos que ainda estão esperando. Todos os clientes chegam antes de começar o atendimento, ou seja, depois que todos chegam é que as filas começarão a ser esvaziadas. 12. Considerando uma matriz 4×4 preenchida com valores inteiros, mostre a média dos elementos da diagonal principal. Dica: a diagonal principal é formada por elementos que tem o índice de linha igual ao índice de coluna. A[0][0], A[1][1] e A[2][2]. Alguem pode me ajudar com essas questões?
  11. Fala ai galera, blz? Encontrei este tutorial bacana, porem está em ingles e traduzir com o google pra ficar mais fácil a leitura. No final do post terá o link com o artigo original em ingles. Obrigado! Como construir um Bot em Python que pode jogar jogos na Web Neste tutorial, exploraremos os prós e contras da construção de um jogo de jogo baseado em computador em Python, que poderá jogar o popular jogo Flash Sushi Go Round. Você pode usar as técnicas ensinadas neste tutorial para criar bots para testar automaticamente seus próprios jogos na web. Pré-visualização final do resultado Vamos dar uma olhada no resultado final em que estaremos trabalhando: Pré-requisitos Este tutorial e todo o código nele requer que algumas bibliotecas Python adicionais sejam instaladas. Eles fornecem um bom pacote de Python para um monte de código C de baixo nível que facilita muito o processo e a velocidade do script do bot. Alguns dos códigos e bibliotecas são específicos do Windows. Pode haver equivalentes de Mac ou Linux, mas não iremos cobri-los neste tutorial. Você precisará baixar e instalar as seguintes bibliotecas: The Python Imaging Library Numpy PyWin Todos os itens acima possuem auto instaladores; Executá-los instalará automaticamente os módulos em seu diretório \ lib \ site-packages e, em teoria, ajustará seu pythonPath de acordo. No entanto, na prática, isso nem sempre acontece. Se você começar a receber mensagens de erro de importação após a instalação, provavelmente você precisará ajustar manualmente suas variáveis de ambiente. Mais informações sobre como ajustar variáveis de caminho podem ser encontradas aqui. A ferramenta final que precisaremos é um programa de pintura decente. Sugiro Paint.NET como uma excelente opção gratuita, mas qualquer programa com regras que exibem suas medidas em pixels pode ser usado. Usaremos alguns jogos como exemplos ao longo do caminho. Introdução Este tutorial é escrito para dar uma introdução básica ao processo de construção de bots que jogam jogos baseados no navegador. A abordagem que vamos tomar é provavelmente um pouco diferente do que a maioria esperaria quando pensasse em um bot. Ao invés de fazer um programa que fica entre o cliente e o código de injeção do servidor (como um botão Quake ou C / S), nosso bot se sentará puramente no "exterior". Nós confiamos nas técnicas de Visão de Computador e nas chamadas da API do Windows para reunir informações necessárias e gerar movimentos. Com essa abordagem, perdemos um pouco de detalhes refinados e controle, mas compensamos isso em tempo de desenvolvimento reduzido e facilidade de uso. A automação de uma função de jogo específica pode ser feita em algumas linhas curtas de código, e um botão de início a término (para um jogo simples) pode ser ativado em algumas horas. As alegrias desta abordagem rápida são tais que, uma vez que você se familiarize com o que o computador pode facilmente "ver", você começará a ver os jogos de forma ligeiramente diferente. Um bom exemplo é encontrado em jogos de quebra-cabeças. Uma construção comum envolve a exploração de limitações de velocidade humana para forçá-lo a uma solução menos do que ideal. É divertido (e muito fácil) "quebrar" esses jogos através de scripts em movimentos que nunca poderiam ser realizados por um ser humano. Esses bots também são muito úteis para testar jogos simples - ao contrário de um ser humano, um bot não ficará entediado jogando o mesmo cenário uma e outra vez. O código-fonte para todos os exemplos do tutorial, bem como para um dos bots de exemplo concluídos, pode ser encontrado aqui. Diverta-se! Passo 1: Criar um novo projeto Python Em uma nova pasta, clique com o botão direito do mouse e selecione Novo> Documento de texto. Uma vez feito, mude o nome do arquivo 'Novo documento de texto' para 'quickGrab.py' (sem as aspas) e confirme que deseja alterar a extensão do nome do arquivo. Finalmente, clique com o botão direito do mouse no nosso arquivo recém-criado e selecione "Editar com IDLE" no menu de contexto para iniciar o editor Etapa 2: Configurando o seu primeiro captador de tela Começaremos a trabalhar no nosso bot, explorando a função básica de captura de tela. Uma vez em funcionamento, passaremos por linha por linha, pois esta função (e suas muitas iterações) servirá como espinha dorsal do nosso código. Em quickgrab.py, digite o seguinte código: <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import ImageGrab</span> Import ImageGrab</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import os</span> importar os</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import time</span> tempo de importação</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def screenGrab():</span> def screenGrab ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">box = ()</span> caixa = ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im = ImageGrab.grab()</span> im = ImageGrab.grab ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im.save(os.getcwd() + '\\full_snap__' + str(int(time.time())) +</span> im.save (os.getcwd () + '\\ full_snap__' + str (int (time.time ())) +</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">'.png', 'PNG')</span> '.png', 'PNG')</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def main():</span> def main ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">screenGrab()</span> captura de tela()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">if __name__ == '__main__':</span> se __name__ == '__main__':</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">main()</span> a Principal()</span> A execução deste programa deve dar-lhe um instantâneo completo da área da tela: O código atual agarra toda a largura e altura da sua área de tela e armazena-o como um PNG no seu diretório de trabalho atual. Agora vamos passar pelo código para ver exatamente como isso funciona. As primeiras três linhas: <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import ImageGrab</span> Import ImageGrab</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import os</span> importar os</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import time</span> tempo de importação</span> ... são as "declarações de importação" apropriadamente mencionadas. Isso diz ao Python que carregue nos módulos listados no tempo de execução. Isso nos dá acesso aos seus métodos através da sintaxe module.attribute . O primeiro módulo é parte da Python Image Library que instalamos anteriormente. Como o próprio nome sugere, isso nos dá a funcionalidade de gabbing de tela básica em que nosso bot confiará. A segunda linha importa o módulo do sistema operacional (sistema operacional). Isso nos dá a capacidade de navegar facilmente pelos diretórios do nosso sistema operacional. Vai ser útil quando começamos a organizar ativos em diferentes pastas. Esta importação final é o módulo de tempo incorporado. Bem, use isso principalmente para carimbar a hora atual em instantâneos, mas pode ser muito útil como um temporizador para bots que precisam de eventos desencadeados ao longo de um determinado número de segundos. As próximas quatro linhas constituem o coração da nossa função screenGrab() . <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def screenGrab():</span> def screenGrab ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">box = ()</span> caixa = ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im = ImageGrab.grab()</span> im = ImageGrab.grab ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im.save(os.getcwd() + '\\full_snap__' + str(int(time.time())) +</span> im.save (os.getcwd () + '\\ full_snap__' + str (int (time.time ())) +</span> A primeira linha def screenGrab() define o nome da nossa função. Os parênteses vazios significam que não espera nenhum argumento. Linha 2, box=() atribui uma tupla vazia a uma variável chamada "caixa". Vamos preencher isso com argumentos na próxima etapa. Linha 3, im = ImageGrab.grab() cria um instantâneo completo da tela e retorna uma imagem RGB para a instância. A Linha 4 pode ser um pouco complicada se você não estiver familiarizado com o funcionamento do módulo de Time . A primeira parte im.save( chama o método "salvar" da classe Image. Ele espera dois argumentos. O primeiro é o local onde salvar o arquivo e o segundo é o formato do arquivo. Aqui nós definimos o local primeiro chamando os.getcwd() . Isso obtém o diretório atual do código que está sendo executado e o retorna como uma string. Em seguida, adicione um + . Isso será usado entre cada novo argumento para concatenar todas as cordas juntas. A próxima peça '\\full_snap__ dá ao nosso arquivo um nome simples e descritivo. (Porque a barra invertida é um caractere de escape em Python, temos que adicionar dois deles para evitar cancelar uma de nossas letras). O próximo é o bit de cabelo: str(int(time.time())) . Isso aproveita os métodos incorporados do Python. Vamos explicar esta peça trabalhando de dentro para fora: time.time() retorna o número de segundos desde Epoch, que é dado como um tipo Float. Uma vez que estamos criando um nome de arquivo, não podemos ter o decimal lá, então primeiro o convertem em um número inteiro envolvendo-o em int() . Isso nos aproxima, mas o Python não pode concatenar o tipo Int com o tipo String , então o último passo é embrulhar tudo na função str() para nos dar um bom timestamp utilizável para o nome do arquivo. A partir daqui, tudo o que resta é adicionar a extensão como parte da string: + '.png' e passar o segundo argumento que é novamente o tipo da extensão: "PNG" . A última parte do nosso código define a função main() e diz para chamar a função screenGrab() sempre que for executada. E aqui, no final, é uma convenção Python que verifica se o script é de nível superior e, se assim, permite que ele seja executado. Traduzido, significa simplesmente que ele só executa main() se é executado sozinho. Caso contrário - se, por exemplo, for carregado como um módulo por um script diferente do Python - ele apenas fornece seus métodos em vez de executar seu código. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def main():</span> def main ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">screenGrab()</span> captura de tela()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">if __name__ == '__main__':</span> se __name__ == '__main__':</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">main()</span> a Principal()</span> Passo 3: a caixa de encadernação A função ImageGrab.grab() aceita um argumento que define uma caixa delimitadora. Esta é uma tupla de coordenadas seguindo o padrão de (x, y, x, y) onde, O primeiro par de valores ( x,y.. define o canto superior esquerdo da caixa O segundo par ..x,y ) define o canto inferior direito. A combinação destes permite copiar somente a parte da tela que precisamos. Vamos colocar isso em prática. Para este exemplo, vamos usar um jogo chamado Sushi Go Round . ( Muitoviciante. Você foi avisado.) Abra o jogo em uma nova guia e faça um instantâneo usando nosso código screenGrab() existente: Um instantâneo da área de tela cheia. Passo 4: Obtendo Coordenadas Agora é hora de começar a extrair algumas coordenadas para a nossa caixa delimitadora. Abra seu instantâneo mais recente em um editor de imagens. A posição (0,0) está sempre localizada no canto superior esquerdo da imagem. Queremos colocar as coordenadas x e y para que nossa nova função de instantâneo seja definida (0,0) no canto mais à esquerda da área de jogo do jogo. Os motivos para isso são duplos. Primeiro, torna as coordenadas no jogo muito mais fáceis quando precisamos apenas ajustar os valores em relação à área de reprodução versus a área inteira da resolução da tela. Em segundo lugar, pegar uma porção menor da tela reduz as despesas gerais de processamento necessárias. As gravações em tela cheia produzem um pouco de dados, o que pode dificultar a sua trajetória várias vezes por segundo. Se não for feito já, habilite a exibição da régua em seu editor e faça zoom no canto superior da área de reprodução até que você possa ver os pixels em detalhes: Passe o cursor sobre o primeiro pixel da área de reprodução e verifique as coordenadas exibidas na régua. Estes serão os dois primeiros valores da nossa tupla Box. Na minha máquina específica, esses valores são 157, 162 . Navegue até a borda inferior da área de reprodução para obter o par inferior das coordenadas. Isso mostra as coordenadas de 796 e 641. A combinação destes com o nosso par anterior dá uma caixa com as coordenadas de (157,162,796,641) . Vamos adicionar isso ao nosso código. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import ImageGrab</span> Import ImageGrab</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import os</span> importar os</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import time</span> tempo de importação</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def screenGrab():</span> def screenGrab ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">box = (157,346,796,825)</span> caixa = (157,346,796,825)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im = ImageGrab.grab(box)</span> im = ImageGrab.grab (caixa)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im.save(os.getcwd() + '\\full_snap__' + str(int(time.time())) +</span> im.save (os.getcwd () + '\\ full_snap__' + str (int (time.time ())) +</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">'.png', 'PNG')</span> '.png', 'PNG')</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def main():</span> def main ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">screenGrab()</span> captura de tela()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">if __name__ == '__main__':</span> se __name__ == '__main__':</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">main()</span> a Principal()</span> Na linha 6, atualizamos a tupla para manter as coordenadas da área de reprodução. Salve e execute o código. Abra a imagem recém-salva e você deve ver: Sucesso! Uma captura perfeita da área de jogo. Nem sempre precisamos fazer esse tipo de busca intensiva por coordenadas. Uma vez que entramos no win32api, examinaremos alguns métodos mais rápidos para configurar as coordenadas quando não precisarmos de precisão de pixel perfeita. Passo 5: planejamento para a flexibilidade Como está agora, codificamos as coordenadas em relação à nossa configuração atual, assumindo nosso navegador e nossa resolução.Geralmente, é uma má idéia as coordenadas de código rígido desta maneira.Se, por exemplo, queremos executar o código em um computador diferente - ou dizer, um novo anúncio no site desloca ligeiramente a posição da área de jogo - teríamos que consertar manualmente e minuciosamente todas as nossas chamadas de coordenadas. Então vamos criar duas novas variáveis: x_pad e y_pad . Estes serão usados para armazenar a relação entre a área do jogo e o resto da tela. Isso tornará muito fácil a porta do código de um lugar para outro, uma vez que cada nova coordenada será relativa às duas variáveis globais que vamos criar e para ajustar as mudanças na área da tela, tudo o que é necessário é redefinir esses dois variáveis. Como já realizamos as medições, definir as almofadas para o nosso sistema atual é muito direto. Vamos configurar as almofadas para armazenar a localização do primeiro pixel fora da área de jogo. Do primeiro par de coordenadas x, y na nossa tupla da box , subtrair um 1 de cada valor. Então 157 torna-se 156 e 346 torna-se 345 . Vamos adicionar isso ao nosso código. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left"># Globals</span> # Globals</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left"># ------------------</span> # ------------------</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">x_pad = 156</span> x_pad = 156</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">y_pad = 345</span> y_pad = 345</span> Agora que estes estão configurados, começaremos a ajustar a tupla da caixa para estar em relação a esses valores. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def screenGrab():</span> def screenGrab ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">box = (x_pad+1, y_pad+1, 796, 825)</span> caixa = (x_pad + 1, y_pad + 1, 796, 825)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im = ImageGrab.grab()</span> im = ImageGrab.grab ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im.save(os.getcwd() + '\\full_snap__' + str(int(time.time())) +</span> im.save (os.getcwd () + '\\ full_snap__' + str (int (time.time ())) +</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">'.png', 'PNG')</span> '.png', 'PNG')</span> Para o segundo par, vamos primeiro subtrair os valores das almofadas (156 e 345) das coordenadas (796, 825) e, em seguida, usar esses valores no mesmo formato Pad + Value . <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def screenGrab():</span> def screenGrab ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">box = (x_pad+1, y_pad+1, x_pad+640, y_pad+479)</span> caixa = (x_pad + 1, y_pad + 1, x_pad + 640, y_pad + 479)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im = ImageGrab.grab()</span> im = ImageGrab.grab ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">im.save(os.getcwd() + '\\full_snap__' + str(int(time.time())) +</span> im.save (os.getcwd () + '\\ full_snap__' + str (int (time.time ())) +</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">'.png', 'PNG')</span> '.png', 'PNG')</span> Aqui, a coordenada x se torna 640 (769-156), e o y se torna 480 (825-345) Pode parecer um pouco redundante no início, mas fazer este passo extra garante uma fácil manutenção no futuro. Etapa 6: Criando uma Docstring Antes de avançarmos, vamos criar um docstring no topo do nosso projeto.Uma vez que a maioria do nosso código será baseado em coordenadas de tela específicas e relacionamentos para coordenadas, é importante conhecer as circunstâncias em que tudo se alinhará corretamente. Por exemplo, coisas como a resolução atual, navegador, barras de ferramentas habilitadas (uma vez que alteram a área do navegador) e quaisquer ajustes necessários para centrar a área de reprodução na tela, todos afetam a posição relativa das coordenadas. Ter tudo isso documentado ajuda muito o processo de solução de problemas ao executar seu código em vários navegadores e computadores. Uma última coisa a ter em conta é o espaço publicitário em constante mudança em sites de jogos populares. Se todas as suas chamadas de gravação de repente parem de se comportar conforme o esperado, uma nova introdução de coisas ligeiramente divertidas na tela é uma boa aposta. Como exemplo, geralmente tenho os seguintes comentários no topo do meu código Python: <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">"""</span> "" "</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">All coordinates assume a screen resolution of 1280x1024, and Chrome</span> Todas as coordenadas assumem uma resolução de tela de 1280x1024 e Chrome</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">maximized with the Bookmarks Toolbar enabled.</span> maximizado com a barra de ferramentas de marcadores habilitada.</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">Down key has been hit 4 times to center play area in browser.</span> A tecla Down foi atingida 4 vezes na área central de reprodução no navegador.</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">x_pad = 156</span> x_pad = 156</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">y_pad = 345</span> y_pad = 345</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">Play area = x_pad+1, y_pad+1, 796, 825</span> Área de reprodução = x_pad + 1, y_pad + 1, 796, 825</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">"""</span> "" "</span> Largar toda essa informação no início do seu arquivo Python torna rápido e fácil verificar todas as configurações e o alinhamento da tela sem ter que controlar seu código tentando lembrar onde você armazenou essa coordenada x específica. Passo 7: Transformando o quickGrab.py em uma ferramenta útil Nós vamos conquistar nosso projeto neste momento, criando dois arquivos: um para armazenar todo o código do nosso bot e o outro para atuar como um utilitário geral de captura de tela. Nós estaremos tomando muitas capturas de tela enquanto buscamos coordenadas, então, ter um módulo separado pronto para ir, tornará as coisas muito mais rápidas. Salve e feche o nosso projeto atual. Na sua pasta, clique com o botão direito do mouse em quickGrab.py e selecione 'copiar' no menu. Agora, clique com o botão direito do mouse e selecione 'colar' no menu Selecione o arquivo copiado e renomeie-o para 'code.py' A partir de agora, todas as novas adições e alterações de código serão feitas em code.py. O FastGrab.py agora funcionará apenas como uma ferramenta de instantâneo. Só precisamos fazer uma última modificação: Altere a extensão do arquivo de .py, para .pyw e confirme as alterações. Esta extensão informa o Python para executar o script sem iniciar o console.Então agora, quickGrab.pyw faz jus ao seu nome. Clique duas vezes no arquivo e ele executará silenciosamente seu código em segundo plano e salvará um instantâneo no seu diretório de trabalho. Mantenha o jogo aberto em segundo plano (certifique-se de silenciá-lo antes que a música em loop o leve à loucura); voltaremos em breve. Temos mais alguns conceitos / ferramentas para apresentar antes de entrar no controle de coisas na tela. Passo 8: Win32api - Uma breve visão geral Trabalhar com o win32api pode ser um pouco intimidante inicialmente. Ele envolve o código do Windows C de baixo nível - o que é felizmente muito bem documentado aqui , mas um pouco como um labirinto para navegar pelo seu primeiro par de go-arounds. Antes de iniciar o script de qualquer ação útil, vamos examinar de perto algumas das funções da API sobre as quais confiamos. Uma vez que tenhamos uma compreensão clara de cada parâmetro, será fácil ajustá-los para servir os fins que precisamos no jogo. O win32api.mouse_event() : <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">win32api.mouse_event(</span> win32api.mouse_event (</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">dwFlags,</span> dwFlags</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">dx,</span> dx</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">dy,</span> dy</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">dwData</span> dwData</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">)</span> )</span> O primeiro parâmetro dwFlags define a "ação" do mouse. Ele controla coisas como movimento, clique, rolagem, etc. A lista a seguir mostra os parâmetros mais comuns usados durante o movimento de script. dwFlags : win32con.MOUSEEVENTF_LEFTDOWN win32con.MOUSEEVENTF_LEFTUP win32con.MOUSEEVENTF_MIDDLEDOWN win32con.MOUSEEVENTF_MIDDLEUP win32con.MOUSEEVENTF_RIGHTDOWN win32con.MOUSEEVENTF_RIGHTUP win32con.MOUSEEVENTF_WHEEL Cada nome é auto-explicativo. Se você quisesse enviar um clique direito virtual, você passaria o win32con.MOUSEEVENTF_RIGHTDOWN para o parâmetro dwFlags . Os dois parâmetros seguintes, dx e dy , descrevem a posição absoluta do mouse ao longo dos eixos x e y. Embora possamos usar esses parâmetros para rotear o movimento do mouse, eles usam um sistema de coordenadas diferente do que usamos. Então, vamos deixá-los definidos para zero e confiar em uma parte diferente da API para as nossas necessidades de mudança de mouse. O quarto parâmetro é dwData . Esta função é usada se (e somente se) dwFlagscontém MOUSEEVENTF_WHEEL . Caso contrário, pode ser omitido ou definido como zero. dwData especifica a quantidade de movimento na roda de rolagem do mouse. Um exemplo rápido para solidificar essas técnicas: Se imaginarmos um jogo com um sistema de seleção de armas semelhante ao Half-Life 2 - onde as armas podem ser selecionadas girando a roda do mouse - nós apresentamos a seguinte função para examinar a lista de armas: <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def browseWeapons():</span> def browseWeapons ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">weaponList = ['crowbar','gravity gun','pistol'...]</span> weaponList = ['crowbar', 'pistola de gravidade', 'pistola' ...]</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">for i in weaponList:</span> para eu em weaponList:</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">win32api.mouse_event(win32con.MOUSEEVENTF_MOUSEEVENTF_WHEEL,0,0,120)</span> win32api.mouse_event (win32con.MOUSEEVENTF_MOUSEEVENTF_WHEEL, 0,0120)</span> Aqui queremos simular a rolagem da roda do mouse para navegar nossa lista de armas teóricas, então passamos ...MOUSEEVENTF_WHEEL 'ação' para o dwFlag.Não precisamos de dx ou dy , dados de posição, então deixávamos aqueles definidos para zero, e queríamos rolar um clique na direção direta para cada "arma" na lista, então passamos o inteiro 120 para dwData (cada um O clique da roda é igual a 120). Como você pode ver, trabalhar com mouse_event é simplesmente uma questão de conectar os argumentos certos ao lugar certo. Vamos agora passar para algumas funções mais utilizáveis Etapa 5: clique básico do mouse Vamos fazer três novas funções. Uma função geral do botão esquerdo e dois que manipulam os estados específicos para baixo e para cima. Abra code.py com IDLE e adicione o seguinte à nossa lista de declarações de importação: <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">import win32api, win32con</span> importe win32api, win32con</span> Como antes, isso nos dá acesso ao conteúdo do módulo através da sintaxe module.attribute . Em seguida, faremos nossa primeira função de clique do mouse. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def leftClick():</span> def leftClick ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,0,0)</span> win32api.mouse_event (win32con.MOUSEEVENTF_LEFTDOWN, 0,0)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,0,0)</span> win32api.mouse_event (win32con.MOUSEEVENTF_LEFTUP, 0,0)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">print "Click."</span> imprimir "clicar".</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">#completely optional.</span> # Completamente opcional.</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">But nice for debugging purposes.</span> Mas bom para fins de depuração.</span> Lembre-se de que tudo o que estamos fazendo aqui é atribuir uma "ação" ao primeiro argumento do mouse_event . Não precisamos passar nenhuma informação de posicionamento, por isso estamos deixando os parâmetros de coordenadas em (0,0), e não precisamos enviar nenhuma informação adicional, então dwData está sendo omitido. A função time.sleep(.1) informa Python para interromper a execução pelo tempo especificado entre parênteses. Nós iremos adicionar isso através do nosso código, geralmente por uma quantidade muito curta de vezes. Sem isso, o "clique" pode avançar e disparar antes que os menus tenham a chance de atualizar. Então, o que fizemos aqui é um clique esquerdo geral. Uma imprensa, uma versão. Vamos passar a maior parte do tempo com este, mas vamos fazer mais duas variações. Os próximos dois são exatamente o mesmo, mas agora cada etapa é dividida em sua própria função. Estes serão usados quando precisamos manter pressionado o mouse por um longo período de tempo (para arrastar, disparar, etc.). <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def leftDown():</span> def leftDown ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN,0,0)</span> win32api.mouse_event (win32con.MOUSEEVENTF_LEFTDOWN, 0,0)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">print 'left Down'</span> imprimir 'para baixo para baixo'</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def leftUp():</span> def leftUp ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP,0,0)</span> win32api.mouse_event (win32con.MOUSEEVENTF_LEFTUP, 0,0)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">print 'left release'</span> imprimir 'release esquerdo'</span> Passo 9: Movimento básico do mouse Ao clicar no caminho, tudo o que resta é mover o mouse na tela. Adicione as seguintes funções a code.py : <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def mousePos(cord):</span> def mousePos (cabo):</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">win32api.SetCursorPos((x_pad + cord[0], y_pad + cord[1])</span> win32api.SetCursorPos ((x_pad + cordão [0], y_pad + cordão [1])</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def get_cords():</span> def get_cords ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">x,y = win32api.GetCursorPos()</span> x, y = win32api.GetCursorPos ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">x = x - x_pad</span> x = x - x_pad</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">y = y - y_pad</span> y = y - y_pad</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">print x,y</span> print x, y</span> Essas duas funções atendem a propósitos distintamente diferentes. O primeiro será usado para mover scripts no programa. Graças a excelentes convenções de nomenclatura, o corpo da função faz exatamente como SetCursorPos() implica. Chamando essa função define o mouse nas coordenadas passadas para ele como uma tupla x,y . Observe que adicionamos em nossas almofadas x e y ; É importante fazer isso em qualquer lugar, uma coordenada é chamada. O segundo é uma ferramenta simples que usaremos ao executar o Python de forma interativa. Ele imprime no console a posição atual do mouse como uma tupla x,y . Isso acelera o processo de navegar por menus sem ter que tirar uma foto e sair com uma régua. Nem sempre poderemos usá-lo, pois algumas atividades do mouse precisarão ser específicas de pixels, mas quando pudermos, é uma economia de tempo fantástica. No próximo passo, vamos colocar algumas dessas novas técnicas para usar e começar a navegar nos menus do jogo. Mas antes de fazê-lo, exclua o conteúdo atual do main() em code.py e substitua-o por pass . Nós estaremos trabalhando com o prompt interativo para o próximo passo, então não precisaremos da função screenGrab() . Etapa 10: Menus do jogo de navegação get_cords() , e as próximas etapas, vamos tentar reunir as coordenadas de eventos que possamos usando o nosso método get_cords() . Usando isso, poderemos construir rapidamente o código para coisas como navegar em menus, limpar tabelas e fazer comida. Uma vez que tenhamos esse conjunto, será apenas uma questão de conectá-los à lógica do bot. Vamos começar. Salve e execute seu código para abrir o shell Python. Uma vez que substituímos o corpo do main() por pass no último passo, você deve ver um invólucro em branco ao correr. Agora, antes mesmo de chegar à parte jogável do jogo, há quatro menus iniciais que precisamos passar. Eles são os seguintes: 1 - Botão inicial de "reprodução" 2 - Botão "continuar" do iPhone 3 - Tutorial botão "Saltar" 4 - O objetivo de hoje "Continuar" Teremos que obter as coordenadas para cada um destes e adicioná-los a uma nova função chamada startGame() . Posicione o shell IDLE para que você possa ver ambos e a área de jogo. Digite a função get_cords() , mas não pressione retornar ainda; Mova o mouse sobre o botão para o qual você precisa de coordenadas. Certifique-se de não clicar ainda, pois queremos que o foco permaneça no shell. Passe o mouse sobre o item do menu e pressione a tecla de retorno. Isso irá pegar a localização atual do mouse e imprimir no console uma tupla contendo os valores x,y . Repita isso para os três menus restantes. Deixe o shell aberto e organize-o para que você possa vê-lo, bem como o editor IDLE. Agora vamos agora adicionar a nossa função startGame() e preenchê-la com as nossas coordenadas recém-adquiridas. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def startGame():</span> def startGame ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">#location of first menu</span> #localização do primeiro menu</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((182, 225))</span> mousePos ((182, 225))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">#location of second menu</span> #localização do segundo menu</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((193, 410))</span> mousePos ((193, 410))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">#location of third menu</span> #localização do terceiro menu</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((435, 470))</span> mousePos ((435, 470))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">#location of fourth menu</span> #localização do quarto menu</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((167, 403))</span> mousePos ((167, 403))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> Agora temos uma boa função compacta para ligar no início de cada jogo.Define a posição do cursor para cada um dos locais de menu que definimos anteriormente e, em seguida, diz ao mouse para clicar. time.sleep(.1) diz a Python que interrompa a execução por 1/10 de segundo entre cada clique, o que dá aos menus tempo suficiente para atualizar entre eles. Salve e execute seu código e você deve ver um resultado semelhante a este: Como um humano fraco leva-me um pouco mais de um segundo para navegar todos os menus à mão, mas o nosso bot agora pode fazê-lo em cerca de .4 segundos. Nada mal a todos! Passo 11: Obter Coordenadas de Alimentos Agora, vamos repetir o mesmo processo para cada um desses botões: Mais uma vez, no shell Python, digite get_cords() , passe o mouse sobre a caixa de alimentos que você precisa e pressione a tecla Enter para executar o comando. Como uma opção para acelerar ainda mais as coisas, se você tiver um segundo monitor ou for capaz de organizar o shell python de forma que você possa vê-lo, bem como a área do jogo, em vez de digitar e executar get_cords() cada vez nós precisamos disso, podemos configurar um loop simples for . Use um método time.sleep() para interromper a execução apenas o tempo suficiente para que você mova o mouse para a próxima localização que precisa de coordenadas. Aqui está o loop para ação: Vamos criar uma nova classe chamada Cord e usá-la para armazenar todos os valores de coordenadas que reunimos. Ser capaz de chamar Cord.f_riceoferece uma enorme vantagem de legibilidade ao passar as coordenadas diretamente para mousePos() . Como uma opção, você também pode armazenar tudo em um dictionary , mas acho a sintaxe da classe mais agradável. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">class Cord:</span> classe Cord:</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_shrimp = (54,700)</span> f_shrimp = (54,700)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_rice = (119 701)</span> f_rice = (119 701)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_nori = (63 745)</span> f_nori = (63 745)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_roe = (111 749)</span> f_roe = (111 749)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_salmon = (54 815)</span> f_salmon = (54 815)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_unagi = (111 812)</span> f_unagi = (111 812)</span> Nós vamos armazenar muitas das nossas coordenadas nesta classe, e haverá uma sobreposição, então, adicionando o prefixo ' f_ ' nos informa que nos referimos aos locais de comida, em vez de, digamos, uma localização no telefone cardápio. Vamos voltar a isso em um pouco. Há um pouco mais de caça coordenada para fazer! Etapa 12: Obtendo coordenadas de placas vazias Cada vez que um cliente termina de comer, eles deixam para trás uma placa que precisa ser clicada para ser removida. Então, precisamos obter a localização das placas vazias também. Eu notei sua posição com um 'X' vermelho gigante. Repita o mesmo padrão nas duas últimas etapas para obter suas coordenadas. Armazene-os na string de comentário por enquanto. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">"""</span> "" "</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">Plate cords:</span> Cordas de placa:</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">108, 573</span> 108, 573</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">212, 574</span> 212, 574</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">311, 573</span> 311, 573</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">412, 574</span> 412, 574</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">516, 575</span> 516, 575</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">618, 573</span> 618, 573</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">"""</span> "" "</span> Estamos chegando perto. Apenas mais algumas etapas de configuração preliminar antes de entrarmos nas coisas realmente divertidas. Passo 13: Obtendo Coordenadas do Telefone Ok, este será o conjunto final de coordenadas que temos para minar desta maneira específica. Este tem muito mais para acompanhar, então você pode querer fazê-lo chamando manualmente a função get_cords() em vez do método de loop anteriormente usado. De qualquer forma, vamos passar por todos os menus do telefone para obter as coordenadas de cada item. Este é um pouco mais envolvido no sentido de alcançar uma das telas de compra que precisamos, você precisa ter dinheiro suficiente para realmente comprar algo. Então você precisará fazer alguns pedaços de sushi antes de ir sobre o negócio da caça coordenada. No máximo, você terá que fazer dois roquetes de sushi, eu acredito. Isso o levará o suficiente para comprar arroz, o que nos levará à tela que precisamos. Existem seis menus que temos para passar: 1 - O telefone 2 - Menu inicial 3 - Toppings 4 - Arroz 5 - Remessa Precisamos obter coordenadas para tudo, exceto Sake (embora você possa, se você quiser. Achei que o bot funcionava bem sem ele. Eu estava disposto a sacrificar a crítica ocasional do jogo em não ter que codificar na lógica.) Obtendo as coordenadas: Vamos adicionar tudo isso à nossa classe Cord. Usaremos o prefixo ' t_ ' para denotar que os tipos de comida são itens de menu toppings para telefone. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">class Cord:</span> classe Cord:</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_shrimp = (54,700)</span> f_shrimp = (54,700)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_rice = (119 701)</span> f_rice = (119 701)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_nori = (63 745)</span> f_nori = (63 745)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_roe = (111 749)</span> f_roe = (111 749)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_salmon = (54 815)</span> f_salmon = (54 815)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">f_unagi = (111 812)</span> f_unagi = (111 812)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">#-----------------------------------</span> # -----------------------------------</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">phone = (601, 730)</span> telefone = (601, 730)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">menu_toppings = (567, 638)</span> menu_toppings = (567, 638)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">t_shrimp = (509, 581)</span> t_shrimp = (509, 581)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">t_nori = (507, 645)</span> t_nori = (507, 645)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">t_roe = (592, 644)</span> t_roe = (592, 644)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">t_salmon = (510, 699)</span> t_salmon = (510, 699)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">t_unagi = (597, 585)</span> t_unagi = (597, 585)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">t_exit = (614, 702)</span> t_exit = (614, 702)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">menu_rice = (551, 662)</span> menu_rice = (551, 662)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">buy_rice = 564, 647</span> buy_rice = 564, 647</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">delivery_norm = (510, 664)</span> Delivery_norm = (510, 664)</span> Bem! Finalmente, extraímos todos os valores de coordenadas que precisamos.Então vamos começar a fazer algo útil! Etapa 14: Limpeza de tabelas Vamos pegar nossas coordenadas previamente gravadas e usá-las para preencher uma função chamada clear_tables (). <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def clear_tables():</span> def clear_tables ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((108, 573))</span> mousePos ((108, 573))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((212, 574))</span> mousePos ((212, 574))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((311, 573))</span> mousePos ((311, 573))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((412, 574))</span> mousePos ((412, 574))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((516, 575))</span> mousePos ((516, 575))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((618, 573))</span> mousePos ((618, 573))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(1)</span> time.sleep (1)</span> Como você pode ver, isso parece mais ou menos exatamente como a nossa função startGame() anterior. Algumas pequenas diferenças: Não temos funções time.sleep() entre os diferentes eventos de clique. Não precisamos aguardar qualquer atualização de menus, portanto, não precisamos acelerar nossas velocidades de clique. Nós, no entanto, temos um longo tempo. time.sleep() no final. Embora não seja estritamente necessário, é bom adicionar essas pausas ocasionais em execução ao nosso código, algo apenas o suficiente para nos dar tempo para sair manualmente do loop principal do bot, se necessário (o que iremos chegar). Caso contrário, a coisa continuará a roubar a posição do mouse uma e outra vez, e você não poderá mudar o foco para o shell o suficiente para parar o script - o que pode divertir as primeiras duas ou três vezes enquanto luta contra um mouse , mas rapidamente perde seu charme. Portanto, certifique-se de adicionar algumas pausas confiáveis em seus próprios robôs! Passo 15: Fazer Sushi A primeira coisa que precisamos fazer é aprender a fazer o sushi. Clique no livro de receitas para abrir o manual de instruções. Todos os tipos de sushi encontrados ao longo do jogo serão encontrados em suas páginas. Vou notar os três primeiros abaixo, mas deixo para você catalogar o resto. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">'''</span> '' '</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">Recipes:</span> Receitas:</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">onigiri</span> onigiri</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">2 rice, 1 nori</span> 2 arroz, 1 nori</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">caliroll:</span> Caliroll:</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">1 rice, 1 nori, 1 roe</span> 1 arroz, 1 nori, 1 roe</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">gunkan:</span> gunkan:</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">1 rice, 1 nori, 2 roe</span> 1 arroz, 1 nori, 2 ovas</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">'''</span> '' '</span> Agora, vamos configurar uma função que aceitará um argumento para "tipo de sushi" e, em seguida, montar os ingredientes apropriados com base no valor passado. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def makeFood(food):</span> def makeFood (comida):</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">if food == 'caliroll':</span> se comida == 'caliroll':</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">print 'Making a caliroll'</span> imprimir 'Making a caliroll'</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_rice)</span> mousePos (Cord.f_rice)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_nori)</span> mousePos (Cord.f_nori)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_roe)</span> mousePos (Cord.f_roe)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">foldMat()</span> foldMat ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(1.5)</span> time.sleep (1.5)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">elif food == 'onigiri':</span> Elif Food == 'onigiri':</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">print 'Making a onigiri'</span> print 'Making a onigiri'</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_rice)</span> mousePos (Cord.f_rice)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_rice)</span> mousePos (Cord.f_rice)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_nori)</span> mousePos (Cord.f_nori)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">foldMat()</span> foldMat ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(1.5)</span> time.sleep (1.5)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">elif food == 'gunkan':</span> elif food == 'gunkan':</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_rice)</span> mousePos (Cord.f_rice)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_nori)</span> mousePos (Cord.f_nori)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_roe)</span> mousePos (Cord.f_roe)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.05)</span> time.sleep (.05)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.f_roe)</span> mousePos (Cord.f_roe)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">foldMat()</span> foldMat ()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(1.5)</span> time.sleep (1.5)</span> Isso funciona como todos os outros, mas com uma pequena alteração: ao invés de passar diretamente as coordenadas, os chamamos de atributos da nossa classe Cord . A função foldMat() é chamada no final de cada processo de fabricação de sushi. Isso faz clic no tapete para rolar o sushi que acabamos de montar.Vamos definir essa função agora: <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def foldMat():</span> def foldMat ():</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos((Cord.f_rice[0]+40,Cord.f_rice[1]))</span> mousePos ((Cord.f_rice [0] + 40, Cord.f_rice [1]))</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">leftClick()</span> Clique esquerdo()</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">time.sleep(.1)</span> time.sleep (.1)</span> Vamos percorrer brevemente essa chamada de mousePos() , pois é um pouco encadernada. f_rice o primeiro valor da tupla do f_rice adicionando [0] no final do atributo. Lembre-se que este é o nosso valor x . Para clicar no tapete, só precisamos ajustar nossos valores x por um punhado de pixels, então adicionamos 40 à coordenada x atual e então passamos o f_rice[1] ao y .Isso muda a nossa posição x suficiente para a direita para nos permitir desencadear o tapete. Observe que, após a chamada foldMat() , temos um long time.sleep() . O Mat leva bastante tempo para rolar, e os itens alimentares não podem ser clicados enquanto suas animações estão sendo executadas, então você só precisa esperar. Etapa 16: Navegando no menu do telefone Nesta etapa, definiremos todos os mousePos() para apontar para os itens de menu apropriados, mas vamos deixá-lo por agora. Isso faz parte do programa que será envolvido e controlado pela lógica do bot. Revisaremos esta função depois de obter algumas novas técnicas ao nosso dispor. <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">def buyFood(food):</span> def buyFood (comida):</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.phone)</span> mousePos (Cord.phone)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.menu_toppings)</span> mousePos (Cord.menu_toppings)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.t_shrimp)</span> mousePos (Cord.t_shrimp)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.t_nori)</span> mousePos (Cord.t_nori)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.t_roe)</span> mousePos (Cord.t_roe)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.t_salmon)</span> mousePos (Cord.t_salmon)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.t_unagi)</span> mousePos (Cord.t_unagi)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.t_exit)</span> mousePos (Cord.t_exit)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.menu_rice)</span> mousePos (Cord.menu_rice)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.buy_rice)</span> mousePos (Cord.buy_rice)</span> <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">mousePos(Cord.delivery_norm)</span> mousePos (Cord.delivery_norm)</span> É por esta etapa. Vamos fazer mais com isso mais tarde. Breve introdução: fazer o computador ver Agora estamos chegando aos bits muito interessantes. Vamos começar a ver como fazer o computador ver os eventos na tela. Esta é uma parte muito emocionante do processo, e é fácil pensar em pensar. Outra parte pura do edifício bot é que, eventualmente, o bot pode fornecer-nos, os programadores, com informações suficientes que mais trabalho visão não é necessária. Por exemplo, no caso do bot Sushi, uma vez que temos a primeira corrida nível, o bot está cuspindo dados suficientes precisas sobre o que está acontecendo na tela que todos nós temos que fazer a partir desse ponto é levar esses dados é "ver" e simplesmente dizer-lhe como reagir a ela. Outra grande parte do edifício bot está aprendendo o jogo, sabendo que valores você precisa manter o controle da relação que você pode ignorar. Por exemplo, vamos fazer nenhum esforço para rastrear o dinheiro na mão. É apenas algo que acabou por ser irrelevante para o bot. Tudo o que precisa de saber é se ele tem comida suficiente para continuar trabalhando. Então ao invés de manter o controle sobre o total de dinheiro, ele simplesmente verifica para ver se ele pode pagar algo, independentemente do preço, porque, como ele funciona no jogo, é apenas uma questão de alguns segundos antes de você pode dar ao luxo de repor alguma coisa. Então, se não pode pagar agora, ele só tenta novamente em alguns segundos. O que me leva ao meu ponto final. A do método de força bruta contra o elegante. Algoritmos de visão tomar o tempo de processamento valioso. Verificando vários pontos em muitas regiões diferentes de área de jogo pode rapidamente corroer o seu desempenho bot, por isso se resume a uma questão de "faz o bot necessidade de saber se _______ aconteceu ou não?". Como exemplo, um cliente do jogo Sushi poderia ser pensado como tendo quatro estados: não presentes, esperando, comendo, e acabado de comer. Quando terminar, eles deixam um prato vazio piscando para trás. Eu poderia gastar o poder de processamento em verificar todos os locais placa encaixando todos os seis locais de placa e, em seguida, verificando contra um valor esperado (que é propenso a falhas desde as placas acendem e apagam, fazendo um falso negativo uma grande possibilidade), ou .. . Eu poderia apenas força bruta meu caminho através clicando em cada localização placa a cada poucos segundos. Na prática, isso é tão eficaz como a solução 'elegante' de deixar o bot determinar o estado do cliente. Clicando seis locais leva uma fração de segundo, onde como agarrar e processamento de seis imagens diferentes é relativamente lento.Podemos usar o tempo que salvou em outras tarefas mais importantes de processamento de imagem. Passo 17: importar Numpy e ImageOps Adicione o seguinte à sua lista de instruções de importação. import ImageOps from numpy import * ImageOps é outro módulo PIL. Ele é usado para executar operações (como grayscaling) em uma imagem. Vou explicar brevemente a segunda para aqueles que não estão familiarizados com o Python. Nossas demonstrações de importação padrão carrega namespace do módulo (uma coleção de nomes de variáveis e funções). Assim, para acessar itens no âmbito de um módulo, temos que empregar o module.attributesytax. No entanto, usando uma from ___ importdeclaração que herdam os nomes em nosso escopo local. Ou seja, a module.attributesintaxe não é mais necessária. Eles não são de alto nível, por isso usá-los como faria com qualquer função built-in outro Python nós, como str()ou list(). Ao importar Numpy desta forma, permite-nos simplesmente chamar array(), em vez de numpy.array(). O curinga *significa importar tudo do módulo. Passo 18: Fazendo o computador See O primeiro método que vamos explorar é a de verificar um valor RGB específica de um pixel contra um valor esperado. Este método é bom para coisas estáticas, como menus. Desde que se trata de pixels específicos, geralmente é um pouco demasiado frágil para objetos em movimento. no entanto, suas varia de caso para caso. Às vezes é a técnica perfeita, outra vez você vai ter que resolver um método diferente. Abra Sushi Go Round no seu navegador e começar um novo jogo. Ignorar seus clientes e abrir o menu do telefone. Você começa com nenhum dinheiro no banco, assim que tudo deve ser acinzentado como abaixo. Estes serão os valores RGB vamos verificar. Em code.py, vá até a sua screenGrab()função. Nós vamos fazer as seguintes alterações: def screenGrab(): b1 = (x_pad + 1,y_pad+1,x_pad+640,y_pad+480) im = ImageGrab.grab() ##im.save(os.getcwd() + '\\Snap__' + str(int(time.time())) +'.png', 'PNG') return im Nós fizemos duas pequenas mudanças. Na linha 5 comentamos a nossa declaração save. Na linha 6 que agora devolver o Imageobjeto para uso fora da função. Salvar e executar o código. Nós vamos fazer algum trabalho mais interativo. Com o menu coberturas aberto e todos os itens acinzentado, execute o seguinte código: >>>im = screenGrab() <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">>>></span> >>></span> Este atribui o snap shot levarmos em screenGrab()para a instância im. Por aqui, podemos chamar o getpixel(xy)método para pegar dados de pixel específicas. Agora precisamos de obter valores RGB para cada um dos itens acinzentado. Estes farão o nosso 'valor esperado' que o bot irá testar contra quando ele faz suas próprias getpixel()chamadas. Nós já temos as coordenadas que precisamos das etapas anteriores, então tudo o que temos a fazer é passá-las como argumentos para getpixel()e observe a saída. Saída da nossa sessão interativa: >>> im = screenGrab() >>> im.getpixel(Cord.t_nori) (33, 30, 11) >>> im.getpixel(Cord.t_roe) (127, 61, 0) >>> im.getpixel(Cord.t_salmon) (127, 71, 47) >>> im.getpixel(Cord.t_shrimp) (127, 102, 90) >>> im.getpixel(Cord.t_unagi) (94, 49, 8) >>> im.getpixel(Cord.buy_rice) (127, 127, 127) <span class="notranslate" onmouseover="_tipon(this)" onmouseout="_tipoff()"><span class="google-src-text" style="direction: ltr; text-align: left">>>></span> >>></span> Precisamos adicionar esses valores à nossa buyFood()função na forma que lhe permite saber se algo é ou não disponível. def buyFood(food): if food == 'rice': mousePos(Cord.phone) time.sleep(.1) leftClick() mousePos(Cord.menu_rice) time.sleep(.05) leftClick() s = screenGrab() if s.getpixel(Cord.buy_rice) != (127, 127, 127): print 'rice is available' mousePos(Cord.buy_rice) time.sleep(.1) leftClick() mousePos(Cord.delivery_norm) time.sleep(.1) leftClick() time.sleep(2.5) else: print 'rice is NOT available' mousePos(Cord.t_exit) leftClick() time.sleep(1) buyFood(food) if food == 'nori': mousePos(Cord.phone) time.sleep(.1) leftClick() mousePos(Cord.menu_toppings) time.sleep(.05) leftClick() s = screenGrab() print 'test' time.sleep(.1) if s.getpixel(Cord.t_nori) != (33, 30, 11): print 'nori is available' mousePos(Cord.t_nori) time.sleep(.1) leftClick() mousePos(Cord.delivery_norm) time.sleep(.1) leftClick() time.sleep(2.5) else: print 'nori is NOT available' mousePos(Cord.t_exit) leftClick() time.sleep(1) buyFood(food) if food == 'roe': mousePos(Cord.phone) time.sleep(.1) leftClick() mousePos(Cord.menu_toppings) time.sleep(.05) leftClick() s = screenGrab() time.sleep(.1) if s.getpixel(Cord.t_roe) != (127, 61, 0): print 'roe is available' mousePos(Cord.t_roe) time.sleep(.1) leftClick() mousePos(Cord.delivery_norm) time.sleep(.1) leftClick() time.sleep(2.5) else: print 'roe is NOT available' mousePos(Cord.t_exit) leftClick() time.sleep(1) buyFood(food) Aqui nós passar um nome de ingrediente para a buyFood()função. Uma série de instruções if/ else é usado para capturar o parâmetro transmitido e responder adequadamente. Cada garfo segue a mesma lógica exata, por isso vamos explorar o primeiro. if food == 'rice': mousePos(Cord.phone) time.sleep(.1) leftClick() mousePos(Cord.menu_rice) time.sleep(.05) leftClick() s = screenGrab() time.sleep(.1) A primeira coisa que fazemos após o if food é clicar sobre o telefone e abra o item de menu apropriado - neste caso o menu Rice. s = screenGrab() if s.getpixel(Cord.buy_rice) != (127, 127, 127): Em seguida vamos dar uma visão rápida da área da tela e chamar getpixel()para obter um valor RGB para o pixel nas coordenadas de Cord.buy_rice. Em seguida, testamos este contra nosso valor RGB previamente estabelecido para quando o item é acinzentado. Se for avaliado como True, sabemos que o item não é mais acinzentado, e não temos dinheiro suficiente para comprá-lo. Consequentemente, se avaliada para False, não podemos permitir isso. print 'rice is available' mousePos(Cord.buy_rice) time.sleep(.1) leftClick() mousePos(Cord.delivery_norm) time.sleep(.1) leftClick() time.sleep(2.5) Fornecendo que podemos pagar o ingrediente, nós simplesmente navegar através das caixas restantes necessários para comprar a comida. else: print 'rice is NOT available' mousePos(Cord.t_exit) leftClick() time.sleep(1) buyFood(food) Finalmente, se não podemos pagar a comida, nós dizemos Python para fechar o menu, espere um segundo, e tente o processo novamente. Geralmente é apenas uma questão de segundos entre ser capaz de pagar algo contra não ser capaz de pagar algo. Nós não vai fazê-lo neste tutorial, mas é bastante simples para adicionar lógica adicional para esta função para permitir que o bot decidir se ele precisa continuar esperando até que ele pode pagar alguma coisa, ou se é livre para fazer outras tarefas e retornar à um momento posterior. Passo 19: Manter o controle de Ingredientes Tudo bem, agora vamos devagar, aos poucos, começar a substituir áreas onde nós, a entidade externa, fornecem entrada e tomada de decisão com a lógica que pode ser executado por si só. Precisamos dispositivo de uma forma de manter o controle de quantas ingredientes que temos atualmente na mão. Nós poderíamos fazer isso através de ping na tela em determinadas áreas, ou pela média de cada caixa de ingrediente (nós vamos chegar a esta técnica mais tarde), mas, de longe, o método mais simples e mais rápido é apenas para armazenar todas as nos itens mão em um dicionário. A quantidade de cada ingrediente se mantém constante ao longo de cada nível. Você sempre começará com 10 dos itens 'comuns' (arroz, nori, o ROE), e 5 dos itens 'premium' (camarão, salmão, unagi). Vamos adicionar esta informação a um dicionário. foodOnHand = {'shrimp':5, 'rice':10, 'nori':10, 'roe':10, 'salmon':5, 'unagi':5} Nossas chaves de dicionário segure o nome do ingrediente, e nós vamos ser capazes de obter quantidade atual, explorando os valores. Passo 20: adicionar monitoramento de Código Agora que temos nosso dicionário de valores. Vamos trabalhar com isso no código. Cada vez que fazemos algo, vamos subtrair os ingredientes utilizados. Toda vez que nós compramos, nós vamos adicioná-los novamente. Vamos começar pela expansão da makeFood()função def makeFood(food): if food == 'caliroll': print 'Making a caliroll' foodOnHand['rice'] -= 1 foodOnHand['nori'] -= 1 foodOnHand['roe'] -= 1 mousePos(Cord.f_rice) leftClick() time.sleep(.05) mousePos(Cord.f_nori) leftClick() time.sleep(.05) mousePos(Cord.f_roe) leftClick() time.sleep(.1) foldMat() time.sleep(1.5) elif food == 'onigiri': print 'Making a onigiri' foodOnHand['rice'] -= 2 foodOnHand['nori'] -= 1 mousePos(Cord.f_rice) leftClick() time.sleep(.05) mousePos(Cord.f_rice) leftClick() time.sleep(.05) mousePos(Cord.f_nori) leftClick() time.sleep(.1) foldMat() time.sleep(.05) time.sleep(1.5) elif food == 'gunkan': print 'Making a gunkan' foodOnHand['rice'] -= 1 foodOnHand['nori'] -= 1 foodOnHand['roe'] -= 2 mousePos(Cord.f_rice) leftClick() time.sleep(.05) mousePos(Cord.f_nori) leftClick() time.sleep(.05) mousePos(Cord.f_roe) leftClick() time.sleep(.05) mousePos(Cord.f_roe) leftClick() time.sleep(.1) foldMat() time.sleep(1.5) Agora, cada vez que fazemos um pedaço de Sushi, reduzimos os valores em nosso foodOnHanddicionário pelo valor apropriado. Em seguida, vamos ajustar buyFood () para adicionar valores. def buyFood(food): if food == 'rice': mousePos(Cord.phone) time.sleep(.1) leftClick() mousePos(Cord.menu_rice) time.sleep(.05) leftClick() s = screenGrab() print 'test' time.sleep(.1) if s.getpixel(Cord.buy_rice) != (127, 127, 127): print 'rice is available' mousePos(Cord.buy_rice) time.sleep(.1) leftClick() mousePos(Cord.delivery_norm) foodOnHand['rice'] += 10 time.sleep(.1) leftClick() time.sleep(2.5) else: print 'rice is NOT available' mousePos(Cord.t_exit) leftClick() time.sleep(1) buyFood(food) if food == 'nori': mousePos(Cord.phone) time.sleep(.1) leftClick() mousePos(Cord.menu_toppings) time.sleep(.05) leftClick() s = screenGrab() print 'test' time.sleep(.1) if s.getpixel(Cord.t_nori) != (33, 30, 11): print 'nori is available' mousePos(Cord.t_nori) time.sleep(.1) leftClick() mousePos(Cord.delivery_norm) foodOnHand['nori'] += 10 time.sleep(.1) leftClick() time.sleep(2.5) else: print 'nori is NOT available' mousePos(Cord.t_exit) leftClick() time.sleep(1) buyFood(food) if food == 'roe': mousePos(Cord.phone) time.sleep(.1) leftClick() mousePos(Cord.menu_toppings) time.sleep(.05) leftClick() s = screenGrab() time.sleep(.1) if s.getpixel(Cord.t_roe) != (127, 61, 0): print 'roe is available' mousePos(Cord.t_roe) time.sleep(.1) leftClick() mousePos(Cord.delivery_norm) foodOnHand['roe'] += 10 time.sleep(.1) leftClick() time.sleep(2.5) else: print 'roe is NOT available' mousePos(Cord.t_exit) leftClick() time.sleep(1) buyFood(food) Agora, cada vez que um ingrediente é comprado, nós adicionamos a quantidade ao valor dicionário apropriado. Passo 21: Verificação comida na mão Agora que temos o nosso makeFood()e buyFood()funções criadas para modificar o foodOnHanddicionário, é preciso criar uma nova função para monitorar todas as alterações e verificar se um ingrediente caiu abaixo de um certo limite. def checkFood(): for i, j in foodOnHand.items(): if i == 'nori' or i == 'rice' or i == 'roe': if j <= 4: print '%s is low and needs to be replenished' % i buyFood(i) Aqui montamos um forloop para percorrer os pares de chave e valor do nosso foodOnHanddicionário. Para cada valor, ele verifica se o nome é igual a um dos ingredientes que precisamos; se assim for, em seguida, verifica para ver se o seu valor for menor ou igual a 3; e, finalmente, desde que seja inferior a 3, ele chama buyFood()com o tipo de ingrediente como o parâmetro. Vamos testar isso um pouco. Tudo parece estar funcionando razoavelmente bem, então vamos passar para algumas tarefas mais reconhecimento de imagem. Passo 22: Valores Atravessando RGB - Configuração Para ir mais longe com a nossa bot, precisamos reunir informações sobre que tipo de sushi é em que o cliente bolha. Fazer isso com o getpixel()método seria muito trabalhoso porque você precisa encontrar uma área em cada balão de pensamento que tem um valor RGB único, não compartilhada por qualquer outra bolha sushi tipo / pensamento. Dada a arte do estilo do pixel, o que por sua própria natureza tem uma paleta de cores limitada, você teria que lutar toneladas de sobreposição de cores nos tipos de sushi. Além disso, para cada novo tipo de sushi introduzido ao longo do jogo, você teria que inspecioná-lo manualmente para ver se ele tem um RGB único não encontrado em qualquer um dos outros tipos de sushi. Uma vez encontrado, certamente seria em um coordenadas diferentes do que os outros para que significa armazenar cada vez mais os valores das coordenadas - 8 tipos de sushi por vezes bolha 6 locais de assento significa 48 únicas coordenadas necessário! Assim, em resumo, precisamos de um método melhor. Digite o método dois: resumo Imagem / média. Esta versão funciona fora de uma lista de valores RGB em vez de um pixel específico. Para cada instantâneo que tomar, a imagem é grayscaled, carregado em uma matriz, e então somados. Esta soma é tratado da mesma como o valor RGB no getpixel()método. Vamos usá-lo para testar e comparar várias imagens. A flexibilidade deste método é tal que uma vez que ele está configurado, no caso do nosso sushi bot, não mais trabalho é necessário em nossa parte. À medida que novos tipos de sushi são introduzidos os seus valores RGB únicas são somados e impresso na tela para nosso uso. Não há nenhuma necessidade de perseguir quaisquer coordenadas mais específicos como com getpixel(). Dito isto, ainda há um pouco de configuração necessária para esta técnica. Nós vamos precisar para criar algumas novas caixas delimitadoras para que processar apenas a área da tela que precisamos, em vez de toda a área de jogo. Vamos começar. Navegue até a sua screenGrab()função e fazer uma segunda cópia do mesmo. Renomeie a cópia para grab()e fazer as seguintes alterações: def screenGrab(): box = (x_pad + 1,y_pad+1,x_pad+640,y_pad+480) im = ImageGrab.grab(box) ##im.save(os.getcwd() + '\\Snap__' + str(int(time.time())) + '.png', 'PNG') return im def grab(): box = (x_pad + 1,y_pad+1,x_pad+640,y_pad+480) im = ImageOps.grayscale(ImageGrab.grab(box)) a = array(im.getcolors()) a = a.sum() print a return a Linha 2: Nós estamos fazendo uma screengrab assim como temos antes, mas agora estamos convertendo-o em tons de cinza antes de atribuí-lo à instância im. A conversão para tons de cinza faz percorrendo todos os valores de cor muito mais rápido; em vez de cada pixel com um valor vermelho, verde e azul, ele só tem um valor que varia de 0-255. Linha 3: Nós criamos uma matriz de valores de cores da imagem, utilizando o método PIL getcolors()e atribuí-los à variávela Linha 4: Nós somar todos os valores da matriz e imprimi-los para a tela. Estes são os números que usaremos quando comparamos duas imagens. Passo 23: Ajuste New Bounding Boxes Comece um novo jogo e esperar que todos os clientes para encher. Dê um duplo clique em quickGrab.pypara tirar um instantâneo da área de jogo. Vamos precisar para definir caixas delimitadoras dentro de cada uma dessas bolhas. Zoom até que você pode ver os detalhes finos dos pixels Para cada bolha, precisamos ter certeza de canto superior esquerdo da nossa caixa delimitadora começa no mesmo local. Para isso, contam-se duas 'bordas' da esquerda interior da bolha. Queremos que o pixel branco na segunda 'borda' para marcar a nossa primeira x, y local. Para obter o par mais baixo, adicione 63 para a posição x, e 16 para o y. Isto lhe dará uma caixa semelhante à abaixo: Não se preocupe que não estamos recebendo toda a imagem do tipo Sushi. Desde que nós estamos somando todos os valores, mesmo uma pequena mudança em um pixel mudará total e deixe-nos saber algo novo está na tela. Nós vamos criar seis novas funções, cada uma versão especializada do nosso general grab()um, e preencher os seus argumentos delimitadoras com as coordenadas de todas as bolhas. Uma vez que aqueles são feitas, vamos fazer uma função simples para chamar tudo de uma vez, apenas para fins de teste. def get_seat_one(): box = (45,427,45+63,427+16) im = ImageOps.grayscale(ImageGrab.grab(box)) a = array(im.getcolors()) a = a.sum() print a im.save(os.getcwd() + '\\seat_one__' + str(int(time.time())) + '.png', 'PNG') return a def get_seat_two(): box = (146,427,146+63,427+16) im = ImageOps.grayscale(ImageGrab.grab(box)) a = array(im.getcolors()) a = a.sum() print a im.save(os.getcwd() + '\\seat_two__' + str(int(time.time())) + '.png', 'PNG') return a def get_seat_three(): box = (247,427,247+63,427+16) im = ImageOps.grayscale(ImageGrab.grab(box)) a = array(im.getcolors()) a = a.sum() print a im.save(os.getcwd() + '\\seat_three__' + str(int(time.time())) + '.png', 'PNG') return a def get_seat_four(): box = (348,427,348+63,427+16) im = ImageOps.grayscale(ImageGrab.grab(box)) a = array(im.getcolors()) a = a.sum() print a im.save(os.getcwd() + '\\seat_four__' + str(int(time.time())) + '.png', 'PNG') return a def get_seat_five(): box = (449,427,449+63,427+16) im = ImageOps.grayscale(ImageGrab.grab(box)) a = array(im.getcolors()) a = a.sum() print a im.save(os.getcwd() + '\\seat_five__' + str(int(time.time())) + '.png', 'PNG') return a def get_seat_six(): box = (550,427,550+63,427+16) im = ImageOps.grayscale(ImageGrab.grab(box)) a = array(im.getcolors()) a = a.sum() print a im.save(os.getcwd() + '\\seat_six__' + str(int(time.time())) + '.png', 'PNG') return a def get_all_seats(): get_seat_one() get_seat_two() get_seat_three() get_seat_four() get_seat_five() get_seat_six() OK!Lotes de código, mas é tudo apenas versões especializadas de funções previamente definidas. Cada define uma caixa delimitadora, e passa para ImageGrab.Grab. A partir daí, converter para uma matriz de valores RGB e imprimir a soma para a tela. Vá em frente e executar isso algumas vezes durante o jogo. Certifique-se de verificar que cada tipo de sushi, independentemente de qual bolha que se encontra, mostra a mesma soma de cada vez. Passo 24: Crie um dicionário Tipos sushi Depois de verificar que cada um dos tipos de sushi é sempre exibir o mesmo valor, gravar suas somas em um dicionário da seguinte forma: sushiTypes = {2670:'onigiri', 3143:'caliroll', 2677:'gunkan',} Ter os números como a chave e as cadeias como os valores irá tornar mais fácil para baralhar as coisas de função para função sem perder o controle de tudo. Etapa 25: Criar uma classe nenhuma bolha A etapa final da nossa reunião bolha está recebendo as somas para quando não há bolhas presentes. Vamos usá-los para verificar quando os clientes vêm e vão. Comece um novo jogo e executar rapidamente get_all_seats()antes que alguém tem a chance de aparecer. Os números ele imprime vamos colocar em uma classe chamada Blank. Como antes, você poderia usar um dicionário, se preferir. class Blank: seat_1 = 8119 seat_2 = 5986 seat_3 = 11598 seat_4 = 10532 seat_5 = 6782 seat_6 = 9041 Estamos quase lá agora! Um passo final e teremos um bot simples, trabalhando! Passo 26: Juntando tudo Tempo para entregar finalmente fora de controle para o nosso bot. Nós vamos script na lógica básica que irá deixá-lo responder aos clientes, tornar as suas ordens, e reabastecer seus ingredientes quando o começam a escassear. O fluxo básico vai seguir esta: Verifique assentos> se o cliente, fazer a ordem> verificar food> se baixa, comprar comida> tabelas claras> repeat . Esta é longa; vamos começar. def check_bubs(): checkFood() s1 = get_seat_one() if s1 != Blank.seat_1: if sushiTypes.has_key(s1): print 'table 1 is occupied and needs %s' % sushiTypes[s1] makeFood(sushiTypes[s1]) else: print 'sushi not found!\n sushiType = %i' % s1 else: print 'Table 1 unoccupied' clear_tables() checkFood() s2 = get_seat_two() if s2 != Blank.seat_2: if sushiTypes.has_key(s2): print 'table 2 is occupied and needs %s' % sushiTypes[s2] makeFood(sushiTypes[s2]) else: print 'sushi not found!\n sushiType = %i' % s2 else: print 'Table 2 unoccupied' checkFood() s3 = get_seat_three() if s3 != Blank.seat_3: if sushiTypes.has_key(s3): print 'table 3 is occupied and needs %s' % sushiTypes[s3] makeFood(sushiTypes[s3]) else: print 'sushi not found!\n sushiType = %i' % s3 else: print 'Table 3 unoccupied' checkFood() s4 = get_seat_four() if s4 != Blank.seat_4: if sushiTypes.has_key(s4): print 'table 4 is occupied and needs %s' % sushiTypes[s4] makeFood(sushiTypes[s4]) else: print 'sushi not found!\n sushiType = %i' % s4 else: print 'Table 4 unoccupied' clear_tables() checkFood() s5 = get_seat_five() if s5 != Bla nk.seat_5: if sushiTypes.has_key(s5): print 'table 5 is occupied and needs %s' % sushiTypes[s5] makeFood(sushiTypes[s5]) else: print 'sushi not found!\n sushiType = %i' % s5 else: print 'Table 5 unoccupied' checkFood() s6 = get_seat_six() if s6 != Blank.seat_6: if sushiTypes.has_key(s6): print 'table 1 is occupied and needs %s' % sushiTypes[s6] makeFood(sushiTypes[s6]) else: print 'sushi not found!\n sushiType = %i' % s6 else: print 'Table 6 unoccupied' clear_tables() A primeira coisa que fazemos é verificar comida na mão. A partir daí, tirar um instantâneo de posição um e atribuir a soma de s1. Depois disso, verificar para ver que s1não é igual Blank.seat_1. Se não , nós temos um cliente. Nós verificamos o nosso sushiTypesdicionário para ver que tem uma soma igual ao nosso s1. Se isso acontecer, nós então chamar makeFood()e passar o sushiTypecomo um argumento. Clear_tables() é chamada a cada dois assentos. Apenas uma última peça restante: a configuração do loop. Passo 27: loop principal Nós vamos criar um loop while muito simples de jogar o jogo. Nós não fazer qualquer tipo de mecanismo de ruptura, de modo a parar a execução, clique no shell e pressione Ctr l + C para enviar uma interrupção de teclado. def main(): startGame() while True: check_bubs() E é isso! Atualizar a página, carregar o jogo, e definir o seu bot perder. Então, é um pouco desajeitado e na necessidade de refinamento, mas permanece como um esqueleto decente para que você possa interagir em cima. Uma versão mais completa do bot pode ser encontrada aqui . Ele tem várias correções de como se manter a par do que está sendo feito, não ficar preso nos menus de telefone e outras otimizações gerais. Conclusão Agora você tem todas as ferramentas que você precisa para ir sobre a construção de seus próprios bots simples. As técnicas utilizadas neste tutorial são bastante primitiva no mundo da Computer Vision, mas ainda assim, com persistência o suficiente, você pode criar muitas coisas legais com eles - mesmo fora do reino da bots jogo. Nós, por exemplo, executar vários scripts baseados nestas técnicas para automatizar tarefas repetitivas de software ao redor do escritório. É muito gratificante para remover uma tarefa humana com apenas algumas linhas de código. [spoiler=Créditos e link do artigo original] https://code.tutsplus.com/tutorials/how-to-build-a-python-bot-that-can-play-web-games--active-11117
  12. Olá tudo bem? espero que sim, pessoal estou a procura de pessoas capacitadas em Delphi, Python, css e html. por tanto se alguém conhecer ou for capacitado em algumas ou todas essas áreas por favor, entre em contato pois tenho uma proposta que pode ou não agradar muito, obrigado.
  13. Olá, alguém poderia me ajudar com essas questões abaixo? Não estou conseguido fechar meu raciocinio. 12. Faça um programa que peça ao usuário números positivos e imprima a soma dos valores. Quando o usuário quiser parar de informar números, deve passar o valor -1. 14. Faça um programa que calcule e mostre a média aritmética de N notas. O usuário informa quantas notas serão digitadas (N) e depois as N notas que ele deseja.
  14. Eu realmente gosto de atrair usuários para meus posts com títulos de tópicos apelativos. Você terá milhões de seguidores nesse post, mas de uma forma diferente :p Seguindo o exemplo do tutorial anterior, vamos criar o método/função de adicionar seguidores. Isso é bem tranquilo e fácil de fazer. Mas antes disso, precisamos de algumas ferramentas para nos ajudar. Vamos criar um método chamado get_user. Veja o exemplo: def get_user(user_id): for u in users_mock: if user_id == u['id']: return u return False Bom, recebemos o id do usuário que queremos todas informações e fazemos um for na lista de usuários (users_mock). Se o id que procuramos bater com o id de algum usuário da lista, retorna o objeto do usuário, se não, retorna falso. No caso, se retornar falso, vamos exibir uma mensagem de usuário não encontrado. Bora testar? Adicione esse método na parte de metodos do código do post anterior e no final, depois do print de adicionar postagem, adicione o código abaixo: print(get_user(2)) #ID da Maria Resultado {'name': 'Maria', 'id': 2, 'birthday': '08/01/1995', 'followers': [], 'following': [], 'is_admin': False, 'email': '[email protected]'} Beleza. Então vamos agora para o método de seguir um usuário, vamos chamar de follow_user. Veja o código abaixo: def follow_user(user_following, user_to_follow): user_to_follow['followers'].append(user_following['id']) user_following['following'].append(user_to_follow['id']) Simplesmente adicionar o id do seguidor no followers do que vai ser seguido e adicionar no following do que esta seguindo, o id do que será seguido. Agora vamos testar esse código, passando no parâmetro do follow_user o usuário que vai seguir primeiro e depois o usuário que será seguido. Aproveitando já o método novo get_user. # Fazendo Cr4cko seguir Maria. follow_user(get_user(1), get_user(2)) print(get_user(1)) print(get_user(2)) Resultado {'name': 'Cr4cko', 'id': 1, 'birthday': '08/01/1996', 'followers': [], 'following': [2], 'is_admin': True, 'email': '[email protected]'} {'name': 'Maria', 'id': 2, 'birthday': '08/01/1995', 'followers': [1], 'following': [], 'is_admin': False, 'email': '[email protected]'} Veja que dentro das informações do Cr4cko, temos o following com o id 2 e nas informações da Maria o followers com o id 1. "Cr4cko, porque você tem uma lista de ID's dentro de followers e following e não o usuário inteiro?" Oras, temos o método get_user! Pra que uma lista inteira de users dentro já de um user? Vamos deixar só os ids, e quando precisarmos das informações dos seguidores, usamos o get_user para obter. 1 MILHÃO DE SEGUIDORES. Agora o "Gran Finale". Vamos fazer o Cr4cko ter 1 milhão de seguidores. Prepara esse PC ai que vai ter que aguentar a carga. Brincadeira... :rolleyes: Antes de mais nada, precisamos doq? 1.000.000 de usuários. Criamos um método chamado shit_users onde criaremos 1 milhão de usuários e adicionaremos na lista de usuários. Vamos adicionar uma lista de 70 nomes e sobrenomes brasileiros que retirei desse link aqui (Nomes Chiques), os usuários com diferentes nomes. Veja o código abaixo: brazillian_names = [ u"Alves", u"Monteiro", u"Novaes", u"Mendes", u"Barros", u"Freitas", u"Barbosa", u"Pinto", u"Moura", u"Cavalcanti", u"Dias", u"Castro", u"Campos", u"Cardoso", u"Silva", u"Souza", u"Costa", u"Santos", u"Oliveira", u"Pereira", u"Rodrigues", u"Almeida", u"Nascimento", u"Lima", u"Araújo", u"Fernandes", u"Carvalho", u"Gomes", u"Martins", u"Rocha", u"Ribeiro", u"Rezende", u"Sales", u"Peixoto", u"Fogaça", u"Porto", u"Ribeiro", u"Duarte", u"Moraes", u"Ramos", u"Pereira", u"Ferreira", u"Silveira", u"Moreira", u"Teixeira", u"Caldeira", u"Vieira", u"Nogueira", u"da Costa", u"da Rocha", u"da Cruz", u"da Cunha", u"da Mata", u"da Rosa", u"da Mota", u"da Paz", u"da Luz", u"da Conceição", u"das Neves", u"Fernandes", u"Gonçalves", u"Rodrigues", u"Martins", u"Lopes", u"Gomes", u"Mendes", u"Nunes", u"Carvalho", u"Melo", u"Cardoso,", u"Pires", u"Jesus", u"Aragão", u"Viana", u"Farias", ] def remove_accents(s): return ''.join(c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn') def shit_users(): for x in range(1, 1000001): if x in users_mock: break first_name = remove_accents(brazillian_names[randint(0, 70)]) last_name = remove_accents(brazillian_names[randint(0, 70)]) birthday = datetime.date(year=randint(1990, 2000),day=randint(1, 25),month=randint(1, 12)) users_mock.append({ "id": x, "name": "%s %s" % (first_name, last_name), "email": ( "%s.%[email protected]" % ( first_name.lower(), last_name.lower() ) ).replace(" ", ""), "birthday": birthday.strftime('%d/%m/%Y'), "followers": [], "following": [], "is_admin": False, }) Nosso for começa na posicao 4 pois já temos 3 usuários na lista de usuários. Quando comecei a fazer o tutorial eu ia criar 1 bilhão de usuários, porém vai demorar muito para exibir os usuários, é muito dado sendo processado. Olha que estou rodando num macbook pro, e para exibir a lista demorou mais de 2 minutos. Enfim, chame a função de criar usuários e vamos printar a lista para ver como está: # C4gando usuários shit_users() print(users_mock) Vai demorar alguns segundos para aparecer o print, e quando aparecer você vai ver vários e vários e vários usuários diferentes aparecendo na sua tela durante alguns segundos. Principalmente quem tem um PC mais lento. Segue abaixo o print de alguns que apareceram num trecho da tela do meu terminal. Um rápido resumo do código: Criei um método para tirar os acentos dos nomes brasileiros. Fiz isso pois aproveitei o nome para criar o email, não seria necessário num caso real. Busco um nome e sobrenome randômico da lista, gero uma data de nascimento fake e do um append na listas de usuários. Veja que o dia do nascimento fiz do 1 ao 25, pois tem todas aquelas regrinhas de diferentes quantidades de dia num mês e no outro, então fiz um rand de uma data que tem em todos pra facilitar. BELEZA! Criamos 1 milhão de usuários. Agora você já sabe o passo a seguir: #FollowMe! Cuidado ao fazer o teste com 1 milhão, pois demora bastante o processo. Para ver como seria, faz testes com 1000 usuários e se você realmente quiser depois ver com os próprios olhos 1 milhão de seguidores é so alterar o for do shit_users. Veja o código abaixo: cr4cko = get_user(1) for user in users_mock: if user['id'] != cr4cko['id']: follow_user(get_user(user['id']), get_user(1)) cr4cko = get_user(1) print( len(cr4cko['followers']) ) Resultado Pronto, 1 milhão de seguidores. O resultado do print do tamanho da lista de followers do Cr4cko sempre será 1 numero a menos da realidade, pois a lista começa com a posição 0 e não 1. Mas se voce printar a lista sem o len(), você verá 1.000.000 de IDs nos followers do Cr4cko. Para quem quiser o código completo, incluindo as coisas do tópico passado: # -*- coding: utf-8 -*- from random import randint import datetime import unicodedata """ Mocks """ users_mock = [ { "id": 1, "name": "Cr4cko", "email": "[email protected]", "birthday": "08/01/1996", "followers": [], "following": [], "is_admin": True, }, { "id": 2, "name": "Maria", "email": "[email protected]", "birthday": "08/01/1995", "followers": [], "following": [], "is_admin": False, }, { "id": 3, "name": "Joaozinho", "email": "[email protected]", "birthday": "08/01/1997", "followers": [], "following": [], "is_admin": False, } ] list_posts_mock = [] brazillian_names = [ u"Alves", u"Monteiro", u"Novaes", u"Mendes", u"Barros", u"Freitas", u"Barbosa", u"Pinto", u"Moura", u"Cavalcanti", u"Dias", u"Castro", u"Campos", u"Cardoso", u"Silva", u"Souza", u"Costa", u"Santos", u"Oliveira", u"Pereira", u"Rodrigues", u"Almeida", u"Nascimento", u"Lima", u"Araújo", u"Fernandes", u"Carvalho", u"Gomes", u"Martins", u"Rocha", u"Ribeiro", u"Rezende", u"Sales", u"Peixoto", u"Fogaça", u"Porto", u"Ribeiro", u"Duarte", u"Moraes", u"Ramos", u"Pereira", u"Ferreira", u"Silveira", u"Moreira", u"Teixeira", u"Caldeira", u"Vieira", u"Nogueira", u"da Costa", u"da Rocha", u"da Cruz", u"da Cunha", u"da Mata", u"da Rosa", u"da Mota", u"da Paz", u"da Luz", u"da Conceição", u"das Neves", u"Fernandes", u"Gonçalves", u"Rodrigues", u"Martins", u"Lopes", u"Gomes", u"Mendes", u"Nunes", u"Carvalho", u"Melo", u"Cardoso,", u"Pires", u"Jesus", u"Aragão", u"Viana", u"Farias", ] """ Métodos """ def send_post(user, message): list_posts_mock.append({ "user": user, "message": message, }) def get_user(user_id): for u in users_mock: if user_id == u['id']: return u return False def follow_user(user_following, user_to_follow): user_to_follow['followers'].append(user_following['id']) user_following['following'].append(user_to_follow['id']) def remove_accents(s): return ''.join(c for c in unicodedata.normalize('NFD', s) if unicodedata.category(c) != 'Mn') def shit_users(): for x in range(4, 1000001): if x in users_mock: break first_name = remove_accents(brazillian_names[randint(0, 70)]) last_name = remove_accents(brazillian_names[randint(0, 70)]) birthday = datetime.date(year=randint(1990, 2000),day=randint(1, 25),month=randint(1, 12)) users_mock.append({ "id": x, "name": "%s %s" % (first_name, last_name), "email": ( "%s.%[email protected]" % ( first_name.lower(), last_name.lower() ) ).replace(" ", ""), "birthday": birthday.strftime('%d/%m/%Y'), "followers": [], "following": [], "is_admin": False, }) """ Testes """ user = users_mock[0] # Escolhi o primeiro usuario (Cr4cko) message = "Olá humanos!" #Mensagem # Chamando a funcao de postagem send_post(user, message) # Printando as postagens de nossa rede social de Mock for post in list_posts_mock: print("%[email protected]%s: %s" % ( "(Admin)" if post['user']['is_admin'] else "", post['user']['name'], post['message'] )) # Obter usuário pelo ID print(get_user(2)) # ID da Maria # Fazendo Cr4cko seguir Maria. follow_user(get_user(1), get_user(2)) print(get_user(1)) print(get_user(2)) # C4gando usuários shit_users() print(users_mock) cr4cko = get_user(1) for user in users_mock: if user['id'] != cr4cko['id']: follow_user(get_user(user['id']), get_user(1)) cr4cko = get_user(1) print( len(cr4cko['followers']) ) É isso. Abraços e bons estudos :)
  15. DESENVOLVENDO EM PYTHON- NINJA IDE É um ambiente de desenvolvimento integrado multi-plataforma (IDE).NINJA-IDE é executado no Linux / X11, Mac OS X e sistemas operacionais de desktop Windows, e permite aos desenvolvedores criar aplicações para diversas finalidades, utilizando todas as ferramentas e utilitários de NINJA-IDE, tornando a tarefa de escrever software mais fácil e agradável. Editor de código poderosa NINJA-IDE fornece um editor de código completo, com realce para várias línguas, conclusão de código, assistente de código para: importações, navegação, etc. Também é possível estender a funcionalidade editor utilizando plugins. Locator Código incrível Este recurso permite o acesso rápido e direto para qualquer arquivo, função ou classe dentro de um dos nossos projetos, simplesmente pressionando algumas teclas.Pressionando “Ctrl + K” vamos ver um pop-up ao longo de um campo de texto, onde você pode digitar o nome do que você quer e feito! Erros e PEP8 Localizador Realce erros estáticos e PEP8 no documento, você também pode ver que os arquivos que contêm erros PEP8 são mostrados com um ícone na guia onde o arquivo é aberto, e os arquivos que contêm erros estáticos código são mostrados com um ícone de bug nesse guia. projeto Managment NINJA-IDE permite gerir Python projeto automaticamente, economizando informações descritivas sobre eles e permitir que o usuário para executar arquivo managment tarefa relacionada no próprio IDE. Executar projeto e arquivos Com NINJA-IDE é possível executar o Project Python ou qualquer arquivo aberto no Editor com apenas um clique. Também é possível tornar um arquivo HTML carregado no Editor do IDE para ver como as mudanças ficaria em um navegador. Altamente extensível Você pode criar um plug-in para diversas finalidades e pode ser integrado completamente com o IDE, aumentando a funcionalidade disponível para melhorar a assistência para o desenvolvimento de projetos. Site Oficial para Download E Plugins [Hidden Content]
  16. Olá, meu nome é Kaique, tenho 16 anos, signo peixes, sou novato em programação mais conheço bem as linguagens Python, Java, C, gosto de surf, curto rap, andar de bicicleta e claro computadores. Vim dos fóruns Power-Pixel e iMasters, e vou migrar para este por que é bem completo e pelos usuários frequentes. Eu ainda não olhei todas áreas do fórum mas espero que tenha de animes e hardwares. Eu desenvolvo servidores Browser e Desktop, Espero fazer grandes amizades e participar de grandes projetos. A parte de cheats não me interessa, enfim, obrigado por ler meu tópico e pela sua atenção!.
  17. Olá, é meu primeiro post aqui. Venho deixar este gerador de hash em python utilizando a lib tkinter. Open Source. Para a galera que está começando, ele é bem simples, fiz quando iniciei em python. Obs: Não cometa este erro se estiver iniciando, comente seus scripts! Esse meu script me lembra quando comecei a programar, e startei com delphi. >>print ("Hashes possiveis") >>phash = [ md5, sha1, sha224, sha256, sha384 ] >>print ("Vamos a source?") >>exit() ##################################### # Contact: [email protected] # # # # Uso : tk-crypter hash text # # Exemplo : tk-crypter md5 abc123 # ##################################### from Tkinter import * import hashlib import sys ##################################### form = Tk() form.title("tk-crypter by Awak3ned") ##################################### MD5 = 'md5' SHA1 = 'sha1' SHA224 = 'sha224' SHA256 = 'sha256' SHA384 = 'sha384' SHA512 = 'sha512' HSEsl = 'HASH' HSEs2 = '' ##################################### def gerar_senha(): print ("Gerando sua Hash!") print ("Modelo:",sp1.get()) HSEsl = sp1.get() if (HSEsl == '0'): HSEs2 = MD5 print "TIPO DA HASH:",HSEs2 if (HSEsl == '1'): HSEs2 = SHA1 print "TIPO DA HASH:",HSEs2 if (HSEsl == '2'): HSEs2 = SHA224 print "TIPO DA HASH:",HSEs2 if (HSEsl == '3'): HSEs2 = SHA256 print "TIPO DA HASH:",HSEs2 if (HSEsl == '4'): HSEs2 = SHA384 print "TIPO DA HASH:",HSEs2 if (HSEsl == '5'): HSEs2 = SHA512 print "TIPO DA HASH:",HSEs2 la1["text"] = 'Escolha o tipo de hash :', HSEs2 hash_name = HSEs2 data = en1.get() print data h = hashlib.new(hash_name) h.update(data) print h.hexdigest() la3["text"] = 'HASH :',h.hexdigest() print("Iniciando o script...") ##################################### def start_form(): print ("Atualizando o script....") print ("Modelo:",sp1.get()) HSEsl = sp1.get() if (HSEsl == '0'): HSEs2 = MD5 if (HSEsl == '1'): HSEs2 = SHA1 if (HSEsl == '2'): HSEs2 = SHA224 if (HSEsl == '3'): HSEs2 = SHA256 if (HSEsl == '4'): HSEs2 = SHA384 if (HSEsl == '5'): HSEs2 = SHA512 la1["text"] = 'Escolha o tipo de hash :', HSEs2 hash_name = HSEs2 ##################################### lbf1 = LabelFrame(form, text="Multi Ecodificador de strings :") lbf1.pack(fill="both", expand="yes") ##################################### lbf2 = LabelFrame(lbf1, text="Definir :") lbf2.pack(fill="both", expand="yes") ##################################### la1 = Label(lbf2, text="{Escolha o tipo de hash :}") la1.grid(row="01", column="01") sp1 = Spinbox(lbf2, from_=0, to=5, command=start_form, width="5") sp1.grid(row="01", column="02") ##################################### la2 = Label(lbf2, text="Digite o que deseja :") la2.grid(row="02", column="01") en1 = Entry(lbf2, width="32") en1.grid(row="02", column="02") ##################################### bt1 = Button(lbf2, text="Encoder string !", command=gerar_senha, width="10") bt1.grid(row="04", column="01") ##################################### la3 = Label(lbf1, text="HASH :") la3.pack() ##################################### start_form() ##################################### form.resizable(width="FALSE", height="FALSE") form.geometry("500x150+200+200") form.mainloop()
  18. Capítulo 2 Introdução No final do capítulo anterior digitamos o seguinte programa diretamente no interpretador Python: >>> d = 1.686 >>> for p in range(50,150): print p, p * d O resultado desta seqüência de comandos é uma longa lista de números em duas colunas. Sabemos que a primeira coluna da esquerda contém preços em dólar e a outra, em reais. Mas nada na listagem indica isto. Observe esse trecho: 95 160.17 96 161.856 97 163.542 98 165.228 99 166.914 100 168.6 101 170.286 102 171.972 103 173.658 104 175.344 105 177.03 Aqui podemos observar outras deficiências: as colunas não estão corretamente alinhadas, e os valores em reais aparecem com uma, duas ou três casas decimais. Como se trata de uma tabela de preços, os valores em ambas colunas deveriam ter sempre duas casas decimais. Vamos fazer algumas melhorias em nosso programa gerador de tabelas de preços. Quatro tipos de dados Para evitar aquele degrau na segunda coluna entre o 99 e o 100, precisamos fazer um pequeno desvio para começar a aprender a lidar com textos, além de números. Digite eu =seguido do seu nome entre aspas: >>> eu = 'Fulano' Você tem que digitar as aspas para evitar um erro. As aspas podem ser 'simples' ou "duplas". Python guardará uma cópia do seu nome na memória do computador, e associará o identificador eu a esse dado. Agora basta digitar eu para ver o seu nome. >>> eu 'Fulano' >>> Antes havíamos criado a variável d referindo-se à cotação do dólar, e no capítulo anterior também criamos uma variável chamada lista, contendo uma lista de valores. Agora criamos a variável eu para se referir ao seu nome. Estes são exemplos de três tipos de dados que Python é capaz de processar: número de ponto flutuante, lista de valores, e texto. Você pode saber o tipo de uma variável ou estrutura de dados usando a função type. Veja estes exemplos: >>> eu = 'Luciano' >>> d = 1.902 >>> type(eu) <type 'str'> >>> type(d) <type 'float'> >>> Python acaba de nos dizer que a variável eu refere-se a um objeto do tipo 'str', uma abreviatura de "string" (basicamente o computador encara um texto como uma cadeia de caracteres). E a variável d aponta para um objeto do tipo 'float', ou "número de ponto-flutuante", como já vimos antes. Vejamos mais alguns tipos de dados: >>> type(1) <type 'int'> >>> type(1.) <type 'float'> >>> type([1,2,3]) <type 'list'> >>> Observe que o número 1 não é 'float', mas 'int'. Já o número 1. ("um" seguido de um ponto decimal) é considerado um 'float'. Como já dissemos no primeiro capítulo, inteiros e floatstêm tratamento diferente em Python. Uma divisão de inteiros (como 7/2), sempre fornece um resultado inteiro (3, nesse exemplo). O próximo dado testado é uma lista, [1,2,3], que Python chama de 'list'. Agora, experimente fazer esses dois testes: >>> type(range) <type 'builtin_function_or_method'> >>> type(range(3)) <type 'list'> >>> Ao perguntarmos qual é o tipo associado ao nome range, Python responde: 'builtin_function_or_method'. Também já vimos isso no capítulo anterior: o nome range refere-se a uma função embutida no próprio interpretador. No teste seguinte, fornecemos um argumento para a função range, e assim produzimos um resultado (neste caso, a lista [0,1,2], que foi criada na memória do seu computador, mas não foi exibida). É sobre este resultado que a função type foi aplicada, retornando a informação de que se trata de um dado do tipo 'list'. Ou seja, range é uma expressão do tipo builtin_function_or_method, mas range(3) é uma expressão do tipo 'list'. Faz sentido? Se não faz, escreva reclamando! Cada tipo de dados suporta operações diferentes. Faça algumas experiências e analise os resultados: >>> n1 = 10 >>> n2 = 20 >>> n1 + n2 30 >>> n1 = 'abacate' >>> n2 = 'banana' >>> n1 + n2 'abacatebanana' >>> n2 + n1 'bananaabacate' >>> Por exemplo, o operador + realiza uma soma quando aplicado a dados numéricos, mas quando aplicado a dados do tipo string, o sinal + faz uma operação de concatenação (junção de duas seqüências). Agora experimente isto: >>> x = 3. >>> x * 5 15.0 >>> 'x' * 5 'xxxxx' >>> Note que x e 'x' são coisas totalmente diferentes. x é o nome de uma variável que neste momento se refere ao valor 3. (um float). O resultado de x * 5 é 15.0 (outro float, como era de se esperar). Já 'x' é uma string com um caractere. Quando o sinal * é aplicado entre uma string e um número inteiro, Python realiza uma operação de repetição. Como você pode notar, os operadores + e * fazem coisas diferentes dependendo dos tipos de dados fornecidos na expressão. É um prazer trabalhar com Python porque se trata de uma linguagem muito coerente. Observe: >>> [1,2] + [3,4] [1, 2, 3, 4] >>> '12' * 3 '121212' >>> [1,2] * 3 [1, 2, 1, 2, 1, 2] >>> No primeiro exemplo, vemos o operador + concatenando duas listas. Os outros dois exemplos mostram a operação de repetição. Note que '12' não é um número, mas uma stringcomposta pelos caracteres '1' e '2'. Para Python, strings e listas têm muito em comum: ambas são seqüências de itens. Enquanto strings são seqüências de caracteres, listas são seqüências de itens quaisquer. Nos dois casos, concatenação e repetição funcionam de forma logicamente idêntica. Enfeitando a tabela Agora que sabemos sobre alguns tipos de dados, e que os operadores funcionam de forma diferente conforme os dados da expressão, estamos prontos para aperfeiçoar nosso gerador de tabelas usando o poderoso operador '%', que em Python não tem nada a ver com porcentagens. Para ver como ele funciona, vamos criar uma string como esta: >>> msg = 'um dólar vale %f real.' >>> Agora vamos ver o que acontece quando chamamos a variável msg: >>> msg 'um d\363lar vale %f real.' >>> Python representa varíaveis string dessa forma: entre aspas simples, e trocando os acentos por códigos especiais (estamos falando do código ASCII em notação octal, algo que explicaremos depois). Se você quiser exibir o conteúdo de msg de forma mais apresentável, use o comando print: >>> print msg um dólar vale %f real. >>> OK, é hora de explicar porque colocamos esse estranho %f dentro da mensagem. Trata-se de um marcador de posição para sinalizar onde Python deverá inserir um número quando quisermos imprimir a mensagem com o valor da cotação. Experimente digitar o seguinte: >>> d = 1.902 >>> print msg % d um dólar vale 1.902000 real. >>> Veja o que aconteceu: Python substituiu a marca %f pelo valor da variável d. É assim que funciona: a partir de uma string com marcas de posição e um ou mais valores, o operador %produz uma nova string com os valores inseridos nas respectivas posições. Veja agora um exemplo com dois valores: >>> msg2 = 'Um dólar vale %f real e um real vale %f dólar.' >>> print msg2 % (d, 1/d) Um dólar vale 1.902000 real e um real vale 0.525762 dólar. >>> Note que os valores d e 1/d estão entre parênteses. Isso é obrigatório quando queremos passar mais de um valor para o operador % (uma sequência de valores entre parênteses é um "tuplo", um tipo especial de lista que explicaremos em um outro capítulo). O símbolo %f serve para informar a Python que o valor a ser inserido naquela posição é um float. Se você quiser limitar o número de casas após o ponto decimal, basta usar um formato como esse: >>> d = 1.685 >>> '%.2f' % d '1.69' >>> Após o marcador %, a indicação .2 determina que devem aparecer duas casas decimais após o ponto. Note que o resultado é arredondado: 1.685 virou 1.69. Vamos usar esse recurso na nossa tabela: >>> for p in range(4,16): print 'US$ %.2f = R$ %.2f' % (p,p*d) US$ 4.00 = R$ 6.74 US$ 5.00 = R$ 8.43 US$ 6.00 = R$ 10.12 US$ 7.00 = R$ 11.80 US$ 8.00 = R$ 13.49 US$ 9.00 = R$ 15.17 US$ 10.00 = R$ 16.86 US$ 11.00 = R$ 18.55 US$ 12.00 = R$ 20.23 US$ 13.00 = R$ 21.92 US$ 14.00 = R$ 23.60 US$ 15.00 = R$ 25.29 >>> Está quase linda. Falta só consertar o degrau que acontece entre a linha do 9 e do 10. No marcador de posição você também pode colocar um número à esquerda do ponto para definir a largura total do espaço que será reservado. Na faixa de preços de 4 a 15, os maiores valores tem cinco caracteres de comprimento (incluindo o ponto decimal), por isso vamos usar '%5.2f'. Agora podemos fazer uma versão bem melhor da tabela: >>> for p in range(4,16): print 'US$ %5.2f = R$ %5.2f' % (p,p*d) US$ 4.00 = R$ 6.74 US$ 5.00 = R$ 8.43 US$ 6.00 = R$ 10.12 US$ 7.00 = R$ 11.80 US$ 8.00 = R$ 13.49 US$ 9.00 = R$ 15.17 US$ 10.00 = R$ 16.86 US$ 11.00 = R$ 18.55 US$ 12.00 = R$ 20.23 US$ 13.00 = R$ 21.92 US$ 14.00 = R$ 23.60 US$ 15.00 = R$ 25.29 >>> Entendendo melhor o for Como você percebeu, no comando for tudo aquilo que aparece após os sinal ":" é repetido várias vezes, uma vez para cada item da lista de valores indicada após a palavra in. Mas os comandos a serem repetidos podem ser vários, e na maioria das vezes não são escritos na mesma linha que o for, como temos feito, mas sim em linhas subseqüentes. O comando for é algo que chamamos de "estrutura de controle", que serve para determinar a forma de execução de um comando ou de uma seqüência de comandos, às vezes chamada de um "bloco". Em outras linguagens, os blocos são delimitados por marcadores especiais. Java, Perl e C++ usam os sinais { e } para este fim. Pascal e Delphi usam as palavras BEGIN e END. Além desses marcadores exigidos pelas linguagens, os programadores usam também o recurso da endentação, ou seja, o recuo em relação à margem esquerda, para tornar mais fácil a visualização da estrutura do programa. Veja este exemplo em Perl: Perl for ($i = 0; $i < 5; $i++) { $v = $i * 3; print "$v\n"; } Atenção: isto é Perl, e não Python. Aqui, os comandos $v = $i * 3; e print "$v\n"; formam o bloco que está sobre o controle do comando for, ou seja, os dois comandos serão executados repetidamente. O programa equivalente em Python é escrito assim: >>> for i in range(5): ... v = i * 3 ... print v Em nossa opinião, o código em Python é bem mais legível. Para sinalizar quais comandos fazem parte do bloco que está sob o controle do for, apenas a endentação é utilizada. Se você está usando o IDLE, esse recuo acontece automaticamente quando uma linha de comando termina com o sinal ':', que em Python sempre indica o início de um bloco. No interpretador Python invocado a partir da linha de comando no DOS ou em UNIX, a endentação não é automática. Você precisa digitar ao menos um espaço em branco para evitar uma mensagem de erro como essa: >>> for i in range(5): ... print i File "", line 2 print i ^ SyntaxError: invalid syntax Note que o interpretador está reclamando de sintaxe inválida, e apontando (^) para a primeira palavra do bloco que deveria estar recuado. Veja a mesma coisa, com a segunda linha recuada com a tecla [TAB]: >>> for i in range(5): ... print i ... 0 1 2 3 4 >>> Já deve ter ficado claro porque era preciso teclar [ENTER] duas vezes depois do for nos exemplos anteriores: é que, no modo interativo, o interpretador Python espera uma linha em branco para sinalizar o final de uma série de comandos que formam um bloco dentro de uma estrutura de controle. Agora que entendemos o conceito de bloco, podemos enfeitar ainda mais a nossa tabela colocando um segundo comando print dentro do nosso for: Veja este exemplo: >>> for p in range(9,13): ... print 'US$ %5.2f = R$ %5.2f' % (p, p * d) ... print '-' * 20 ... US$ 9.00 = R$ 15.17 -------------------- US$ 10.00 = R$ 16.85 -------------------- US$ 11.00 = R$ 18.54 -------------------- US$ 12.00 = R$ 20.22 -------------------- >>> A outra face do % Antes de encerrar este capítulo, vale a pena contar que, assim como o + e o *, o operador '%' também tem dupla personalidade. Quando aplicado sobre dois números, que podem ser inteiros ou floats, o '%' retorna o resto da divisão inteira do primeiro pelo segundo. Veja só: >>> 6 % 3 0 >>> 7 % 3 1 >>> 8 % 3 2 >>> 9 % 3 0 >>> Explicando: 6 / 3 dá 2, e o resto é 0; a divisão inteira de 7 / 3 também dá 2, mas o resto é 1. Esta operação é chamada de "modulo" em inglês. Sua principal utilidade é determinar se um número é múltiplo de outro. Nos exemplos acima, o resultado de 6 % 3 e 9 % 3 é zero, porque 6 e 9 são múltiplos de 3. No próximo capítulo vamos começar a elaborar programas mais extensos. O modo interativo, que temos usado até agora, vai continuar sendo útil para testarmos novas idéias e observar o comportamento de funções e módulos do Python rapidamente. Mas, a partir da próxima sessão, vamos começar a gravar nossos programas para uso posterior, em vez de digitá-los diretamente no interpretador. E vamos também descobrir como solicitar informações do usuário, de forma que os programas possam ser utilizados por pessoas que não sabem programar e preferem ficar longe de um interpretador interativo. Vou estar postando 1 Capitulo por dia para não ter problemas com flood.
  19. Capítulo 0 Porque aprender a programar? A razão fundamental, que nos motivou a produzir este tutorial, é uma só: programar é divertido. É claro que nem todo mundo vai concordar com isso, assim como muita gente não acha graça nenhuma em jogar xadrez ou explorar cavernas. Ao contrário do xadrez e da espeleologia, a programação também é uma habilidade que tem forte demanda no mercado de trabalho. Mas a dura realidade é que somente com centenas ou milhares de horas de experiência programando é que você estará apto a incluir essa disciplina em seu currículo e se dar bem em uma entrevista de emprego. Portanto nosso objetivo aqui é bem mais modesto do que transformar você em um programador profissional. O que estamos te oferecendo é uma introdução suave a esse tópico fascinante. Ao final, esperamos que você descubra se tem a vocação e a motivação necessárias para criar softwares, como hobby ou profissão. Antes de começar, apenas um aviso: o prazer de construir um programa pode causar dependência psicológica. Não é apenas por dinheiro que programadores do mundo inteiro varam noites escrevendo código. Material necessário Para acompanhar esse tutorial você precisará de um computador qualquer onde tenha instalado um interpretador da linguagem Python. Em quase todas as versões modernas de Linux e Mac OS X o interpretador Python já vem instalado (experimente abrir um console e digitar "python"). Na página http://www.python.org/download/ você encontra links para baixar o interpretador adequado para o seu computador. No caso do Windows, o instalador .msi da versão atual do Python tem cerca de 11 MB. Capítulo 1 Abrindo e fechando o interpretador A melhor forma de aprender a programar é usando um interpretador em modo interativo. Dessa forma você pode digitar comandos linha por linha e observar a cada passo como o computador interpreta e executa esses comandos. Para fazer isso em Python, há duas maneiras: 1-executar o interpretador em modo texto (chamado "Python (command line)" no Windows, ou simplesmente python no Linux) 2-usar o IDLE, que é um ambiente baseado em janelas. Se você usa Windows, escolha o IDLE para começar a acompanhar esse tutorial. O IDLE também está disponível para a plataforma Linux (algumas distribuições colocam o IDLE em um pacote separado do pacote do Python). Seja qual for o interpretador que você escolheu, ao executá-lo você verá uma mensagem com informações de copyright mais ou menos como essa: Python 2.5.1 (r251:54863, Oct 5 2007, 13:50:07) [GCC 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2)] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> O símbolo ">>>" exibido pelo interpretador é o que os americanos chamam de "prompt", que alguns traduzem por "aviso", mas nós vamos chamar de "deixa" (em teatro, o termo "prompt" é a deixa que indica ao ator a hora de dizer ou fazer algo; em computação, o prompt informa o usuário que o sistema está pronto para receber um novo comando). Para sair do interpretador você pode fechar a janela do IDLE, ou teclar [CTRL]+[D] (no IDLE ou no interpretador em UNIX) ou [CTRL]+[Z] e então [ENTER] (no interpretador DOS). Uma calculadora melhor Vamos então aproveitar a deixa e escrever algo. Experimente escrever uma expressão aritmética bem simples, como 2+2: >>> 2+2 4 >>> A resposta é reconfortante: para Python, 2+2 é igual a 4. Você pode experimentar outras expressões mais complexas, mas é bom saber que os quatro operadores básicos em Python (e em quase todas as linguagens modernas) são esses: + adição - subtração * multiplicação / divisão Em Python, assim como na linguagem C, os números inteiros têm um tratamento especial. Isso fica evidente quando fazemos uma divisão: >>> 7/2 3 >>> Em vez de 3,5, o resultado foi 3. Isso acontece sempre que todos os números de uma expressão são inteiros. Neste caso, Python imagina que se deseja um resultado inteiro também (esse comportamento estranho às vezes é conveniente em programação). Se você quiser operar com números decimais, deve usar o ponto e não a vírgula como separador decimal: >>> 7.0/2 3.5 >>> 7/2.0 3.5 >>> 7/2. 3.5 >>> Note que basta digitar um ponto após o número. O computador não consegue lidar com números do conjunto dos reais, mas apenas com uma aproximação chamada "número de ponto-flutuante" (porque o ponto decimal pode aperecer em qualquer posição do número). Ao lidar com ponto-flutuante, às vezes vemos resultados estranhos: >>> 2.4 * 2 4.7999999999999998 >>> O resultado não deveria ser 4.8? Deveria, mas antes de ficar revoltado note que a diferença foi muito pequena. Acontece que o sistema de "ponto-flutuante" padrão IEEE-754 usado em quase todos os computadores atuais tem uma precisão limitada, e Python não esconde este fato de você, programador. O problema não está na conta, mas na própria representação interna do valor 2.4: >>> 2.4 2.3999999999999999 Para exibir valores de ponto-flutuante para um usuário sem assustá-lo, use o comando print: >>> print 2.4 * 2 4.8 >>> Você pode digitar espaços entre os números e operadores para fazer uma expressão longa ficar mais legível. Veja esse exemplo: >>> 1 + 2 * 3 7 >>> Note que o interpretador Python é mais esperto que uma calculadora comum. Ele sabe que a multiplicação deve ser efetuada antes da adição. Se você teclar a mesma expressão em uma calculadora qualquer obterá o resultado 9, que é incorreto. Em Python, se você realmente deseja efetuar a soma antes da multiplicação, precisa usar parênteses: >>> (1 + 2) * 3 9 >>> Ao contrário do que você aprendeu na escola, aqui os símbolos [] e {} não servem para agrupar expressões dentro de outras expressões. Apenas parênteses são usados: >>> ( 9 - ( 1 + 2 ) ) / 3.0 2.0 >>> ( 9 - 1 + 2 ) / 3.0 3.33333333333 >>> DICA: Se você escrever algo que o interpretador não reconhece, verá na tela uma mensagem de erro. Não crie o mau hábito de ignorar essas mensagens, mesmo que elas pareçam difíceis de entender num primeiro momento. A única vantagem de cometer erros é aprender com eles, e se a preguiça o impedir de ler as mensagens, seu aprendizado será bem mais lento. Veja aqui como decifrar as mensagens de erro do Python. Como ler uma mensagem de erro A dura realidade é que um programador profissional passa boa parte de sua vida caçando erros, e por isso é fundamental saber extrair o máximo de informações das mensagens resultantes. A essa altura você talvez já tenha provocado um erro para ver o que acontece. Vamos fazer isso agora, e aprender a ler as mensagens resultantes. Pode parecer perda de tempo, mas é importantíssimo saber interpretar as mensagens de erro porque a melhor forma de aprender a programar é experimentando, e ao experimentar você certamente vai provocar muitos erros. Como exemplo, vamos digitar uma expressão aritmética sem sentido: >>> 7 + / 2 File "<stdin>", line 1 7 + / 2 ^ SyntaxError: invalid syntax >>> O interpretador indica o local de erro em vermelho no IDLE, ou com o sinal ^ no console. Nos dois casos a última linha contém as informações mais importantes: SyntaxError: invalid syntax. A primeira parte, SyntaxError é o tipo do erro, e após o sinal de ":" vem a descrição: erro de sintaxe inválida. No console a primeira linha da mensagem de erro indica em a linha do seu código onde ocorreu o problema. No modo interativo essa informação pouco útil, mas quando fizermos programas extensos será muito bom saber exatamente em qual linha está a falha. Agora vamos provocar um outro tipo de erro: >>> 1.5/0 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: float division >>> Novamente, a parte mais importante é a última linha, que nesse caso é bem fácil de entender: ZeroDivisionError: float division, ou "erro de divisão por zero em divisão de ponto-flutuante". Conversor de dólares Digamos que você tem uma loja de discos importados, e precisa constantemente converter dólares em reais. O valor do dólar para venda em 20/05/1999 é de 1.686. Para converter US$9,95 e US$11,95 em reais você pode digitar: >>> 9.95 * 1.686 16.775699999999997 >>> 11.95 * 1.686 20.147699999999997 >>> Mas há uma forma melhor: em vez de digitar o valor 1.686 o tempo todo, você pode armazenar esse valor na memória do computador, assim: >>> d = 1.686 >>> Note que o interpretador não respondeu nada (a menos que você tenha cometido um erro), mas ele guardou o número em uma posição de sua memória, e associou o símbolo "d" a essa posição. Agora, fica mais confortável converter dólares em reais: >>> 9.85 * d 16.607099999999999 >>> 11.95 * d 20.147699999999997 >>> 5 * d, 7 * d, 9 * d (8.4299999999999997, 11.802, 15.173999999999999) >>> No último caso, convertemos de uma vez só os valores 5, 7 e 9 em dólares. Para um resultado mais apresentável, use o comando print: >>> print 5 * d, 7 * d, 9 * d 8.43 11.802 15.174 >>> E se a cotação do dólar mudou para 1.61? Basta armazenar o novo número e refazer os cálculos: >>> d = 1.61 >>> print 5 * d, 7 * d, 9 * d 8.05 11.27 14.49 >>> Você precisa digitar a linha mais longa de novo. No IDLE, clique sobre a linha que digitamos no exemplo anterior e tecle [ENTER]. A linha será reproduzida na última deixa, e bastará um novo [ENTER] para processá-la. No console, teclando a seta para cima você acessa o histórico de comandos. Tabela de preços em dólares e reais Agora vamos mostrar como o interpretador Python é muito mais poderoso que uma calculadora. Imagine que em sua loja de discos importados você tem um balcão de ofertas com discos de $4 até $9. Se quisesse fazer uma tabela de preços em reais você poderia digitar: >>> print 4*d, 5*d, 6*d, 7*d, 9*d 6.44 8.05 9.66 11.27 14.49 >>> Mas isso é um tanto chato e repetitivo. Em programação, sempre que você fizer algo repetitivo é porque não encontrou ainda a melhor solução. Lidar com séries de números é uma atividade comum, e Python pode ajudar muito nesses casos. Digite o seguinte: >>> lista = [5,6,7,8,9] >>> Aqui nós criamos uma lista de preços na memória do computador e associamos o nome "lista" a esses dados. Em seguida, digite o seguinte (você terá que teclar [ENTER] duas vezes ao final dessa linha; depois saberá porque). >>> for p in lista: print p * d 8.05 9.66 11.27 12.88 14.49 >>> Aqui nós instruímos o interpretador a fazer os seguintes passos: - para cada item sucessivo da lista: - associe o nome p ao item da vez - exiba o valor de p * d Agora digamos que você tem discos com valores de 4 a 15 dólares. Você poderia digitar a lista de novo, mas a coisa começa a ficar repetitiva novamente. Há uma forma melhor. A linguagem Python possui uma palavra chamada "range" que serve para gerar faixas de números. Vamos usar essa palavra. Digite: >>> range <built-in function range> >>> Quando você digita o nome de uma função sem fornecer dados, Python limita-se a dizer a que se refere o nome. Nesse caso: "built-in function range", ou função embutida range. Isso quer dizer que a palavra range é o nome de uma função, um tipo de comando que produz resultados a partir de dados fornecidos. E trata-se ainda de uma função embutida, ou seja, incluída no próprio interpretador (a maioria das funções da linguagem Python não são embutidas, mas fazem parte de módulos que o programador precisa chamar explicitamente; isso será explicado depois). Acabamos de dizer que uma função "produz resultados a partir de dados fornecidos", então vamos fornecer algum dado para ver que resultados a função range produz. Digite "range(5)" e veja o que acontece: >>> range(5) [0, 1, 2, 3, 4] >>> Quando apenas um dado N é fornecido, range gera uma lista de N números, de zero até N-1. É um comportamento um pouco estranho, mas útil em programação (o primeiro item de uma série, na maioria das linguagens, é o item número zero; isso será discutido mais profundamente quando aprendermos mais sobre listas). Agora digamos que eu queira uma sequência a partir de 2, e não zero. Digite: >>> range(2,5) [2, 3, 4] >>> Agora para obter a lista de valores de discos podemos digitar: >>> range(4,16) [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15] >>> E usando o comando for, calcular de uma só vez todos os valores convertidos: >>> for p in range(4,16): print p * d 6.44 8.05 9.66 11.27 12.88 14.49 16.1 17.71 19.32 20.93 22.54 24.15 >>> Mas o ideal mesmo era ter os valores em dólares e reais lado a lado. Isso é fácil: >>> for p in range(4,16): print p, p * d ... 4 6.44 5 8.05 6 9.66 7 11.27 8 12.88 9 14.49 10 16.1 11 17.71 12 19.32 13 20.93 14 22.54 15 24.15 >>> Resumindo o que foi feito até aqui, com apenas duas linhas de código em Python, você pode gerar tabelas de conversão de qualquer tamanho. Experimente: >>> d = 1.686 >>> for p in range(50,150): print p, p * d Parabéns, você acaba de construir seu primeiro programa! Porquê Python Toda programação de computadores é feita através de uma ou mais linguagens de programação, portanto não é possível aprender a programar sem aprender ao menos uma linguagem de programação. Nossa meta não é mostrar como se programa em uma linguagem específica, mas sim como se programa de uma forma geral. Ou seja, a linguagem para nós será um veículo, e não o destino. Mesmo assim, pensamos bastante antes de escolher uma linguagem para este tutorial, e optamos por Python. Centenas de linguagens já foram criadas desde que o computador eletrônico foi inventado nos anos 40. Algumas já são línguas mortas. Outras, como C++ e Java, são peças fundamentais no desenvolvimento da economia digital. No entanto, a complexidade dessas duas linguagens nos motivou a descartá-las, e focalizar o universo das chamadas linguagens de "scripting", que são mais simples e se prestam a um estilo de programação exploratória, mais sintonizado com um tutorial como esse. As três linguagens de scripting mais populares atualmente são !PHP, JavaScript e !VBScript. Todas são utilizadas na construção de web-sites dinâmicos, mas praticamente não têm aplicação fora desse domínio, e por isso foram descartadas. É que, embora seja nosso objetivo abordar também esse tópico, achamos que é complexo demais para começar, especialmente devido à dificuldade de se diagnosticar erros de programação em páginas dinâmicas. Escolhemos Python porque é uma linguagem muito versátil, usada não só no desenvolvimento Web mas em muitos outros tipos de aplicação. Python roda nos servidores de mega-sites como Google e YouTube, nos clusters de computação gráfica da Industrial Light & Magic, em laboratórios da NASA e da farmacêutica AstraZeneca, e em games como Civilization IV e EVE-Online. O nome "Python" é uma homenagem ao grupo humorístico inglês Monty Python, adorado por geeks de todo o mundo, mas pela pequena amostra de usuários citados, não é uma linguagem de brinquedo. Apesar de sua sintaxe simples e clara, Python oferece os seguintes recursos disponíveis também em linguagens mais complicadas como Java e C++: programação orientada a objetos (incluindo herança múltipla, conceito apenas parcialmente presente em Java) exceções, um moderno mecanismo para o tratamento de erros módulos, uma forma inteligente de acessar e organizar código a ser reutilizado coleta de lixo automática, sistema que elimina os erros causados pelo acúmulo de dados inúteis na memória do computador (característica presente também em Java, mas não em C++) recursos avançados de manipulação de textos, listas e outras estruturas de dados possibilidade de executar o mesmo programa sem modificações em várias plataformas de hardware e sistemas operacionais (difícil de se conseguir em C++) Em resumo, Python nos oferece uma sintaxe tão simples quanto PHP ou VBScript, mas é mais versátil do que elas. E permite explorar vários recursos de Java e C++ de uma forma mais acessível. Por esses motivos acreditamos que seja a melhor escolha para quem quer começar a programar hoje.
  20. Calma, calma. Você não vai competir com Mark Zuckerberg depois desse post. A ideia é montar através de Mock uma estrutura de rede social. Mock, para quem não sabe, são dados fakes que normalmente desenvolvedores usam para testar sua aplicação. Por exemplo, para não ficar consultando no banco de dados ou ter que criar a estrutura antes de consulta para testar uma aplicação, criamos o Mock, que seriam os dados fictícios. Veja um exemplo: users_mock = [ { "id": 1, "name": "Cr4cko", "email": "[email protected]", "birthday": "08/01/1996", "followers": [], "following": [], "is_admin": True, }, ] No caso acima, temos uma lista de usuarios, e 1 objeto dentro dela que é as informações de um usuário (Eu rs). A ideia aqui é apresentar uma estrutura de rede social utilizando mocks. Tendo isso como base, depois para criar um banco de dados e armazenar os dados de acordo com a estrutura do MOCK, fica mais facil. Claro que sempre rola modificações no meio do caminho, mas é bem menos do que criar tudo na imaginação. Bom, let's go bitches. Vamos aproveitar a base de exemplo do users e criar mais alguns usuários. users_mock = [ { "id": 1, "name": "Cr4cko", "email": "[email protected]", "birthday": "08/01/1996", "followers": [], "following": [], "is_admin": True, }, { "id": 2, "name": "Maria", "email": "[email protected]", "birthday": "08/01/1995", "followers": [], "following": [], "is_admin": False, }, { "id": 3, "name": "Joaozinho", "email": "[email protected]", "birthday": "08/01/1997", "followers": [], "following": [], "is_admin": False, } ] Beleza. Temos usuarios em nossa rede social. Qual é o proximo passo? Bom, ai é voce quem decide. Eu vou começar com os mocks de Postagens. Toda rede social tem seu sistema de postagem. A gente vê um layout diferente em cada uma mas o segredo por trás e a mesma bost4: um usuario envia uma mensagem para o mundo. Vou chamar esse mock de Postagem. Vamos criar uma lista VAZIA de postagens: list_posts_mock = [] Como não temos postagens nenhuma ainda, vamos criar o metodo para um usuario poder postar algo. Vou chama-lo de send_post. def send_post(user, message): list_posts.append({ "user": user, "message": message, }) Bom, vamos simular agora um usuário fazendo uma postagem e vamos printar para ver oq rola. Vou comentar no próprio código o que estarei fazendo. user = users_mock[0] # Escolhi o primeiro usuario (Cr4cko) message = "Olá humanos!" #Mensagem # Chamando a funcao de postagem send_post(user, message) # Printando as postagens de nossa rede social de Mock for post in list_posts_mock: print("%[email protected]%s: %s" % ( "(Admin)" if post['user']['is_admin'] else "", post['user']['name'], post['message'] )) Resultado Opa fechou. Ja temos uma postagem em nossa "rede social". Bom, esse post será apenas isso por enquanto. A ideia é a gnt construir primeiro no Python uma estrutura simples e funcional, e depois passar para o HTML e começar a dar uma cara pro negocio. Enquanto isso, vai treinando com esse exemplo, adicionando mais postagens, adicionado mais atributos aos usuários e tudo mais. Abaixo, o código por completo: # -*- coding: utf-8 -*- """ Mocks """ users_mock = [ { "id": 1, "name": "Cr4cko", "email": "[email protected]", "birthday": "08/01/1996", "followers": [], "following": [], "is_admin": True, }, { "id": 2, "name": "Maria", "email": "[email protected]", "birthday": "08/01/1995", "followers": [], "following": [], "is_admin": False, }, { "id": 3, "name": "Joaozinho", "email": "[email protected]", "birthday": "08/01/1997", "followers": [], "following": [], "is_admin": False, } ] list_posts_mock = [] """ Métodos """ def send_post(user, message): list_posts_mock.append({ "user": user, "message": message, }) """ Testes """ user = users_mock[0] # Escolhi o primeiro usuario (Cr4cko) message = "Olá humanos!" #Mensagem # Chamando a funcao de postagem send_post(user, message) # Printando as postagens de nossa rede social de Mock for post in list_posts_mock: print("%[email protected]%s: %s" % ( "(Admin)" if post['user']['is_admin'] else "", post['user']['name'], post['message'] )) Para rodar o código, vai até seu TERMINAL/CMD e digite: python nome_do_arquivo.py Qualquer dúvida, to aqui. Abs
  21. Uma foto do jogo feito com Python/Flask e HTML Bom, agora o bixo pega! Vamos criar uma parada mais avançada. Na aula anterior, criamos um joguinho bem besta. Agora vamos começar a brincar de verdade. Vamos construir algo mais fuck monster foda. Que tal um Joguinho de tiro? Fui pegando umas imagens da internet para ficar mais interessante o jogo, mas o ideal e voce construir algo original. Vamos trabalhar com Flask. Segue uma breve explicação do mesmo, se quiser informações a mais, pesquise e estude. E só digitar no google :) PRIMEIROS PASSOS 1 - Primeiramente, certifique-se de estar com python instalado em seu computador. 2 - Vamos instalar o Flask: Windows (Abrir CMD como administrador) pip install flask Linux/OSx sudo pip install flask 3 - Agora que voce instalou o Flask direitinho em seu computador, crie uma pasta para criarmos o jogo. Ela vai ter que ter a seguinte arquitetura de arquivos. No meu caso, eu tenho uma pasta chamada webcheats-python e dentro dela esta organizado todas essas pastas e arquivos. Nao crie o app.pyc, ele gera sozinho. Pode ignorar esse arquivo. 5 - Agora antes de criar um jogo, precisamos entender qual é a proposta do jogo e quais serão as regras. Como eu estou criando um jogo aqui, eu vou dar as regras. Mas o processo sera o mesmo nos proximos jogos que vocês forem criar. Veja abaixo: Um jogo de tiro onde um jogador (voce) vai trocar tiros com um Bot. O bot tera movimentos aleatorios. O jogador vai controlar seu boneco (bonequinho embaixo) com as teclas W,S,A,D e o ESPAÇO para atirar. O jogador e o bot terao um ESCUDO. Entao quando estiverem atras do escudo, estarao protegidos dos tiros. Para acertar o tiro, e preciso sair do escudo e o adversario estar fora do escudo tambem. Alem disso, e preciso os 2 estarem do mesmo lado, caso contrario o tiro não pega. 6 - Bom vamos então começar a criar a estrutura HTML. Jogue dentro do seu templates/game.html esse código abaixo. Não vou explicar o que cada div faz, ja existe alguns tutoriais aqui na Info Zone explicando sobre HTML CSS e Javascript. Vou apenas explicar o algoritmo que fiz. [HIDE-THANKS] <html> <head> <title>Tiro Seco</title> <link rel="stylesheet" type="text/css" href="{{url_for('static', filename='css/app.css')}}"> </head> <body> <!-- Arena do Jogo--> <div class="arena"> <div class="bot"> <div class="head"><img src="{{url_for('static', filename='img/enemy.png')}}"></div> <div class="shield" style="margin-top: 120px;"><img src="{{url_for('static', filename='img/shieldenemy.png')}}"></div> </div> <div class="player"> <div class="shield"><img src="{{url_for('static', filename='img/shield.png')}}"></div> <div class="head"><img src="{{url_for('static', filename='img/player.png')}}"></div> </div> </div> <!-- Placar--> <div class="placar"> <fieldset> <legend>Você</legend> <div>HP: <span id="player_hp"></span></div> <div>ACERTOS: <span id="player_score"></span></div> </fieldset> <fieldset> <legend>Bot</legend> <div>HP: <span id="bot_hp"></span></div> <div>ACERTOS: <span id="bot_score"></span></div> </fieldset> </div> <!-- jQuery e Regras do Jogo --> <script src="http://code.jquery.com/jquery-3.2.1.min.js" integrity="sha256-hwg4gsxgFZhOsEEamdOYGBf13FyQuiTwlAQgxVSNgt4=" crossorigin="anonymous"></script> <script>var SHOT_AUDIO = "{{url_for('static', filename='sounds/tiro.mp3')}}"</script> <script src="{{url_for('static', filename='js/game.rules.js')}}"></script> </body> </html> [/HIDE-THANKS] Beleza. Nada muito complexo no HTML acima. Criei uma estrutura simples de HTML (html, head, body) e dentro do body eu adicionei 2 divs: arena e placar. Arena tem o escudo e o personagem do Player e do Bot. No final eu importo o jQuery que vamos trabalhar no arquivo static/js/game.rules.js e um script gravando na variavel SHOT_AUDIO a rota do audio de TIRO que baixei. Isso porque essas variáveis são do FLASK ({{url_for('static', filename='js/game.rules.js')}}), e só vão funcionar no html. 7 - Agora vamos adicionar um CSS bonitinho. Eu fiz algo bem porco, nada demais. Podem editar a vontade. No fundo, eu adicionei uma imagem de Mapa que catei na internet, e o unico arquivo que nao fiz download e joguei o URL mesmo. Jogue o codigo abaixo dentro do seu arquivo static/css/app.css: [HIDE-THANKS] @import url('https://fonts.googleapis.com/css?family=Sedgwick+Ave'); body { font-family: 'Sedgwick Ave', cursive; background-image: url('https://i.ytimg.com/vi/c0a2_C3Fqo8/maxresdefault.jpg') } /* Arena & Placar*/ .arena { width: 500px; height: 580px; background-color: rgba(255, 255, 255, 0.26); color: white; border-radius: 25%; position: relative; margin: auto; box-shadow: 0px 0px 20px #000; } .placar { color: white; text-shadow: 0px 0px 3px #000; margin: auto; width: 530px; position: relative; height: 90px; background-color: #0000007a; } .placar fieldset { width: 230px; position: relative; float: left; } /*Bot*/ .bot { position: absolute; top: 0; text-align: center; width: 100%; } .bot .head { position: absolute; width: 100%; } /* Player*/ .player { position: absolute; bottom: 0; text-align: center; width: 100%; } .player .head img { transform: rotate(180deg); } .player .head img { position: relative; } .player .head img.left { left: 100px; } .player .head img.right { right: 100px; } /* Both */ .player .head img, .bot .head img { width: 125px; } .player .shield img, .bot .shield img { width: 100px; } [/HIDE-THANKS] FLASK_APP=app.py flask run 8 - Bom, agora vamos ao Javascript. Agora vou ser bem detalhado, vai ser um pouco chato mas tentarei resumir o máximo possível. Não é difícil entender o código. Se você possui alguma dificuldade com sintaxe ou algumas funções, e só dar uma pesquisada. Nenhum programador sabe tudo, a maior ferramenta de todos nos é o Google. Abaixo o codigo do Javascript bem comentado e explicado, jogue tudo dentro do seu arquivo static/js/game.rules.js: [HIDE-THANKS] /* @author Cr4cko @description Estas sao as regras e funcoes do jogo. */ /* Sempre deixo variaveis que precisamos instanciar no topo do codigo. Usaremos essa aqui mais no final. Essa variavel vai guardar o audio de TIRO. Sempre que voce ver um som_tiro.play() e o que vai fazer o barulho de TIRO quando apertar ESPAÇO ou quando o BOT atirar. */ var som_tiro = null; /* Aqui eu crio 2 variaveis PLAYER e BOT com os seus atributos. Estou dando uma vida de 100 para os 2, dano de tiro de 5 e zerando o score dos 2 a principio. A variavel is_protected e um boolean (verdadeiro ou falso). Ela vai me dizer se o jogador/bot esta PROTEGIDO no escudo ou nao. Ja a variavel position, diz se o jogador/bot esta na posicao inicial (protegido) ou esquerda(left) ou direita(right). */ PLAYER = { hp: 100, maxHp: 100, damage: 5, score: 0, is_protected: true, position: "initial" } BOT = { hp: 100, maxHp: 100, damage: 5, score: 0, is_protected: true, position: "initial" } /* PLAYER SETTINGS */ /* Essa e a funcao de tiro do jogador. Vejam que eu crio um timer (timerToShotAgain), para impedir que o jogador fique atirando milhoes de vezes por segundo, se nao fica facil demais haha. Aqui e bem simples: Se o bot estiver desprotegido, e eu (player) tambem estiver desprotegido e estivermos no mesmo LADO do mapa (eu no lado esquerdo e ele no lado direito dele), quer dizer que acertei o tiro. Essa funcao e chamada no evento da tecla ESPAÇO no teclado. Voce vera onde eu crio os eventos mais abaixo. */ function player_shot() { if (timerToShotAgain) return; //Se tiver ainda rolando o tempo, impedir de atirar novamente. som_tiro.play(); if (!BOT.is_protected && !PLAYER.is_protected && BOT.position == PLAYER.position) { life = BOT.hp - PLAYER.damage; //resultado da vida do bot - dano do tiro do player if (life > 0){ //se a vida for maior que zero... BOT.hp = life; //altera vida do bot PLAYER.score += 1; //da ponto pro PLAYER //printa os resultados no html $("#bot_hp").text(BOT.hp); $("#player_score").text(PLAYER.score); //Pinta o BOT de vermelho para identificar que foi atingido e depois pinta de transparente. $(".bot .head img").css({"background-color":"red"}); setTimeout(function(){$(".bot .head img").css({"background-color":"transparent"});}, 500) } else{ //Se a vida nao for maior que zero o bot MORREU. chama a funcao de resetar o jogo. resetGame(); } } timerToShotAgain = setTimeout(delayShotAgain, timerMS); } /* Como disse acima, o delay de tiro do player. Quando voce apertar espaco voce tera que esperar 500ms (timerMS) para poder atirar novamente mesmo que clique centenas de vezes no ESPACO. */ var timerToShotAgain; //o timer var timerMS = 500; //delay pra poder atirar novamente function delayShotAgain(){ clearTimeout(timerToShotAgain); timerToShotAgain = null; } /* Aqui e a funcao que protege o jogador. Quando ele nao estiver clicando pra esquerda(A) ou direita(D), ele estara protegido atras do ESCUDO. Ativo o is_protected pra true. E coloco a posicao dele como inicial (protegido). */ function player_shield(){ $(".player .head img").removeClass("left") $(".player .head img").removeClass("right") PLAYER.is_protected = true; PLAYER.position = "initial"; } /* Aqui e o evento que define a DIRECAO do jogador. Esquerda(A) ou direita(D). Lembrando que quando ele estiver fora do escudo, ele estara desprotegido. Definimos o atributo is_protected pra false. */ function player_direction(dir){ $(".player .head img").addClass(dir); PLAYER.is_protected = false; //Aqui vou inverter a ideia de esquerda e direita, pois o jogador esta //de frente para o bot. A esquerda do jogador e a direita do BOT, visse versa. PLAYER.position = dir == "right" ? "left":"right"; //Isso e um if ternario, pesquise depois. } /* EVENTOS*/ /* Esse e o evento de CLIQUE do jogador. Veja que eu estou gravando os eventos de todo o BODY do HTML. Se o jogador clicar no A (esquerda) e o keycode 100. Se clicar no D (direita) e o keycode 97. Se clicar no espaco, keycode 32. */ $( "body" ).keypress(function(evt) { if (evt.keyCode == 32) { player_shot(); } if (evt.keyCode == 100) { //esquerda player_direction("left"); } else if (evt.keyCode == 97){ //direita player_direction("right"); } }); /* Esse e o evento de TIRAR o dedo do clique. O keypress e quando voce aciona o botao O keyup e quando voce tira o dedo. Entao aqui serve apenas para verificar se voce TIROU o dedo do A (esquerda) ou D (direita) para voltar a posicao do player no ESCUDO (initial). */ $( "body" ).keyup(function(evt) { if (evt.keyCode == 65 || evt.keyCode == 68){ player_shield(); } }); /* FIM */ /* BOT SETTINGS */ /* Aqui e a mesma pegada do Player, porem para o BOT. Escudo do BOT. */ function bot_shield(){ $(".bot .head img").css({"float": "initial"}); BOT.is_protected = true; BOT.position = "initial"; } /* Mesma pegada do player. Porem nao precisa inverter as posicoes. */ function bot_direction(direction){ $(".bot .head img").css({"float": direction}) BOT.is_protected = false; BOT.position = direction; } /* Exatamente igual o Player mas nao precisa bloquear a quantidade de cliques, pois o MEU ROBO e honesto e vai jogar bem de boas com voce. :D */ function bot_shot(){ som_tiro.play(); if (!PLAYER.is_protected && !BOT.is_protected && BOT.position == PLAYER.position) { life = PLAYER.hp - BOT.damage; //resultado da vida do player - dano do tiro do bot. if (life > 0){ //se a vida for maior que zero PLAYER.hp = life; //alterar vida player BOT.score += 1; //add pontuacao bot //printar no html os resultados $("#player_hp").text(PLAYER.hp); $("#bot_score").text(BOT.score); //Pintar em vermelho o player dizendo que ele foi atingido, dpois pintar de transparente novamente. $(".player .head img").css({"background-color":"red"}); setTimeout(function(){$(".player .head img").css({"background-color":"transparent"});}, 500) } else{ //Se a vida nao for maior que zero o player MORREU. chama a funcao de resetar o jogo. resetGame(); } } } /* Aqui e a funcao do sleep que eu crio para usar na inteligencia do robo. Só copia :) */ function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } /* Aqui e a funcao que da vida ao BOT. Aqui vamos ter que criar toda a logica de acoes do mesmo. Vai ser interessante o BOT fazer movimentos aleatorios, para nao ficar manjado. */ async function startBot() { /* Aqui eu crio o primeiro movimento e segundo movimento. Ao executar o startBot, ele vai fazer uma acao, voltar para o escudo fazer outra acao e depois voltar pro escudo. Entao ele tera 2 movimentos para fazer aleatoriamente. */ var first_dir = Math.floor(Math.random() * 2) + 0; //numero entre 0 e 1 var second_dir = Math.floor(Math.random() * 2) + 0; //numero entre 0 e 1 //Aqui eu crio um tempo aleatorio entre 200ms e 500ms que o bot vai ficar escondido no ESCUDO. var time_protect = Math.floor(Math.random() * 500) + 200; //Se o movimento for 1, esquerda, se for 0, direita. first_dir = first_dir == 1 ? "left":"right"; second_dir = second_dir == 1 ? "left":"right"; /* - INTELIGENCIA DO BOT Agora vem a parte show. Vamos criar os movimentos e dizer os tempos de espera entre um e outro. */ //Iniciando com o robo escondido. await sleep(200); bot_shield(); //O bot espera 100ms vai para uma direcao e atira. await sleep(100); bot_direction(first_dir); await sleep(BOT_NIVEL == "facil" ? 200:100); //200ms nivel facil, 100ms nivel dificil bot_shot(); await sleep(BOT_NIVEL == "facil" ? 200:100); //200ms nivel facil, 100ms nivel dificil //Bot volta para escudo bot_shield(); await sleep(time_protect); //O bot espera 100ms vai para uma direcao e atira. await sleep(100); bot_direction(second_dir); await sleep(BOT_NIVEL == "facil" ? 200:100); //200ms nivel facil, 100ms nivel dificil bot_shot(); await sleep(BOT_NIVEL == "facil" ? 200:100); //200ms nivel facil, 100ms nivel dificil //Bot volta para escudo await sleep(200); bot_shield(); };/* FIM */ /* GAMEOVER: resetGame */ /* Aqui fica a funcao de reset. Se o bot te matar ou voce matar ele, essa funcao e chamada. Bem simples, vemos quem ta com a vida maior, e abre um alert dizendo quem ganhou. Em seguida, resetamos os scores para 0 e setamos a vida do bot e player para o maxHp que sempre sera a vida total. Depois jogamos os 2 para a posicao atras do escudo. */ function resetGame() { //Exibindo Ganhador if (PLAYER.hp > BOT.hp){ alert("Voce ganhou :D") } else { alert("Voce perdeu :(") } //Resetando Vida e Score $("#player_score").text(0); $("#bot_score").text(0); $("#player_hp").text(PLAYER.hp = PLAYER.maxHp); $("#bot_hp").text(BOT.hp = BOT.maxHp); //Voltando para protecao os 2 bot_shield(); player_shield(); } /* LOAD SETTINGS - Configuracao e Start do Jogo */ /* Aqui e onde configuramos as preferencias iniciais do jogo e demos start no bot. */ function loadSettings(){ //Aqui que definimos o nivel do jogo. Lembra ali em cima no delay de tiro do BOT? //Ou seja, se tiver facil, ele vai pra direcao e atira em 200ms. Se tiver no dificil, faz isso em 100ms. //Quanto menos ms, mais rapido, ou seja, mais dificil hehe :) BOT_NIVEL = "facil"; // facil, dificil //Aqui setamos a vida do player/bot e os scores. lembre-se que aqui ainda o jogo nao comecou. $("#player_hp").text(PLAYER.hp); $("#player_score").text(PLAYER.score); $("#bot_hp").text(BOT.hp); $("#bot_score").text(BOT.score); //Carregando som de tiro. Lembra da variavel la em cima? Enfim usaremos ela! som_tiro = document.createElement('audio'); som_tiro.setAttribute('src', SHOT_AUDIO); //aqui a variavel criada no HTML, arquivo do tiro.mp3 som_tiro.load(); /* Agora com a funcao de javascript setInterval, criamos um looping infinito que e executado a cada 2 segundos. Entao o startbot e chamado a cada 2 segundos. Em 2 segundos, vai acontecer todos aqueles eventos da funcao startBot que criamos. */ setInterval(function(){ startBot(); }, 2000); }; /* Quando tudo estiver carregado certinho, executamos o loadSettings para iniciar jogo. */ $(document).ready(function(){ loadSettings(); }) [/HIDE-THANKS] Eita.. bom galera a pior parte passou. Foi mais chato eu organizar todo meu codigo e comentar do que ler e entender isso kkkkkkkkk. Bom, nao fique triste se voce nao entender tudo o que ta rolando ate agora, o importante e voce entender os passos que estamos fazendo e entender um pouco a LOGICA que estou criando. Programar nao e dificil, dificil e saber identificar os mateirias e as decisoes que precisaremos tomar para alcancar certo objetivo. MAS ENFIM, vamos continuar. 9 - Agora com HTML, CSS e o Javascript prontos, esta faltando quem? FLASK! Agora e bem simples, dentro do seu app.py adicione esse codigo: [HIDE-THANKS] from flask import Flask, render_template app = Flask(__name__) @app.route('/') def index(): return render_template('game.html') [/HIDE-THANKS] Simples. Certo? Não precisa entender a fundo o que e esse pequeno trecho de codigo. Como estamos usando um framework (Flask), ele possui diversas complexidades e funcoes por tras. Isso e um framework, assumir todas as complexidades por tras e deixar bem facil do usuario entender. No codigo acima, chamamos a classe Flask, e criamos uma rota "/" retornando o template game.html que criamos. O metodo render_template observa a pasta templates. Entao nosso game.html precisa estar la. Se voce mudar o @app.route('/') para @app.route('/game') voce muda a rota do site. Ou seja, quando voce iniciar voce precisara acessar: http://seusite.com/game. 10 - Agora so falta as imagens e o som de tiro para estar 100% antes de iniciar o jogo. Eu vou deixar no final do post o link de download de todas as imagens e arquivos. Coloque eles nas pastas de acordo com a estrutura que mostro na imagem la no passo 3 e logo em seguida vamos iniciar o jogo com esse comando digitado no TERMINAL/CMD: FLASK_APP=app.py flask run Pronto! Servidor ligado, agora acesse no teu navegador: http://localhost:5000/ Teclados: A,D para esquerda/direita e ESPACO para atirar. DOWNLOAD
  22. Bom, duvida que so aprendendo o tutorial 2 conseguimos criar um Jogo? Jovem, jogo não eé só 3d, com bracos e animacoes. Antes de tudo isso, os jogos eram de tabuleiro, alguns jogos de texto e apenas de cliques. No nosso caso, vamos criar um jogo simples de pergunta e resposta. Primeiro de mais nada, vamos escrever as regras desse jogo. Se você não consegue escrever as regras e funcionalidades do jogo no papel, voce NUNCA vai escrever em python ou qualquer outra linguagem de programação. Lembrando que estou falando em criar, e não copiar. Então vamos lá. 1 - Vamos criar uma lista de dicionarios. 2 - Cada dicionario tera os seguintes atributos: titulo da pergunta, resposta certa, lista de respostas possiveis. 3 - Vamos criar um looping e ir perguntando e armazenando as respostas. 4 - Respostas certas o usuario ganha 1 ponto, resposta errada perde 1 ponto. 5 - Depois de todo looping, vamos exibir quantos pontos o usuario fez. Lembrando que explicações sobre loopings vou deixar no final do topico. Tudo que tiver #blablabla, e um comentário sobre o que estou fazendo. Isso não afeta no código. # -*- coding: utf-8 -*- #Iniciando os pontos do usuario SCORE = 0 # Lista de perguntas lista_de_perguntas = [ { "title": "Quem descobriu o Brasil?", # titulo "right_answer": "B", #resposta certa "answers": [ #mais uma lista de objetos com as possiveis respostas { "value": "A", #Letra A "description": "Cr4cko" #Descricao da letra A }, { "value": "B", "description": "Pedro Álvares Cabral" }, { "value": "C", "description": "Carlos Drummond de Andrade" } ] }, { "title": "A Webcheats é um...?", "right_answer": "C", "answers": [ { "value": "A", "description": "Disco Voador" }, { "value": "B", "description": "Blog" }, { "value": "C", "description": "Forum" } ] }, ] """ No looping vamos fazer a pergunta, aguardar o input do usuarios conferir se a resposta esta certa ou nao e anotar o score. """ print("# Joguinho de Perguntas #\n\n") #Primeiro looping para obter as perguntas for pergunta in lista_de_perguntas: print("Pergunta) %s \n\n" % pergunta['title']) #Segundo looping para obter as respostas for resposta in pergunta['answers']: print( "%s) %s\n" % (resposta['value'], resposta['description']) ) # para obter o que o usuario escreve, use o input. answer_selected = input("\nResposta: ") # Isso eé uma condição. Se a resposta selecionada e a certa, aumenta o ponto, se nao, subtrai. if answer_selected.lower() == pergunta['right_answer'].lower(): #.lower() para forcar tudo letra minuscula SCORE = SCORE + 1 # ou SCORE += 1 (resposta certa, aumentar pontos) else: SCORE = SCORE - 1 print("Perguntas finalizadas. Sua pontuação é: %s" % SCORE) Referencias e Dicas Loopings em Python - Link externo Estruturas Condicionais em Python - Link externo
  23. Vamos entender um pouco sobre as variaveis que mais vamos usar daqui para frente. Vou detalhar um pouco sobre cada exemplo. Lembrando que se quiser entender a fundo veja as referencias no fim do tópico. Crie um arquivo aula2.py e acesse essa pasta com seu Terminal/CMD para podermos executar o arquivo e rodar os códigos em Python. Para testar os exemplos, voce tera que digitar cada um dos blocos de código abaixo dentro do seu arquivo aula2.py e rodar no seu terminal com python aula2.py. Você verá os resultados nos prints em seu terminal. Variaveis Guardamos em variaveis qualquer tipo de valor. Pode ser uma string (texto), pode ser um int (numero inteiro), pode ser um boolean ( verdadeiro (True) ou falso(False) ) ou qualquer outro tipo de variavel. Em breve vamos ver algumas. Abaixo vou fazer um print sem variavel e depois um print mencionando uma variavel. A ordem dos %s importam, e a variavel tera que seguir essa ordem. Sempre ter'a que ter uma variavel quando voce digitar %s no print. Se voce nao fizer certo, vai dar um erro. Eu uso %s pois para printar precisa ser uma string, entao o %s forca a variavel virar uma string. # -*- coding: utf-8 -*- #VARIAVEIS name = "Guilherme" print("Vamos printar a variavel nome abaixo") print("Nome: %s" % name) Outras Variaveis Vou mostrar outros tipos variáveis para melhor entendimento. Perceba que quando eu vou printar mais de uma variavel, eu agrupo em uma tupla* (variavel1, variavel2, variavel3) # -*- coding: utf-8 -*- #VARIAVEIS name = "Guilherme" print("Vamos printar a variavel nome abaixo") print("Nome: %s" % name) #OUTRAS VARIAVEIS age = 21 # numero inteiro (minha idade) weight = 72.5 # numero decimal (meu peso) is_wc_member = True # boolean (é um membro webcheats?) print( "Este é %s, possui %s anos e pesa %s kg. Status como Membro: %s" % (name, age, weight, is_wc_member) ) Dicionario (ou objeto) Agora vamos falar dos dicionarios. Eles sao um grupo de chave e valor, sao melhores para organizar os atributos de certas coisas. Vamos no exemplo abaixo aproveitar os meus dados que coloquei acima e transformar em um objeto, para melhor organização já que estamos falando de uma mesma coisa. # -*- coding: utf-8 -*- #VARIAVEIS name = "Guilherme" print("Vamos printar a variavel nome abaixo") print("Nome: %s" % name) #OUTRAS VARIAVEIS age = 21 # numero inteiro (minha idade) weight = 72.5 # numero decimal (meu peso) is_wc_member = True # boolean (é um membro webcheats?) print( "Este é %s, possui %s anos e pesa %s kg. Status como Membro: %s" % (name, age, weight, is_wc_member) ) #DICIONARIO (ou objeto) usuario = { "name": "Guilherme", "age": 21, "weight": 72.5, "is_wc_member": True, } print("Vamos printar o dicionario inteiro primeiro: %s" % usuario) print("Agora apenas um atributo desse dicionario (nome): %s" % usuario['name']) Listas Listas é literalmente uma lista de coisas. Pode ser uma lista de numeros inteiros, uma lista de numeros decimais, ou lista de strings. Funciona da mesma forma para todos. Abaixo, eu primeiro mostro uma lista de numeros inteiros, depois eu adicionando um numero nessa lista. Depois crio uma lista ja com um objeto e adicionando o objeto que criamos anteriormente. # -*- coding: utf-8 -*- #VARIAVEIS name = "Guilherme" print("Vamos printar a variavel nome abaixo") print("Nome: %s" % name) #OUTRAS VARIAVEIS age = 21 # numero inteiro (minha idade) weight = 72.5 # numero decimal (meu peso) is_wc_member = True # boolean (é um membro webcheats?) print( "Este é %s, possui %s anos e pesa %s kg. Status como Membro: %s" % (name, age, weight, is_wc_member) ) #DICIONARIO (ou objeto) user = { "name": "Guilherme", "age": 21, "weight": 72.5, "is_wc_member": True, } print("Vamos printar o dicionario inteiro primeiro: %s" % user) print("Agora apenas um atributo desse dicionario (nome): %s" % user['name']) #LISTAS list_integers = [1, 2, 3] list_integers.append(4) print("Lista de inteiros: %s" % list_integers) list_users = [] list_users.append({ "name": "Joaozinho", "age": 19, "weight": 90.5, "is_wc_member": False, }) list_users.append(user) print("Printando a lista inteira com os 2 usuarios Guilherme e Joaozinho: %s" % list_users) print("Printando apenas o primeiro objeto da lista: %s" % list_users[0]) Conclusão O legal é você pegar isso que estão aprendendo aqui e trocarem valores, nomes de variáveis, dar append em mais objetos nas listas, e tudo mais. Existem outros comandos para todas essas variaveis, mas nao vou entrar muito afundo nisso. No final do topico eu deixo algumas referencias caso voces queiram saber os detalhes e como saber o tipo de cada variavel. Espero que esteja indo tudo bem, parece uma loucura para alguns no começo, mas com o tempo e pratica vamos dominando. Qualquer duvida, poste aqui! Referencias e Links para estudos Tupla - Link externo Variáveis - Link externo
  24. Boa tarde pessoal. Vou começar uma série de Tutoriais em python. Eu sou ansioso e impaciente. Esse tutorial vai para as pessoas que querem aprender coisas de forma rápida sem muito lero lero e Teoria. Porém para conseguir aprender seguindo meus tutoriais, você terá que mostrar para si mesmo que é capaz de aguentar o tranco. Vou começar do simples até o que eu considero hoje o essencial para um programador Python se encaixar em qualquer vaga no mercado de trabalho. Pelo menos é os que eu contrataria :) Antes de mais nada, você vai precisar do Python em sua maquina. Acredito que na sua maquina já tenha alguma versão de python rodando. Se não tiver eu explico um pouco abaixo como instalar para cada maquina. Vou deixar abaixo algumas palavras chaves que vou usar durante as aulas que você precisa ter sempre em mente para não ficar travando ou se atrapalhando. Lembrando também para ler isso com atenção, pois vou ignorar e reportar posts com dúvidas relacionadas a essa list aqui embaixo. LEIA COM ATENÇÃO Terminal/CMD: Quando eu falar Terminal, considere o seu CMD se estiver usando Windows. Terminal é para quem usa os sistemas operacionais OSx e Linux. É aquela telinha preta onde você digita os comandos. PIP: "...é um sistema de gerenciamento de pacotes usado para instalar e gerenciar pacotes de software escritos na linguagem de programação Python". Muitos pacotes podem ser encontrados no Python (Fonte). Vamos usar ele para instalar alguns pacotes que vão nos auxiliar no desenvolvimento. Amem o pip, vocês vão precisar dele e ele é o melhor amigo do programador Python. Erros & StackOverflow: Eu estou fazendo os tutoriais em um computador Windows, pois a grande parte dos iniciantes aqui provavelmente usam Windows. Porém eu desenvolvo em OSx. Então qualquer dúvida de lib que não instalou corretamente no seu pc por questão de funcionar em Windows e não em OSX/Linux, pergunte no meu MP e não aqui no tópico. Mas assim como qualquer desenvolvedor, aprenda a primeiro procurar no StackOverflow (Uma comunidade de duvidas para programadores). Joga no google o erro que está dando e provavelmente voce encontrara sua duvida perguntada por alguem nessa comunidade. Ame o Stackoverflow, ele também será seu amigo na tua vida de programador. Explicações Avançadas: Quando digo avançadas é que não vou ficar te contando a historinha de como o Python nasceu, sobre a cegonha e as primeiras palavras dessa linguagem. Eu vou te ensinar o essencial, com exemplos práticos, dar uma breve detalhada no que estou fazendo e ir avançando. Então se você está acostumado com escolinha do Professor Girafales, CORRE DAQUI. Aqui é paulera comigo. Vida de professor é foda, ainda mais aqui na WebCheats q não ganhamos nada kkkkk então aproveite :D Links, Fontes, Downloads: Provavelmente todos os links e downloads vou deixar no final do tópico. Se não deixei, mande mensagem pelo MP. Vamos tentar manter os tópicos o mais limpo possível. Peço que se for duvidas complexas ou que realmente estejam te travando e você não consiga encontrar uma solução, poste aqui que resolveremos juntos. Mas antes de uma pesquisada como falei, e tente resolver por si mesmo. Veja os comentários nesse tópico pois sua duvida pode já ter sido postada. Lembrando que eu posso atualizar essa lista no decorrer do desenvolvimento/tutoriais. APRESENTAÇÃO Podem me chamar de Cr4cko mesmo ou Guilherme Iazzetta, tenho 21 anos atualmente (2017), sou desenvolvedor Fullstack e arquiteto de Software. Crio e arquiteto projetos com Django (Python), Mean.io (MongoDB, Express, Angular, Node). Formado na FIAP como Analista e Desenvolvedor de Sistemas e atualmente iniciando MBA em Gestão de Tecnologia da Informação. E dedicando o resto das minhas horas e vida em estudos com Inteligencia Artificial :rolleyes:. DOWNLOAD DO PYTHON E PIP Vou deixar o download do Python e PIP para Windows/Linux/OSx. Vocês são bem grandinhos e ja sabem qual é o seu sistema operacional, certo? Obrigado. Estamos usando a versão 3.6.2 para esses tutoriais. Windows Ubuntu OSx (aqui é instalando o brew antes) VALIDANDO A INSTALAÇÃO DO PYTHON Para verificar as versões instaladas, você precisa digitar: --version na frente do python e pip. Se não aparecer a versão 3.6, digite python3 e pip3 em todos os tutoriais inclusive esse para ver versão, pois você está com 2 versões de python no PC. Para entender como remover ou usar uma de cada, leia: (LINUX/OSX) How to Python run Python3 python --version #Python 3.6.2 pip --version #pip 9.0.1 from c:\users\xxxxxx\appdata\local\programs\python\python36-32\lib\site-packages (python 3.6) CONCLUSÃO Bom, aqui provavelmente será o unico topico bem detalhadinho e de dúvidas sobre instalação e tudo mais. O resto, o que rodar no meu, se esforcem para rodar no de vocês. Dúvidas no MP e erros absurdos podem postar aqui. Logo abaixo, vou deixar a lista de tutoriais que eu for criando, pois eu QUERO que os novos usuários primeiro entenda como as aulas vão funcionar para ajudar a manter as aulas produtivas e limpas. Não sou ignorante nem FD*, fiquem tranquilos que faço oq amo e ajudar/ensinar faz parte disso. Só que como disse, sou ansioso e rápido, e gosto de ensinar dessa forma. Foi assim que aprendi. Desejo uma ótima aula para vocês, espero que gostem, e se tornem ótimos desenvolvedores (para quem quiser). É nois! Lista dos Tutoriais 2 - Entendendo as variaveis do Python 3 - Criando um jogo simples com Python 4 - Criando um jogo com Python/Flask e HTML
  25. Opa galera , tudo certo ??? :D :D Bom , to aqui pra divulgar meu programa que desenvolvi recentemente por conta de dificuldades que eu tinha na hora de encontrar diretórios em sites com o intuito de obter informação. "o arquivo zipado tem o scan e uma wordlist que sera utilizada , mas você pode baixar outras , obs : se baixar outra wordlist , troque o nome dela para commom , para o programa identificar ela" O direcional do programa são usuários windows , mas como é python podem usar em linux também. O código está comentado , então quando abrir leiam-o e apaguem os comentários para utiliza-lo... ou então apenas apaguem os comentários e mão na massa kkk , é isso :D [spoiler=DOWNLOAD]https://www.dropbox.com/s/5c7qca2248t2qrr/DIRESCAN.rar?dl=1 [spoiler=SCAN] https://www.virustotal.com/pt/file/619366f83ebbcc9c2c26e7b48dc52f1f87df831825b656d48386c703581fb327/analysis/