No tutorial de iniciação Python da BGE você vai aprender como usar Python scripting no Blender 2.6, para fazer um movimento do carro, e parar aumente a velocidade. Este tutorial vai te ensinar o básico da linguagem Python para a game engine do Blender, incluindo acesso e alteração de informações dos tijolos lógicos, por meio de scripts. Antes de começar, se você é novo em Python, e para mais informações gerais sobre Python, incluindo formatação, declarações, funções, blá, blá, confira Guia do Iniciante em Python.
Clique aqui para baixar o arquivo mistura . Este arquivo é o produto acabado e não é necessário fazer o download, a fim de fazer o tutorial. Todos os modelos e texturas embalados no arquivo de lote são seu para fazer o que quiser.
Você já deve ter uma compreensão básica de como tijolos lógicos trabalhão, antes de ler este tutorial sobre o uso de python, mas é simples o suficiente para acompanhar, de uma ou outra maneira. Os tijolos são lógicas estão na janela lógica do jogo, com sensors na esquerda, controllers no meio, e actuators do lado direito.
Criando um novo script Python
No editor de texto, crie um novo arquivo de texto, pressionando o botão com um sinas de "+", e renomeá-lo para "cubeMove".
Antes de escrever qualquer coisa que quiser conferir algumas de nossas opções visuais. Há 3 ícones ao lado do campo do nome do script onde você apenas mudou o nome do script. O primeiro é o número da linha. Clique nele para ativá-lo. Isso simplesmente mostra números ao lado de cada linha para que você saiba que linha do script que você está escrevendo. Isto é essencial para a depuração, quando há um erro no seu script, o console do sistema irá dizer-lhe qual o número da linha o erro está errada. Os outros dois ícones são para quebra de linha, e destaque de sintaxe.
Uma última coisa que precisamos é ativar o console do sistema. Em versões mais antigas do Blender era visível por padrão, mas não é mais. Este é o lugar onde todos os dados de script e erros de script irá se imprimir. Para permitir isso, vá no menu Ajuda do topo e selecione "Console Sistema Toggle" se você não tiver essa janela visível.
Agora, para alguns scripts reais. Copie e cole o código abaixo em seu novo arquivo de script:
print ("Olá")
print () é um simples comando que imprime o que está no parêntese para o console, neste caso, ele imprime a palavra Olá. Para o script rodar e fazer isso, nós vamos usar tijolos lógicos. Então, escolha um objeto em sua cena, e na janela lógica do jogo adicionar um sensor de clique direito do mouse, e um controlador de python. Ligue estes dois, e no campo do script python, digite ou selecione o seu cubeMove.
Agora posicione o cursor do mouse sobre a visualização 3D e aperte "P". Isso inicia o jogo. Clique com o botão direito do mouse e depois pressione Esc para encerrar o jogo.Verifique o console e você verá a palavra Olá. Seu primeiro script com sucesso!
** Anote que se você estiver com o mouse pairando sobre a janela do script e pressionou P, você teria escrito P em algum lugar no script e isso teria causado um erro. Qualquer que seja a janela em que o mouse esteja passado sobre, ela é a janela ativa.**
Ficando sério
Agora apague essa linha de impressão, e Cole a seguinte linha no topo do seu script:
import GameLogic
Esta linha vai estar no topo de praticamente todos os seus scripts de jogos. GameLogic contém todas as funções Python em tempo real para Blender, por isso é necessário importar este módulo para que possamos acessar todas as suas funções, para usar em nossos scripts. Adicionar em outra linha abaixo, o que faz melhor uso do comando de impressão, de modo que seu script parecido com este:
import GameLogicprint (dir(GameLogic))print (dir(GameLogic.getCurrentController()))cont = GameLogic.getCurrentController()own = cont.ownercont = GameLogic.getCurrentController()own = cont.ownermove = cont.actuators["move"]pressup = cont.sensors["up"]pressdown = cont.sensors["down"]speed = move.dLoc[1]
Iniciar o jogo (pressione p enquanto mouse é passado sobre Visualização em 3D), em seguida, olhar para o seu console, ele irá imprimir todas as funções no módulo GameLogic.Então, você deve saber que não só você pode imprimir o dir de GameLogic, mas o dir de todas as suas funções também.
Encontre o getCurrentController , uma função listada no console. Este acessa o controlador de tijolo lógicos que executa o script. Uma vez que acessar o controlador podemos acessar todos os sensores e atuadores conectados a ele, e até mesmo acessar informações sobre o objeto que possui o controlador. Esta é uma função muito importante. Agora vamos mudar a linha de impressão do seu script, para imprimir o dir de GameLogic.getCurrentController () , e ter certeza que ele tem seu próprio conjunto de parênteses, para que o script:
import GameLogic
Comece o jogo e dar uma olhada no console. Você verá um novo conjunto de funções, incluindo atuadores e sensores, todos os quais têm seus próprios diretórios que podem ser impressas também. Todas as informações que você precisa pode ser encontrado usando dir (). Se você ficou sem saber o que são as suas opções ao trabalhar com objetos ou tijolos lógicos em Python, você pode simplesmente imprimir seu diretório.
Para Scripts reais
Então você sabe sobre o comando de impressão, a impressão de diretórios, e você sabe sobre import GameLogic . Vamos avançar para alguns scripts de jogo. Apague a linha de impressão e adicionar duas linhas para que o script fique parecido com este:
import GameLogic
Dê uma olhada nestes três linhas. Eles vão estar no topo de cada um de seus scripts de jogo e são provavelmente as três linhas mais essenciais do código para qualquer script do jogo.
Vou começar por explicar a segunda linha, cont = GameLogic.getCurrentController () . Eu disse antes que o getCurrentController () era uma função de tudo. Bem, aqui nós adicionamos apenas uma linha, que acessa o controlador, e atribui essa informação para a variável cont . O nome da variável pode ser qualquer coisa que você goste. Isso é usado simplesmente para não ter que escrever GameLogic.getCurrentController () toda vez que precisar dele.
Agora na terceira linha, own = cont.owner .
Aqui nós acessamos o proprietário do controlador e atribuir essa informação a uma variável. Agora temos acesso ao objeto que possui o controlador de python que executa o script, neste caso. Isso nos dá acesso a informações sobre o objeto, mais as propriedades de seu jogo.
Adicionando mais tijolos lógicos
Eliminar o sensor sempre e adicionar dois sensores de teclado, um para a tecla para cima, e um para a tecla para baixo. Renomeie esses sensores para "up" e "down". O nome é importante porque nós vamos estar chamando esses sensores pelo nome no script python. Para o sensor "up", marque o "Tap", essa opção fara com q o sensor só registre uma vez, quando você pressiona a tecla, senão ele também registra uma segunda vez quando a tecla é liberada. Tap assegura que um único sensor dispare. Ligue ambos os sensores para o controlador de python, para que o script python seja executado quando um desses botões forem pressionados.
Agora adicione um atuador de movimento e conecte o ao controlador. Renomeie o atuador para "move". Nós vamos usar esse atuador para mover nosso carro quando o botão é pressionado para cima.
Agora vamos adicionar mais quatro linhas abaixo do own = cont.owner para que possamos ter acesso aos nossos novos sensores e atuadores no script, e estamos criando uma outra variável para a velocidade. Então faça seu script parecido com este, adicionando as quatro linhas de fundo:
import GameLogic
Dê uma olhada no move = cont.actuators["move"] . Este acessa o atuador chamado "move" da lista de atuadores. Se nada foi definido dentro dos colchetes (ex: cont.actuators[] ), então todos os atuadores conectados ao controlador python serão colocado nesta lista. Mas neste caso, estamos apenas chamando o nome "move".
Agora olhe para as linhas de pressup e pressdown . Estas acesso dos sensores "up" e "down" para que possamos detectar qual as teclas são pressionadas, e fazer o script fazer algo diferente para cada evento.
Agora veja a última linha, speed = move.dLoc[1] . Aqui nós mexendo no atuador move. O move é um atuador de movimento e tem campos diferentes que podemos acessar e mudar com python. Neste exemplo estamos acessando o valor do dLoc porque é assim que estamos movendo nosso veículo. Queremos movimentar o veículo sobre o eixo Y é por isso que eu estou chamando o segundo valor para o campo dLoc.
Se você está se perguntando por que eu digitei [1] para chamar o segundo valor na lista, faça uma nota que os itens da lista começar a partir de 0, portanto, chamando move.dLoc[1] é chamar o segundo item na lista. Se eu quisesse pegar o primeiro valor, o valor de X, escrevê-lo como move.dLoc[0] . Assim, em breve, com esta linha de código a variável speed será igual qualquer que seja o valor de Y no momento em que o script é executado.
Fazendo as coisas acontecerem
Agora que declarou todas as nossas variáveis iremos adicionar algumas declarações para determinar se up ou down foi pressionado, e depois ter as duas chaves de gatilho diferentes. Em resumo, é o que queremos que aconteça, sempre que o jogador pressiona para cima, adicionado 0,05 ao valor de Y no actuador de movimento, aumentando a velocidade cada vez mais com cada pressionar de tecla. E sempre que o jogador pressiona para baixo, o valor de Y é reposto a 0, fazendo o carro parar.
Vamos começar por definir o que acontece quando nós pressionamos para cima. Então adicione as linhas abaixo da variável speed , de forma que seu script parecido com este:
import GameLogic
cont = GameLogic.getCurrentController()
own = cont.owner
move = cont.actuators["move"]
pressup = cont.sensors["up"]
pressdown = cont.sensors["down"]
speed = move.dLoc[1]
if pressup.positive:
speed = speed + 0.05
move.dLoc = [0.0, speed, 0.0]
cont.activate(move)
Esse if é usado para detectar a ação ou não o botão para cima (up). Certifique-se de manter as coisas formatado como eu formatei. O seu if precisa de uma declaração de cólon no final do mesmo, e qualquer parte de ação desta declaração deve ser tabulada em abaixo dela. Agora, se o jogador pressiona para cima, "0,05" é adicionado a qualquer que seja o valor atual de speed , e esse valor de speed está ligado ao move do atuador. dLoc é o campo no atuador de movimento qui queremos mudar. Se você quiser alterar outros campos no atuador, para descobrir quais são as opções disponíveis, você pode usar print dir(move) . Então, agora nós simplesmente ligamos o speed como o valor de Y na lista e ele vai mudar o valor no atuador. Para fazer este atuador ativo agora, usamos a linha cont.activate(move) . Agora o nosso carro se move mais rápido.
Agora vamos definir o que acontece quando nós pressionamos para baixo (down). Então adicione as linhas na parte inferior para seu script parecido com este:
import GameLogic
cont = GameLogic.getCurrentController()
own = cont.owner
move = cont.actuators["move"]
pressup = cont.sensors["up"]
pressdown = cont.sensors["down"]
speed = move.dLoc[1]
if pressup.positive:
speed = speed + 0.05
move.dLoc = [0.0, speed, 0.0]
cont.activate(move)
elif pressdown.positive:
speed = 0
cont.deactivate(move)
move.dLoc = [0.0, 0.0, 0.0]
A declaração elif é como dizer "else if". Então, se o jogador está pressionando para baixo em vez de para cima, vamos definir speed como 0, desativando o movimento do atuador e, finalmente, redefinir o valor de Y na dLoc para o volta 0.
Jogue o jogo!
Seu script está completo! Comece o jogo! Agora pressione para cima repetidamente para ganhar velocidade, e pressione a tecla para baixo para parar.
