Tip:
Highlight text to annotate it
X
>> ZAMYLA CHAN: Olá, e bem-vindos para o passo a passo do risco.
Meu nome é Zamyla e eu vou estar levando passo a passo para você este ano.
Em CS50, cada conjunto de problemas é acompanhado por uma explicação passo a passo.
Durante essas orientações vou passar por cima conjunto de problemas da semana, explicar o
conceitos necessário e acabar com a conjunto de problemas em mordidas gerenciáveis.
>> Pela primeira p-set em CS50, nós realmente Não vou entrar em digitação e
coisas código de máquina bastante ainda.
Em vez disso, vamos usar zero, um programa que nos permite explorar
conceitos de programação em um forma visual e criativo.
Esse passo a passo irá explorar conceitos fundamentais que usaremos
CS50 todo, além de servir como um tutorial zero.
Em cada passo a passo vou listar um conjunto de ferramentas que você pode usar para o
conjunto de problemas.
A partir de conceitos do curso maiores para real funções, é bom e útil para
sabe o que está equipado com antes enfrentar o conjunto de problemas.
>> Primeiro, vamos falar sobre sprites.
Sprites são fundamentais para a tomada de projetos em zero.
Cada objeto ou a cada personagem, seja ele um gato, um cão ou um
bola, é chamado de um sprite.
Se eu quiser, por exemplo, os dois gatos no meu projeto, Eu vou precisar fazer duas
sprites separados em risco, mesmo se eles são absolutamente idênticos.
>> Cada sprite scripts associados com o duende específico.
Scripts são o que você vai estar construindo arrastando
e soltando blocos.
Scripts são instruções que determinar e definir
como o script se comporta.
>> Agora, sprites não são apenas imagens.
Um traje sprites determina que o sprite parece.
Qualquer dado Sprite pode ter mais do que uma fantasia.
Um pouco mais tarde, durante este passo a passo eu vou mostrar como você pode ter o seu
trajes mudança de sprite durante o seu programa.
>> Para criar um sprite em zero, você pode ou escolher o seu traje inicial
Biblioteca de zero, desenhar o seu próprio em Raspadinha do built-in editor de pintura,
fazer upload de sua própria imagem, ou tirar uma foto com a câmera do seu computador.
Todos os gráficos são colocados sobre o que chamamos de fase.
O palco é como a nossa tela onde sprites pode se mover.
>> Embora possamos ter múltiplos sprites, só pode haver um estágio.
Caso contrário, estágios e sprites são bastante semelhante em que a fase pode
também têm scripts.
Scripts no palco são muito úteis quando você não tem um script que
não necessariamente pertencem para um duende específico.
Talvez se refere a múltiplas listras, ou nenhum.
>> Em geral, é um bom projeto para colocar a sua scripts no palco se eles são
geral o suficiente e não pertencem para sprites específicas.
E, assim como sprites têm costumes, estágios têm cenários que podem mudar
ao longo de seu programa.
E você pode desenhar o seu próprio, fazer upload de uma imagem, tirar uma foto, ou usar o
Biblioteca zero de cenários.
Tanto o palco e sprites também pode jogar sons da biblioteca de zero, ou
você pode carregar e gravar a sua própria.
>> Para iniciar o programa de zero você vai precisa clicar na bandeira verde no
canto superior direito da janela do palco.
Mas se você não ligar nada a este bloco aqui, então nada é
realmente vai acontecer, porque o seu sprites eo estágio precisa ser dito
para responder ao evento do bandeira verde sendo clicado.
Então, você precisa anexar blocos à ranhura na parte inferior do verde
sinalizador e, em seguida, o programa irá executar essas ações quando inicia
seu programa.
>> Bem, o que vem depois disso?
Bem, tem muito risco de blocos para você usar, e você pode
até mesmo fazer o seu próprio.
Você verá três abas, scripts, Costumes e sons.
Sob a tag Scripts são categorias de declarações.
As declarações são convenientemente organizado por cor.
Você tem ações relacionadas ao movimento, som, aparência, e assim por diante.
Apesar de você ter outros blocos construídos em torno de suas declarações, é o
declarações que ajudarão os sprites ou ao palco para fazer alguma coisa, enquanto
outros blocos irão ajudar a determinar quando fazê-las.
>> Vamos dizer que você está criando sua própria primeiro projeto e você só quer a
gato a miar sob certas circunstâncias.
Para implementar isso, podemos tomar vantagem de booleanos.
Estas são expressões que avaliam de verdadeiro ou falso.
Em Risco estes são identificados pela ângulos, no final dos blocos.
Você terá uma variedade de diferentes tipos de booleanos, como é o mouse
sendo pressionado, não 2 mais 2 equiparar a 5, ou se o usuário pressionar
se uma determinada tecla no teclado?
>> Agora, você não pode apenas usar estes Booleanos sozinho.
Você precisa combiná-los com o que chamamos de condições.
Condição blocos podem ser encontrados em as instruções de controle de laranja.
Condições convenientemente ter um pouco espaço reservado que mostra a forma de
o bloco que você precisa para colocar nele.
Assim, dependendo do contexto do situação, você pode escolher um valor booleano
e colocá-lo dentro de sua condição.
E juntos, você tem uma instrução condicional.
Uma vez que você colocar dentro declarações que bloquear você tem uma estrutura montada
pelo que uma vez que uma determinada condição é atendida, então você executar os
declarações.
>> Uma das vantagens dos computadores é a grande força e velocidade em que eles
pode executar processos repetitivos.
Em vez de, digamos, repetindo um instrução mais e mais e mais
novamente e realmente escrever isso, ou neste caso, arrastar e soltar
e arrastar e soltar, o que pode fazer é encapsular em um loop.
>> Os laços podem ser usados para executar tanto coisas infinitamente com um loop para sempre,
ou para um número definido de vezes.
Por exemplo, repetir a afirmação, digamos hi, 10 vezes, ou talvez até um certo
condição é verdadeira.
E com esta Repetir até bloqueá-lo ver que zero é insinuando que
você precisa colocar um valor booleano em Repetir até o bloco para fazer uma
instrução condicional.
>> Agora, nós sabemos que podemos encapsular processos repetitivos dentro de loops,
assim você pode ver por que algo como isso pode não ser ideal.
É super longo, ele só faz a mesma coisa uma e outra
mais uma vez, 10 vezes, de facto.
Ela se move 10 passos, diz Olá, movimentar 10 passos, diz Olá.
Mas, com a ajuda de lacetes nós pode arrumar isso um pouco.
Veja como este é muito melhor.
É mais curto, que é menor e ele completa a mesma coisa.
>> Passando para variáveis.
As variáveis são essencialmente containers para os valores.
Em risco, os tipos de valores pode ou ser palavras ou eles podem ser
números, valores que tem controle.
Neste primeiro bloco temos um variável de texto que contém o
valor, Olá, mundo.
No segundo exemplo, é assumido que já temos uma variável chamada
Contador e estamos incrementando por três.
E então, no último exemplo, vemos uma lista de variáveis sendo usados
dentro de condições.
Neste bloco, perguntamos se a variável Contador é menor que zero.
>> Agora, quando você cria uma variável que você tem para decidir se você fizer o
variável disponível para todos os sprites em seu programa de zero, ou
apenas para os sprites específicos seleccionados quando você faz a variável.
E isso é muito importante decisão a tomar.
Tudo se resume ao que você alcance deseja que a variável tem.
>> Um exemplo de escopo local seria um variável apenas para um duende específico,
o que significa que somente aquele duende faria ser capaz de ver ou modificá-lo.
Se você determinar uma variável com a Global escopo, selecionando para todos
sprites, então isso significa que o palco, bem como todos os sprites,
será capaz de ver, modificar, e de acesso que
variável que você criou.
E em termos de design, é melhor escolher âmbito local sempre que puder
apenas para que o resto dos sprites e estágio não tem que se preocupar com
manter o controle dessa variável.
>> Você pode realmente ter duas variáveis de o mesmo nome para diferentes sprites como
desde que esses são variáveis locais.
Sprite um, um gato, pode ter uma variável nome do contador, e Sprite dois, um cão,
Também é possível ter uma variável chamada Contador enquanto estes
são as duas variáveis locais.
Porque o âmbito da variável não se estende para o resto do
programa, e nenhum dos outros sprites ou o estágio vai ficar confuso.
>> Anteriormente, mencionei o ponto de entrada, quando a bandeira verde clicado bloco.
Esse bloco eo acompanhamento declarações são essencialmente dizendo
seus sprites ou no palco, OK, quando a bandeira verde é clicado, este é
o que você deve fazer.
Mas esse não é o único evento que sprites eo estágio pode responder.
Nós temos, por exemplo, um gerador quando uma tecla do teclado é pressionada.
Você pode realmente escolher as letras A A a Z, de zero a nove ou a
teclas de seta.
>> Há outros eventos, também, como como quando seu sprite é clicado.
Quando você começa com blocos de eventos como estes, você vai notar uma tendência.
Eles todos têm um único grupo no inferior e uma superior lisa, que
indica que nada acima atribui a esse bloco.
Você constrói sob esses eventos blocos e construir para baixo.
>> Agora, o que acontece se nós queremos algum evento acontecer, por exemplo, quando um gato é
tocar uma determinada seção do palco?
Nós realmente não têm qualquer built-in evento para significar que, então o que nós vamos
tem a fazer é criar o nosso próprio evento.
E isso é chamado de radiodifusão.
>> Então, quando você quer sinalizar que a determinado evento aconteceu, então você
usar um chamado Emissão preto, o qual encontra-se na guia de controlo.
Lá você vai digitar o nome do evento que pretende transmitir, e
então qualquer duende ou fase pode reagir a essa
transmitido, se assim o desejarem.
O bloco quando eu recebo diz o sprites o que fazer quando eles estão
notificado de que seu costume evento aconteceu.
Então lembre-se que sempre que você transmitir um evento, é com o
entendido que qualquer um dos sprites ou o estágio vai
receber esse evento e responder a ele.
>> Agora, o último conceito antes de chegarmos a um exemplo concreto de um risco
programa, é o conceito de fios.
É quando o computador é execução simultânea
processos ao mesmo tempo.
E eu tenho certeza que todos nós já tomadas vantagem deste.
Como navegar na web enquanto ouvir música.
O computador pode executar vários coisas ao mesmo tempo.
>> Neste exemplo, aqui, estes dois scripts podem ser usadas para
o mesmo Sprite exata.
O bloco de ponto de entrada, quando Bandeira Verde Clicado, é usado várias vezes, mas
eles são dois scripts separados.
De fato, a Bandeira Verde clicado bloco provavelmente será uma das mais
blocos populares em seu programa.
Aqui vemos que quando a bandeira verde é clicado, há um processo em andamento
no, bem como um outro.
Então zero vai realmente executar estes dois exatamente ao mesmo tempo.
E sabendo que você pode realmente ter mais do que um ponto de entrada, mesmo se
é o mesmo ponto de entrada, vai para ser realmente útil se você quiser
tarefas distintas, separadas um do outro.
>> Tudo bem.
Portanto, agora que nós cobrimos todos estes conceitos, vejamos um exemplo.
Eu fiz uma série de programas de rascunho, de modo a tentar acompanhar como nós
fazer um pouco de jogo.
Vamos começar por abrir Hungry Dino Zero.
>> Vamos clicar na bandeira verde para começar e ver o que ele faz.
Temos um sprite bug que se move para a alguns passos, reinicia em alguma altura, e
depois recua.
E depois temos um dino Sprite.
Ao pressionar as teclas de seta, estou me mudando o sprite dino redor, tornando-se transformar
e girar.
Isso pode ser divertido, mas lá não são muitos
scripts neste programa.
Nós podemos definitivamente adicionar a isso.
>> Por exemplo, quando o dino está movendo pode realmente sair da tela e
quase desaparecem do site.
Queremos mudar isso, porque nós não quer que o dino para escapar.
Então, vamos parar o nosso roteiro com o vermelho bandeira e, em seguida, editar os scripts Dino.
Observe que este script particular tem um circuito para sempre, que termina com um
straight edge.
Ele não tem qualquer ranhura na parte inferior.
E isso faz sentido a partir do nome, um loop para sempre.
É a execução de algo infinitamente e nunca vai acabar.
Portanto, esta é uma grande oportunidade introduzir uma discussão.
>> Tudo bem.
Então, vamos adicionar outro script.
Vou começar com esta entrada ponto, quando Bandeira Verde Clicado.
E eu quero verificar continuamente se o dino vai ser
tocar a borda.
Sob Movimento há um bloco pequeno puro que diz que, se por Bounce Borda.
E por isso queremos continuamente executar isso.
>> O que esta declaração faz é verifica se o sprite está à beira da
palco, e salta para trás se for.
E porque o usuário sempre pode mover o dino, queremos encontrar algum tipo de
laço que nos permite continuamente executar esta declaração.
Olhando sob Controle vamos escolher o loop para sempre.
Então, vamos arrastar isso para o scripts de Dino e, em seguida
adicionar If On Bounce Borda.
E, em seguida, vamos testar nosso programa.
>> Assim, o erro está em movimento, como de costume, e então se testar nosso novo script
mover o nosso dino até a borda, vemos que ele não pode
escapar da fase mais.
Ele salta de trás.
Agora você pode se perguntar por que o dino saltos, mas não o bug.
Bem, isso é porque nós escrevemos o nosso mais novo script dentro do scripts de dino
e não os erros.
Então, o erro não irá ouvir o instruções que deu o dino.
>> Tudo bem.
Então, vamos acrescentar algo de novo agora.
Se você vai para a guia Costumes você verá que os diferentes costumes que
vem pré-carregado com seu sprite selecionado se você escolher um do
Biblioteca do zero.
Há esse bonitinho dino chomp traje, então vamos implementar o dino
mastigando quando nós pressionamos, dizer, a tecla de espaço.
>> Voltar para os scripts do dino.
Neste script aqui, eu já estou verificação no circuito sempre se
certas teclas estão sendo pressionadas e movendo o dino conformidade.
Se eles deixaram de seta é pressionado, o dino gira no sentido anti-horário.
Se a seta para a direita é pressionado, o dino gira no sentido horário.
Então, se a seta para cima é pressionado, em seguida, o dino progride para a frente.
Nós podemos apenas adicionar o script em vez de adicionando um separado porque esta
já está verificando no tema da que teclas estão sendo pressionado.
>> Vamos adicionar uma que verifica a tecla de espaço que está sendo pressionado.
Estes blocos estão verificando aqui para que as teclas sejam pressionadas.
Eles estão todos no azul brilhante, de modo vamos para a detecção azuis brilhantes
declarações e olhar ao redor.
Aqui está um bloco de Imprensa Spaced chave.
Então, o que nós queremos fazer é ter o dino mudar para o derrubar traje
se, e somente se, o Espaço tecla está sendo pressionada.
>> Então, vamos imitar a estrutura aqui.
Agora, mudando a roupa tem a ver com como o dino parece tão vamos para
Olhe comunicado.
E com certeza, nós temos um switch Costume de Dino Chomp.
Agora, quando chomp para baixo não queremos o dino estar mastigando-se para sempre,
então vamos adicionar uma declaração dizendo para voltar.
Vai mudar costumes tipo de forma rápida, porém, porque nas demonstrações Raspadinha
executará back to back realmente rapidamente, quase instantaneamente.
Então vamos para Controle e, em seguida, fazer a dino pausa para um pouco de espera
um segundo depois ele chomps baixo.
>> Agora vamos editar o sprite bug.
O sprite bug avança cinco um total de cinco vezes os passos depois de um
pausa momento.
No bloco de cima aqui o bug Coloca-se numa determinada
valor coordenada x.
Para encontrar as coordenadas você pode realmente mouse sobre a tela e
em seguida, no canto inferior do palco a janela de coordenadas será atualizado assim
você pode tirar proveito desta prática apresentam para implementar as coordenadas
que você deseja.
E, nesta declaração aqui, instruímos o bug para começar ao mesmo
x valorizam cada vez, mas para escolher um aleatório altura para o bug que ainda
estadias dentro dos limites do palco.
>> Veja aqui que eu estou aproveitando a transmissão do evento em risco.
Esse manipulador de eventos é chamado de New bug1.
Assim, sempre que o bug recebe Novo evento bug1,
ele vai executar a instrução.
Então, depois de ele se move para a frente o seu conjunto quantidade de vezes, ele realmente
transmite o evento New bug1.
>> Mas que tal mudar este roteiro um pouco?
Agora temos o bug movendo cinco etapas.
Isso não é muito, um total de cinco vezes.
Nós realmente não sei quantas vezes vou ser necessário até que o bug atinge,
dizer, o fim da tela, então vamos mas fazem a chegar ao fim da
tela, mas use algum tipo de outra construção.
>> Eu vou separar isso porque vamos mudar algumas coisas.
Para eliminar blocos a partir do zero arrastar os blocos para o
à esquerda e depois solte.
E isso fica excluída.
Se você decidir que não quer seja eliminada, então você pode
vá em Editar e undelete.
Mas queria ficar livrar desse bloco.
>> O que nós queremos fazer agora é se mover, digamos, 50 passos e fazer uma pausa de um segundo, e
Repita este procedimento até que tocamos a extremidade da tela.
Então, vamos usar um laço que nos permite repetir o processo até que uma certa
condição for satisfeita, apropriadamente nomeado repetir.
>> O que se passa no interior do estado de um Repetir até?
Algo que nos diz se o bug está tocando a borda da
tela, que vai estar sob Demonstrações de detecção.
Aqui está este booleano, Tocar.
E você pode escolher aqui o que que você deseja verificar.
Então, vamos selecionar Touching Edge e adicionar esta instrução condicional para trás dentro
>> Portanto, agora se observarmos o nosso erro, ele vai voltar mais uma vez ele toca
a borda do palco.
Grande.
Terminamos com Hungry Dino Zero, então vamos abrir Hungry Dino Uno.
Como uma espécie de show cooking, eu adicionei um pouco mais de recursos.
Por exemplo, você verá que o bug é, na verdade, pura e simplesmente deslizar agora
em oposição ao anterior.
Sob movimento há essa deslizar comunicado.
Agora, o bug desliza 70 unidades para o direito de sua exposição atual, mas
permanece na mesma posição y aqui.
E agora podemos ter um dino mastigando como foi implementado antes.
>> Mas, este programa não é chamado Hungry Dion para nada, então vamos ter o
dino comer o bug.
Como podemos dizer o bug, ou dizer o dino, que foi cortada?
Como podemos comunicar este evento?
Bem, nós sabemos que quando ligar o traje para o dino para o dino chomp
que temos chomped baixo.
E dizer que queremos que o bug de desaparecer uma vez que é comido.
Bem, nós vamos ter que verificar se o erro foi chomped em e
comunicar ao bug que ele vai ter para esconder ou desaparecer da tela
uma vez que foi chomped baixo.
>> Então, que tipo de conceito, que tipo de ferramenta que podemos usar para ter o dino
comunicar ao bug que tem chomped baixo?
Broadcasting.
Então vamos a eventos e adicionar um evento para transmitir.
Chomp.
OK.
Mas lembre-se que uma vez que nós transmitimos algo que também temos de
receber este evento.
Assim que o duende vai transmitir chomp?
Bem, vamos ter que fazer o dino quando a tecla Espaço for pressionada.
>> Vamos adicionar um bloco para receber chomp.
Agora, quando o dino se resume apenas em um espaço vazio que não quer que o bug
reagir a isso em tudo, somente se o dino estava tocando o, mas na época
do chomp é que vamos realmente fazer alguma coisa.
Então, vamos usar a condição Se porque estamos verificando se algo é
verdade ou não.
>> Agora, se voltar a sentir, então podemos usar este Touching
bloquear e selecione Dino.
Então, sob olhares, encontramos esta Esconder bloco que basicamente vai fazer o bug
desaparecer do palco.
>> Vamos torná-lo esconder, mas o que fazemos quer outro bug, certo?
Nosso dino está com fome.
Por isso, queremos dar-lhe outro bug para perseguir.
Então, vamos também transmitem o evento New bug1.
Exceto que queremos esperar por um tempo antes que outro bug aparece, então vamos
também esperar um segundo.
>> Tudo bem.
Então, vamos verificar isso.
Nós chomped para baixo, mas a desaparecer, outro aparece, e nós chomp para baixo
nele novamente.
Isso está parecendo uma bonita jogo divertido, mas todos os jogos
precisa marcar, certo?
Então o que podemos usar para manter o controle de quantos erros o dino tem comido?
Uma variável.
Então, vamos adicionar uma variável chamada Score.
>> E agora nós vamos ter que decidir o que âmbito desta variável tem.
Então, vamos pensar.
Enquanto podemos querer o mas para aumentar o resultado se ele foi
comido com sucesso, eo estágio pode tem algo a ver com o
pontuação, bem, então vamos atribuir esta variável para todos os sprites.
>> Queremos aumentar a pontuação, se, e somente se, um bug foi comido.
E nós já escrevi um script que trata de um bug ser comido assim
vamos adicionar esta declaração em, mudar marcou um.
Isso significa que uma vez que você come um bug a pontuação aumenta.
>> Vamos jogar um pouco e comer, Eu não sei, três erros.
Então você se cansar do jogo, bem, você pressiona o batente vermelho
sinal para parar o jogo.
E quando você quiser voltar, você vai pressione a bandeira verde novamente.
Mas o resultado ainda é três ainda embora eu estou jogando um jogo novo.
Nós não queremos dar aos usuários uma cabeça começar, por isso vamos precisar redefinir o
marcar cada vez que começar um novo jogo.
Então, vamos adicionar uma instrução para o estágio de script de ponto de entrada para definir o
pontuação variável de zero.
Então, agora, sempre que você iniciar um jogo, a pontuação terá início às zero.
>> Agora vamos abrir Hungry Dino 2, onde Eu adicionei mais algumas coisas.
Eu direita clicou o sprite bug para duplicar o sprite que fez uma
Sprite idêntico ao meu anterior.
Veneno Bug é essencialmente idêntico ao Bug1 mas eu escolhi um traje novo, porque
Eu pensei que parecia, bem, tipo de veneno.
Em vez de aumentar o placar quando o bug veneno é comido, eu realmente
diminuir o placar, mudando pontuação negativa.
>> E então eu fiz outra fantasia para nossa dino usando o editor tinta
fazer um doente procurando dino e nomeou-o Dino doente.
Mas nós não utilize este costume em nossa programa ainda, então vamos adicionar um pouco de
declarações e blocos que irão mudar traje do dino aos doentes verde
costume sempre que ele come um bug envenenado.
>> Agora, uma vez que duplicado o sprite bug, o bug envenenado tem todas
os scripts que o bug original não.
Se você quiser copiar os scripts de outros sprites, você pode arrastar o
roteiro em cima da Sprite que você deseja copiar.
Mas não precisa fazer isso aqui porque o bug envenenado já tem um
script que verifica se o bug foi chomped baixo em.
E nós podemos aproveitar isso para comunicar à dino que comeu um
inseto venenoso.
E a comunicação entre sprites por difusão.
Então, vamos transmitir uma nova evento chamado Dino doente.
>> E nós sabemos que temos um traje para o dino para mudar, mas nós também
saber de mais cedo que é melhor para adicionar uma pausa
entre mudanças de figurino.
Então, quando eu receber Dino doente, eu vou para mudar traje de Dino doente, espere
um segundo, e depois mudar voltar para Dino Hungry.
Tudo bem.
Vamos jogar o nosso jogo e comer um bug eo besouro.
E a pontuação diminui um ponto.
>> Agora, às vezes você pode perceber que o variável pode não aparecer na
canto esquerdo da tela.
Se você navegar para a Seção de dados ao abrigo os scripts, você verá esta marca
ao lado das variáveis que você cria.
E isso esconde ou unhides os variável na tela.
Mas você também pode usar uma instrução chamado Show ou
Ocultar uma variável específica.
Então, vamos usar este Mostrar pontuação variável para certificar-se de que toda vez que começar
o jogo, a variável é mostrado.
Grande.
>> Então, vamos executar o jogo e comer um bug veneno imediatamente.
Agora, é um pouco estranho ter um jogo ter pontos negativos, certo?
Então, vamos introduzir uma outra característica.
Se o dino come demais venenoso erros, em seguida, ele fica muito doente e
jogo acabou.
Assim, para implementar isso, vamos transmitir outro evento, Game Over.
Como sabemos quando executar este Game Over transmissão?
>> Bem, nós podemos fazer isso de várias maneiras.
Nós podemos ter um script na fase que verifica continuamente se a pontuação
é negativa ou não, e as transmissões Game Over quando o
pontuação torna-se negativo.
Ou podemos tirar proveito do fato de que a única maneira de o placar poderia sempre
ser negativo, é quando um venenoso bug é comido.
Porque quando você come o outro bug, a pontuação aumenta.
Não há nenhum uso em verificar se deve ser Game Over ou não, quando você
comer um bug comestível.
>> Assim, podemos realmente apenas acrescentar ao script que recebe o Dino Doente
evento transmitido.
Queremos instruir o dino como se segue.
Se o resultado for menor que zero, transmitir Game Over.
Então, vamos construir a pontuação inferior a Zero condição usando um bloco do
parte do operador, e arrastando em nossa pontuação para esse bloco.
E veja aqui você pode simplesmente arrastar o pontuação variável e colocar menos do que zero.
E vamos para transmitir um novo evento, Game Over.
>> Mas se o resultado não tenha ido abaixo zero, queremos que o dino para
continuar o jogo.
Então, ao invés de usar um caso aqui, vamos usar um se construir mais.
Uma pessoa se diz construir nosso dino de fazer uma coisa, se a condição for verdadeira
e outra coisa, se o condição é falsa.
O corpo do nosso primeiro caso pode ir para se a outra pessoa, por isso vamos arrastar que dentro
Mas, se a pontuação não seja inferior a zero, então vamos voltar para o
Traje Dino fome.
Nós não queremos fazer isso preventivamente.
Grande.
>> Mas desde que nós transmitimos Game Over, ainda precisamos fazer uma
bloco receptor de eventos.
Na verdade, há uma paragem Todos declaração no controle, então vamos ligar este ao
quando eu receber Game Over.
Mas também queremos que o erro de parar, de modo vamos arrastar esse script para todos
o erro sprites, bem como a fase.
Vamos tentar fazer isso.
>> Comer um inseto venenoso de imediato, o programa pára como esperado.
Nenhum dos outros insetos movimento e nem faz o dino se você pressionar
as teclas de seta.
Mas vamos dizer que não queremos lembrar o usuário de sua pontuação negativa, de modo
vamos esconder a pontuação variável de a fase sempre que o jogo
Mais de evento é recebido.
Tudo bem.
>> Portanto, este é um jogo bastante decente.
Com mais tempo, você pode adicionar mais sprites e mais scripts.
Talvez os erros podem se mover a velocidades diferentes.
Você pode adicionar um novo fundo a fase -
um Game Over cenário -
de tal modo que, quando a fase de receber o Jogo sobre o evento, pode mudar para o
Jogo sobre o pano de fundo e tudo dos sprites esconder.
Lotes de pequenos ajustes podem ser feitos para tornar o seu jogo um pouco mais polido.
>> E este é apenas um exemplo de uma projeto que você pode fazer em Scratch
usando todas as ferramentas que discutimos anteriormente -
sprites, figurinos, palcos, cenários, condições, loops, variáveis,
eventos e linhas de transmissão.
Hungry Dino não usar qualquer som efeitos, mas você pode facilmente adicionar o seu
próprio navegando até a guia Sons e explorar as declarações de som.
Scratch é uma ótima introdução para conceitos de programação, para ser criativo
e, mais importante, divirta-se.
Meu nome é Zamyla, e este é o CS50.