Como fazer um elemento ter o tamanho do elemento filho que tenha position : absolute?

Em projetos de desenvolvimento web, é comum precisarmos posicionar um elemento filho dentro de um container usando position: absolute. O problema é que, quando fazemos isso, o container perde a sua altura e largura, pois os elementos filhos posicionados absolutamente são retirados do fluxo do documento. Isso pode ser um problema quando queremos que o container tenha o tamanho do elemento filho.

Felizmente, há uma solução simples para este problema, que envolve o uso de JavaScript para definir o tamanho do container com base no tamanho do elemento filho. Neste artigo, vou mostrar como fazer um container ter o tamanho do elemento filho quando este filho tem position: absolute usando JavaScript.

Usando JavaScript para definir o tamanho do container

A maneira de fazer um container ter o tamanho do elemento filho quando este filho tem position: absolute usando JavaScript envolve calcular a largura e altura do elemento filho e definir essas dimensões para o container. Veja o código abaixo:

<div class="container" id="container">
  <div class="child">Elemento filho</div>
</div>

<script>
  const container = document.getElementById('container');
  const child = container.querySelector('.child');
  const width = child.offsetWidth;
  const height = child.offsetHeight;
  container.style.width = `${width}px`;
  container.style.height = `${height}px`;
</script>

<style>
  .container {
    position: relative;
  }
  .child {
    position: absolute;
    top: 0;
    left: 0;
  }
</style>

Neste exemplo, a classe .container é definida como position: relative, o que significa que ela será posicionada em relação ao seu pai. A classe .child é definida como position: absolute, o que permite que o filho seja posicionado em relação ao container. As propriedades top: 0 e left: 0 garantem que o filho comece a ser posicionado a partir do canto superior esquerdo do container.

O JavaScript começa selecionando o container e o elemento filho usando document.getElementById e Element.querySelector. Em seguida, o código calcula a largura e altura do elemento filho usando offsetWidth e offsetHeight. Finalmente, as dimensões são definidas para o container usando style.width e style.height.

Conclusão

Neste artigo, vimos como fazer um container ter o tamanho do elemento filho quando este filho tem position: absolute usando JavaScript. Essa solução envolve calcular a largura e altura do elemento filho e definir essas dimensões para o container usando JavaScript. Embora seja um pouco mais complexa do que as soluções CSS, esta técnica é muito útil quando precisamos definir o tamanho do container dinamicamente com base no tamanho do elemento filho.

Como conectar na ViaCPE com JavaScript?

Este é um artigo rápido e prático que mostra que conectar-se ao ViaCEP usando JavaScript. O processo em si é simples, você pode fazer uma requisição HTTP GET para a API do ViaCEP com o CEP desejado e manipular a resposta retornada para obter os dados desejados.

Usando métodos encadeados

Você pode fazer isso usando a função fetch() do JavaScript ou outras bibliotecas de requisições HTTP como o Axios. Veja um exemplo usando a função fetch():

const cep = '01001000';
const url = `https://viacep.com.br/ws/${cep}/json/`;

fetch(url)
  .then(response => response.json())
  .then(data => {
    console.log(data);
    // Faça a manipulação dos dados retornados aqui
  })
  .catch(error => console.log(error));

Nesse exemplo, uma requisição HTTP GET é feita para a URL do ViaCEP com o CEP desejado inserido na URL. A resposta da API é convertida para o formato JSON usando o método json() e, em seguida, é possível manipular os dados retornados como um objeto JavaScript.

Lembre-se de tratar os erros que podem ocorrer durante a requisição HTTP e de ajustar a forma como os dados serão manipulados de acordo com a sua necessidade.

Usando Async/await

O async/await é uma forma mais moderna e simplificada de trabalhar com Promises, que são utilizadas nas requisições HTTP. Com o async/await, o código fica mais legível e fácil de entender.

Veja um exemplo de como buscar os dados do ViaCEP utilizando async/await:

async function getCEPData(cep) {
  try {
    const url = `https://viacep.com.br/ws/${cep}/json/`;
    const response = await fetch(url);
    const data = await response.json();
    console.log(data);
    // Faça a manipulação dos dados retornados aqui
  } catch (error) {
    console.log(error);
  }
}

getCEPData('01001000');

Nesse exemplo, a função getCEPData é definida como assíncrona com a palavra-chave async. Dentro da função, é criada a URL da API do ViaCEP com o CEP desejado e, em seguida, é feita a requisição HTTP GET utilizando o fetch. O await é utilizado para aguardar a resposta da API e a conversão da resposta para JSON. Em seguida, é possível manipular os dados retornados como um objeto JavaScript.

Lembre-se de utilizar a estrutura try/catch para tratar os erros que podem ocorrer durante a requisição HTTP.

Entendendo o Prototype do JavaScript

Uma das características mais poderosas do JavaScript é a sua capacidade de trabalhar com objetos, que são instâncias de classes ou protótipos. O sistema de protótipos do JavaScript permite que os desenvolvedores criem objetos de forma flexível e eficiente. Neste artigo, vamos explorar o conceito de prototype no JavaScript e entender como ele funciona.

O que é o Prototype / Protótipo?

O prototype é um mecanismo interno do JavaScript que permite aos objetos herdar propriedades e métodos de outros objetos. Essa herança é diferente da herança de classe tradicional encontrada em linguagens orientadas a objetos, como Java e C#. No JavaScript, a herança ocorre através da chamada “herança prototípica” e é baseada em objetos, em vez de classes.

Herança Prototípica

A herança prototípica é a base do sistema de objetos do JavaScript. Cada objeto em JavaScript tem uma referência interna a outro objeto, chamado de “protótipo”. Quando uma propriedade ou método é acessado em um objeto, o JavaScript primeiro verifica se essa propriedade ou método existe no próprio objeto. Se não for encontrado, o JavaScript procurará no protótipo do objeto. Esse processo continua até que a propriedade ou método seja encontrado ou até que a cadeia de protótipos termine.

Essa cadeia de protótipos é a principal característica que permite a herança no JavaScript. Quando um objeto herda de outro objeto, na verdade está herdeiro do protótipo desse objeto.

Funções Construtoras e o Prototype

No JavaScript, funções construtoras são usadas para criar objetos com propriedades e métodos específicos. Quando uma função é chamada com a palavra-chave “new”, um novo objeto é criado e sua referência de protótipo é atribuída ao protótipo da função construtora.

function Pessoa(nome, idade) {
    this.nome = nome;
    this.idade = idade;
}
const pessoa1 = new Pessoa("João", 30);

Neste exemplo, a função Pessoa é uma função construtora e cria objetos com as propriedades nome e idade. Quando criamos um objeto pessoa1 usando a palavra-chave “new”, o protótipo do objeto pessoa1 é configurado para ser o objeto Pessoa.prototype.

Adicionando Propriedades e Métodos ao Prototype

O prototype é um objeto comum e, como tal, você pode adicionar propriedades e métodos a ele. Isso é útil quando você deseja que todos os objetos criados por uma função construtora compartilhem propriedades e métodos sem precisar redefini-los em cada instância.

Pessoa.prototype.apresentar = function() {
    return `Olá, meu nome é ${this.nome} e tenho ${this.idade} anos.`;
};

console.log(pessoa1.apresentar()); // Olá, meu nome é João e tenho 30 anos.

Ao adicionar o método apresentar ao prototype da função construtora Pessoa, todos os objetos criados a partir dela terão acesso a esse método.

Qual a diferença entre herança de classes e herança herança Prototípica no JavaScript?

Bom, esse é um tópico que merece sua própria postagem. E você pode ver detalhes no post Qual a diferença entre Herança de classes e herança Herança Prototípica no JavaScript?

Mas resumidamente, a herança de classes é baseada em classes, enquanto a herança prototípica é baseada em objetos. Essa diferença fundamental afeta a forma como a herança e a reutilização de código são alcançadas em cada paradigma.

Conclusão

Isso ai, o sistema de protótipos do JavaScript é uma característica poderosa e flexível que permite a herança e o compartilhamento. Espero que tenha gostado e aproveita para conferir nossas outras postagens

Trabalhando com a API do DOM

O DOM, ou Document Object Model, é uma interface de programação de aplicativos (API) que permite aos desenvolvedores manipular o conteúdo HTML e CSS de uma página da web.

O DOM é organizado em uma árvore de nós (Nodes), onde cada nó representa um elemento HTML na página. Os desenvolvedores podem usar JavaScript para acessar e manipular esses nós, adicionando, removendo e modificando elementos HTML em tempo real.

Neste tutorial, vamos explorar os conceitos básicos do DOM e como usá-lo para manipular o HTML de uma página da web.

Obtendo elementos do DOM

Antes de podermos manipular o HTML de uma página, precisamos primeiro obter os elementos HTML desejados usando o DOM.

Existem vários métodos para obter elementos do DOM, mas dois dos mais comuns são document.getElementById() e document.querySelector(). O document.getElementById() retorna um elemento HTML com base no valor do atributo id, enquanto o document.querySelector() retorna o primeiro elemento HTML que corresponde a um seletor CSS específico.

// Obtendo um elemento por ID
const myElement = document.getElementById('my-id');

// Obtendo o primeiro elemento que corresponde a um seletor CSS
const myOtherElement = document.querySelector('.my-class');

Manipulando conteúdo do DOM

Uma vez que temos referências aos elementos HTML que queremos manipular, podemos atualizar seu conteúdo usando o DOM.

Para atualizar o conteúdo de um elemento HTML, podemos usar as propriedades textContent ou innerHTML. A propriedade textContent define o texto dentro de um elemento, enquanto a propriedade innerHTML define o HTML dentro de um elemento.

// Atualizando o texto de um elemento
myElement.textContent = 'Novo texto aqui';

// Atualizando o HTML de um elemento
myOtherElement.innerHTML = '<p>Novo HTML aqui</p>';

Adicionando e removendo elementos do DOM

Podemos adicionar e remover elementos HTML do DOM usando o JavaScript. Para adicionar um novo elemento HTML, podemos criar um novo nó usando o método document.createElement() e anexá-lo a um elemento existente usando o método appendChild().

Para remover um elemento HTML, podemos usar o método removeChild().

// Criando um novo elemento HTML
const newElement = document.createElement('div');

// Definindo o conteúdo do novo elemento
newElement.textContent = 'Novo elemento aqui';

// Anexando o novo elemento a um elemento existente
myElement.appendChild(newElement);

// Removendo um elemento
myOtherElement.removeChild(myOtherElement.firstChild);

Manipulando atributos do DOM

Os elementos HTML também possuem atributos que podemos acessar e manipular usando o DOM. Podemos obter e definir valores de atributos usando as propriedades getAttribute() e setAttribute().

// Obtendo o valor de um atributo
const myAttribute = myElement.getAttribute('data-my-attribute');

// Definindo o valor de um atributo
myOtherElement.setAttribute('data-my-other-attribute', 'meu valor');

Conclusão

O DOM é uma ferramenta poderosa que os desenvolvedores podem usar para manipular o conteúdo HTML e CSS de uma página da web em tempo real. Com as habilidades básicas que aprendemos neste tutorial, você deve estar bem encaminhado para começar a criar páginas web dinâmicas e interativas.

Tratando erros em JavaScript

O JavaScript é uma linguagem amplamente utilizada em desenvolvimento web, com várias aplicações em front-end e back-end. Como em qualquer outra linguagem, é possível que ocorram erros durante a execução do código, o que pode afetar o desempenho do programa e, em alguns casos, impedir que ele funcione corretamente.

Felizmente, existem várias maneiras de lidar com erros em JavaScript, permitindo que os desenvolvedores criem códigos mais robustos e confiáveis. Nesta postagem, discutiremos as principais técnicas para tratar erros em JavaScript, juntamente com exemplos de código e as melhores práticas para aplicá-las.

Bloco Try-Catch

Uma maneira comum de lidar com erros em JavaScript é usando o bloco try-catch. O bloco try contém o código que pode gerar um erro, enquanto o bloco catch é usado para tratar o erro caso ele ocorra.

Aqui está um exemplo de como usar o bloco try-catch em JavaScript:

try {
    // código que pode gerar um erro
} 
catch (e) {
    // código que trata o erro
}

No exemplo acima, o bloco try contém o código que pode gerar um erro, enquanto o bloco catch é responsável por manipular o erro caso ele ocorra. A variável e contém informações sobre o erro, como o tipo de erro e uma mensagem de erro.

Eventos de erro

Outra maneira de lidar com erros em JavaScript é por meio de eventos. Alguns erros são gerados por eventos, como uma imagem que não foi carregada corretamente. Para lidar com esses tipos de erros, você pode usar eventos específicos do navegador, como onerror.

Veja um exemplo de como usar o evento onerror em JavaScript:

const img = document.createElement('img');
img.onerror = function() {
  // código que trata o erro
}
img.src = 'imagem_que_não_existe.png';

No exemplo acima, criamos um novo elemento img e definimos a propriedade onerror para uma função que será executada caso ocorra um erro ao carregar a imagem. Dentro dessa função, podemos inserir o código que irá lidar com o erro de acordo com as necessidades do nosso programa.

Validações

Além das técnicas acima, é importante lembrar que as validações são uma forma eficaz de prevenir erros em JavaScript. As validações podem ser usadas para verificar se o input do usuário é válido, se uma variável possui o tipo esperado, ou se um objeto possui todas as propriedades necessárias.

Veja um exemplo de validação em JavaScript:

function calculaQuadrado(x) {
  if (typeof x !== 'number') {
    throw new TypeError('O valor fornecido não é um número');
  }
  return x * x;
}

No exemplo acima, criamos uma função calculaQuadrado que recebe um parâmetro x. Antes de realizar o cálculo do quadrado, verificamos se o parâmetro é um número. Se não for, lançamos um erro de tipo usando o comando throw.

Quando evitar o tratamento de erros e usar validações

Embora seja importante tratar erros em JavaScript, existem situações em que pode ser adequado não tratar um erro. Isso pode ocorrer quando um erro é inofensivo ou irrelevante para o funcionamento do programa, ou quando o tratamento de erros pode ter um impacto significativo no desempenho.

Algumas situações em que pode ser aceitável não tratar um erro incluem:

  • Erros que ocorrem em ambientes controlados, como testes automatizados ou ambientes de desenvolvimento;
  • Erros que ocorrem em código que não é crítico para o funcionamento geral do programa;
  • Erros que ocorrem em eventos que você não tem controle, como a interrupção de uma conexão de rede.

Em vez de tratar um erro, outra abordagem pode ser usar validações para prevenir que ele ocorra em primeiro lugar. As validações podem ser usadas para verificar se o input do usuário é válido, se uma variável possui o tipo esperado ou se um objeto possui todas as propriedades necessárias. Dessa forma, é possível reduzir a probabilidade de erros ocorrerem, o que pode levar a um código mais eficiente e confiável.

Por exemplo, ao invés de tratar o erro de uma variável não ser um número dentro de uma função, podemos validar o input da função e garantir que somente números sejam passados como argumento:

function calculaQuadrado(x) {
  if (typeof x !== 'number') {
    throw new TypeError('O valor fornecido não é um número');
  }
  return x * x;
}

Conclusão

Lidar com erros em JavaScript é uma parte importante do processo de desenvolvimento, garantindo que o código seja eficiente e confiável. Neste artigo, discutimos as principais técnicas para tratar erros em JavaScript, incluindo o uso do bloco try-catch, eventos de erro e validações. Também vimos que, em algumas situações, pode ser aceitável não tratar um erro e, em vez disso, usar validações para prevenir que ele ocorra em primeiro lugar. Esperamos que essas informações ajudem você a criar códigos JavaScript mais robustos e confiáveis em seu próximo projeto.

Lendo e renderizando arquivos XML com JavaScript

Olá pessoal, neste artigo demonstrarei como ler e renderizar no seu HTML um arquivo XML, usando JavaScript. Para isso, necessitaremos de um servidor local, como Xamp ou Wamp server, por exemplo. No nosso exemplo, utilizaremos o Xamp.

Vamos começar?

Primeiro, criaremos um arquivo XML de exemplo. No nosso arquivo XML, teremos um catálogo com CDs. Cada CD possui um título e um artista. É importante especificar o tipo de codificação de caracteres no cabeçalho do nosso XML. O tipo de caractere usado nesse exemplo é do conjunto UTF-8.

Representaremos o catálogo com a tag <CATALOG>. Os CDs serão representados com a tag <CD> e teremos três CDs. Cada CD possui duas tags: <TITLE> e <ARTIST>, que possuem o nome do disco e nome do artista, respectivamente.

<?xml version="1.0" encoding="UTF-8"?>
<CATALOG>
    <CD>
        <TITLE>Empire Burlesque</TITLE>
        <ARTIST>Bob Dylan</ARTIST>
    </CD>
    <CD>
        <TITLE>Hide your heart</TITLE>
        <ARTIST>Bonnie Tyler</ARTIST>
    </CD>
    <CD>
        <TITLE>Pavarotti Gala Concert</TITLE>
        <ARTIST>Luciano Pavarotti</ARTIST>
    </CD>
</CATALOG>

Pronto, agora que já temos o nosso arquivo XML, precisamos de um script JavaScript para realizar a leitura e renderizar o nome de cada disco e artista no DOM.

Dentro de um documento HTML, abra uma tag <script> e, dentro de uma estrutura condicional, utilize o XMLHttpRequest para que ocorra a transferência de dados entre o cliente e o servidor. Começaria assim:

<script>
    if (window.XMLHttpRequest){
        xmlhttp = new XMLHttpRequest();
     } else {
        xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
     }
</script>

O ActiveXObject é utilizado para suporte em Internet Explorer, sendo opcional no nosso exemplo.

Precisamos utilizar agora os métodos open() e send(), para abrir e enviar ao servidor/cliente o nosso arquivo XML a ser lido. Utilizaremos o método GET para isso.

if (window.XMLHttpRequest){
    xmlhttp = new XMLHttpRequest();
} else {
    xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.open("GET", "file.xml", false);
xmlhttp.send();

Agora, utilizando o método responseXML, faremos a leitura do documento XML:

document.write("<table border='1'>");

Com nossa tabela criada, precisamos agora capturar a tag XML que contém os atributos título e artista. Como sabemos, essa tag é a CD. Utilizaremos o getElementsByTagName para capturarmos esses valores:

let x = xmlDoc.getElementsByTagName("CD");

Feito isso, criaremos um laço de repetição para percorrer esta tag CD e, assim, imprimir os conteúdos. Utilizaremos o childNodes e o nodeValue para capturar o conteúdos das tags <ARTIST> e <TITLE> do XML:

for (let i = 0; i < x.length; i++){
    document.write("<tr><td>");
    document.write("Artista: " + x[i].getElementsByTagName("ARTIST")[0].childNodes[0].nodeValue);
    document.write("</br>")
    document.write("Disco: " + x[i].getElementsByTagName("TITLE")[0].childNodes[0].nodeValue);
    document.write("</td></tr>");
}

E por fim, fecharemos nossa tag <table>:

document.write("</table>");

O seu resultado deve ser algo parecido com isso:

O código JavaScript completo é este:

<script>
    if (window.XMLHttpRequest){
        xmlhttp = new XMLHttpRequest();
    } else {
        xmlhttp = new ActiveXObject("Microsoft.XMLHTTP");
    }
    xmlhttp.open("GET", "file.xml", false);
    xmlhttp.send();
    xmlDoc = xmlhttp.responseXML;

    document.write("<table border='1'>");
    let x = xmlDoc.getElementsByTagName("CD");
    for (let i = 0; i < x.length; i++){
        document.write("<tr><td>");
        document.write("Artista: " + x[i].getElementsByTagName("ARTIST")[0].childNodes[0].nodeValue);
        document.write("</br>")
        document.write("Disco: " + x[i].getElementsByTagName("TITLE")[0].childNodes[0].nodeValue);
        document.write("</td></tr>");
    }
    document.write("</table>");
</script>

Gostou deste artigo? Comente abaixo!

Como criar eventos ao pressionar CTRL, ALT e SHIFT

Neste post rápido será visto como criar eventos para capturar quando o usuário pressiona CTRL, ALT ou SHIFT na tela do navegador. Aproveitando que isso já está sendo visto, também vamos testar algumas combinações de teclas.

A primeira parte que você precisa fazer é o evento. Você precisa dizer onde que deverá estar o foco na hora que foi apertado o botão, no nosso exemplo usaremos o document pois mais amplo que isso não tem como. Você pode usar o body ou até uma “zona” menor caso prefira.

 

JavaScript

document.addEventListener("keydown", function(event){});

 

JQuery

$(document).bind('keydown', function(event){ });

Note que estamos usando o evento “keydown”, isso é importante pois keypress e keyup não captura as teclas que queremos.


 

Agora vejamos sobre como saber o que foi clicado, você já deve ter tentado o key, keycode e which, mas nada aconteceu. Isso acontece pois precisamos acessar outras propriedades para saber se o CTRL, ALT ou SHIFT foram pressionados. Veja abaixo:

event.ctrlKey // CTRL

event.altKey // ALT

event.shiftKey // SHIFT

Simples assim? Sim, simples assim….

Então se quisermos saber quem foi pressionado, podemos fazer o seguinte:

 

JavaScript

document.addEventListener("keydown", function(event){

    if(event.ctrlKey) {
        console.log('ctrl');
    }

    if(event.altKey) {
        console.log('alt');
    }

    if(event.shiftKey) {
        console.log('shift');
    }
});

 

Para JQuery basta alterar a primeira linha por 

$(document).bind('keydown', function(event){

 

Por último, você pode estar querendo uma combinação, como por exemplo um CTRL + A. Agora que sabemos como pegar o CTRL, ficou fácil

document.addEventListener("keydown", function(event){

    if(event.ctrlKey && event.key == "a") {
        console.log('ctrl + a');
    }

});

 

É isso ai, espero que com esse post eu tenha ajudado outros que tiveram o mesmo problema para descobrir como criar estes eventos que combinam pressionar várias teclas. Até a próxima

Você sabe o que é Docker?

Neste artigo, imostrarei o que é Docker e os conceitos de containers.

O Docker é uma plataforma para criar, compartilhar e executar aplicativos com containers. Quando você utiliza containers para implantar os seus aplicativos, você utiliza a containerização.

Os containers são:

  • Flexíveis: Até as aplicações mais complexas podem ser containers;
  • Leves: os containers aproveitam e compartilham o kernel do host, tornando-os muito mais eficientes em termos de recursos do sistema do que as máquinas virtuais;
  • Portáteis: você pode criá-los localmente, implantar na nuvem e executar em qualquer lugar;
  • Fraco acoplamento: Containers são auto-suficientes e encapsulados, isto é, permitem substituir ou atualizar um sem atrapalhar outros;
  • Escaláveis: Você pode distribuir automaticamente réplicas de containers por um datacenter;
  • São seguros: aplicam restrições e isolamentos agressivos.

Mas o que é um container?

Bsicamente, não passa de um processo que está em execução, com o porém de ser isolado do host e de outros containers. Cada container interage com seu sistema de arquivos privado, sendo esse um sistema fornecido por uma imagem do Docker. Essa imagem incluirá tudo que for necessário para executar o aplicativo.

Ele difere de uma máquina virtual pois uma VM executa um SO completo, com acesso virtual a recursos do host. Já o Docker é executado nativamente no Linux e compartilha o kernel do Host com outros containers, executando um processo discreto, tornando-o leve.

Vantagens:

Com o Docker, temos uma alta portabilidade e podemos escalar nossos apps entre nuvens e datacenters, garantindo que esses aplicativos sejam executados da mesma maneira em qualquer lugar.

Orquestradores:

São ferramentas para gerenciar, dimensionar e manter aplicativos em containers. Os exemplos mais comuns são Kubernetes e Docker Swarm.

Continue lendo “Você sabe o que é Docker?”

Phaser.js #4 – Criando jogo Parte 3

Nosso jogo já está tomando forma, pessoal! Para continuarmos, recomendo a leitura da Parte 2 desta série de artigos!

Adicionando o jogador:

Já temos nossas plataformas, mas ninguém para percorrê-las. Temos que resolver isso neste momento.

Criaremos uma variável chamada player e adicionaremos o seguinte código à função create().

player = this.physics.add.sprite(100, 450, 'dude');

player.setBounce(0.2);
player.setCollideWorldBounds(true);

this.anims.create({
    key: 'left',
    frames: this.anims.generateFrameNumbers('dude', { start: 0, end: 3 }),
    frameRate: 10,
    repeat: -1
});

this.anims.create({
    key: 'turn',
    frames: [ { key: 'dude', frame: 4 } ],
    frameRate: 20
});

this.anims.create({
    key: 'right',
    frames: this.anims.generateFrameNumbers('dude', { start: 5, end: 8 }),
    frameRate: 10,
    repeat: -1
});

Você pode conferir isso no seu arquivo part5.html.

Há duas coisas acontecendo neste código: a criação de um Sprite de física e a criação das animações que ele irá usar.

Physics Sprite:

A primeira parte do código cria o sprite:

player = this.physics.add.sprite(100, 450, 'dude');

player.setBounce(0.2);
player.setCollideWorldBounds(true);

Isso cria um novo sprite chamado player, posicionado a 100×450 pixels da parte inferior do jogo. O sprite foi criado através da Physics Game Object Factory, ou seja, ele é um corpo de Física Dinâmica por padrão.

Depois de criar o sprite, ele recebe um valor de rejeição de 0,2. Mas o que isso significa?

Isso significa que, quando ele aterrissar de um salto, ele saltará levemente. O sprite é definido para colidir com os limites do jogo. Os limites, por padrão, estão do lado de fora da dimensão do jogo. Como o jogo foi definido em 800×600, o jogador não poderá avançar para fora desta área, impedindo o player de correr pelas bordas da tela ou pular pela parte superior.

Animando:

Se você olhar para a função preload, verá que o “dude” foi carregado como uma folha de sprites, não como uma imagem. Isso acontece porque ele possui vários quadros de animação.

Existem 9 quadros de animação dentro desta página de sprites: 4 para a esquerda, uma para a frente e 4 para a direita. O Phaser suporta sprites invertidos, para econimizar quadros de animação.

Definimos duas animações, “left” e “right”. Aqui está a animação “left”:

this.anims.create({
    key: 'left',: 'left',
    frames: this.anims.generateFrameNumbers('dude', {
        start: 0,
        end: 3
    }),
    frameRate: 10,
    repeat: -1
});

A animação “left” usa os frames 0, 1, 2 e 3 e é executada a 10 frames por segundo. O valor “repeat -1” informa que há repetição de animação.

Esse é o nosso ciclo de execução padrão e o repetimos para correr na direção oposta, usando a tecla “right” e a final para “turn”.

Velocidade do player:

O Phaser tem suporte para uma variedade de sistemas de física diferentes, cada um atuando em alguma cena do Phaser. Quando um Sprite de Física é criado, ele recebe uma propriedade body, que é uma referência ao seu corpo. Isso representa o sprite como um corpo físico no mecanismo de física do Phaser Arcade. O objeto body tem muitas propriedades e métodos. Por exemplo, para simular os efeitos da gravidade de um sprite, podemos adicionar o seguinte:

player.body.setGravityY(300);

Isso tornará o objeto mais pesado e mais rapidamente ele cairá. Verifique isso no seu código executando o part5.html, e verá que o player irá cair sem parar, ignorando completamente o terreno criado anteriormente:

Isso acontece pois ainda não estamos testando colisões entre o solo e o player. O Phaser já sabe que nosso solo e plataformas são corpos estáticos. Se tivéssemos os criado de forma dinâmica, o jogador entraria em contato com elas, pararia por um momento e o jogo colapsaria. Um sprite de solo dinâmico é um objeto físico em movimento e, quando o jogador o atinge, a força resultante da colisão também é aplicada ao solo, levando os dois corpos a trocarem suas velocidades, fazendo o solo começar a cair também. Para permitir a colisão com as plataformas, podemos criar um objeto Collider. Este objeto monitora dois objetos de física (que podem incluir grupos) e verifica as colisões ou sobreposições entre eles:

this.physics.add.collider(player, platforms);

Veja a mágica acontecer:

O Collider testa a colisão e realiza a separação entre dois objetos. Estamos fornecendo um sprite do player e o grupo de plataformar. Precisamos ter colisões com todas as plataformas, então precisamos fazer esta colisão com o grupo da plataforma. O resultado disso é uma plataforma firme que não entra em colapso.

Está gostando do jogo? Curtindo os seus resultados? Comente abaixo e aguarde o próximo artigo 🙂

Phaser.js #3 – Criando jogo Parte 2

Olá pessoal! Dando sequência ao tutorial de Phaser.js na prática, hoje iremos abordar a inserção de assets no nosso jogo. Recomendo fortemente uma leitura da nossa Parte 1 para seguirmos adiante.

Continuando…

Bom, já temos o nosso céu criado. Podemos usar o setOrigin para alterar a exibição da imagem. Veja como fazer isso:

this.add.image(0, 0, 'sky').setOrigin(0, 0);

Isso redefiniria a posição do nosso desenho (céu) no canto superior esquerdo da tela. No Phaser 3 existem as propriedades originX e originY.

A ordem de exibição dos objetos do jogo corresponde à ordem que você os cria. Agora, iremos colocar um sprite de estrelas que ficará acima do nosso plano de fundo, ou seja, precisamos garantir que ele seja adicionado depois da imagem do céu.

function create() {
    this.add.image(400, 300, 'sky');
    this.add.image(400, 300, 'star');
}

A sua saída deve ser assim:

Se a imagem da estrela for inserida antes, a imagem do céu a encobrirá.

Por baixo dos panos, this.add.image cria um objeto de jogo de imagem e o adiciona a lista de exibição das cenas. Essa lista é onde ficam os objetos do seu jogo. Cuidado para não adicionar as imagens fora da tela. Você não as verá visualmente, mas ainda existirão.

A cena em si não possui tamanho fixo e se estende em todas as direções, mas a câmera controla sua visualização na cena. Agora, criaremos elementos da cena, adicionando uma imagem de fundo e também, algumas plataformas, utilizando a função create:

var platforms;

function create ()
{
    this.add.image(400, 300, 'sky');

    platforms = this.physics.add.staticGroup();

    platforms.create(400, 568, 'ground').setScale(2).refreshBody();

    platforms.create(600, 400, 'ground');
    platforms.create(50, 250, 'ground');
    platforms.create(750, 220, 'ground');
}

Olhando o código, você deve ter percebido uma chamada this.physics. Estamos utilizando o sistema Arcade Physics do Phaser. Precisamos adicioná-lo ao Game Config para informar ao Phaser. Aqui está a configuração:

var config = {
    type: Phaser.AUTO,
    width: 800,
    height: 600,
    physics: {
        default: 'arcade',
        arcade: {
            gravity: { y: 300 },
            debug: false
        }
    },
    scene: {
        preload: preload,
        create: create,
        update: update
    }
};

A sua saída deve ficar algo parecido com isso:

Observação:

Comente a inserção da estrela no seu código.

Você pode verificar o seu código olhando o arquivo part4.html.

Ok, já temos um cenário e algumas plataformas. Mas como essas plataformas funcionam?

platforms = this.physics.add.staticGroup();

Criamos um grupo de física e atribuímos à variável platforms. Na Arcade Physics existem dois tipos de corpos físicos: Dinâmico e Estático. O corpo dinâmico pode se mover através de aceleração ou velocidade, podendo saltar e colidir com outros objetos. Um corpo estático simplesmente possui posição e tamanho. Quando algo colide com ele, ele não se move. É perfeito para solo e plataformas.

O que é um grupo?

São maneiras de agrupar objetos e controlá-los como uma única unidade. Você pode verificar colisões entre grupos e objetos de jogo. Eles são capazes de criar seus próprios objetos de jogo por meio de funções auxiliares úteis. Em um grupo criado para a física, os filhos automaticamente herdarão as habilidades de física, poupando trabalho.

platforms.create(400, 568, 'ground').setScale(2).refreshBody();

platforms.create(600, 400, 'ground');
platforms.create(50, 250, 'ground');
platforms.create(750, 220, 'ground');

Este código cria uma imagem “ground”: um retângulo verde simples, que servirá de plataforma.

Para fazer a plataforma abranger toda a largura do nosso jogo, utilizamos a função setScale(2), que dobrará em x2 o tamanho original. A chamada refreshBody() é necessária pois escalamos um corpo estático, portanto, precisamos fazer alterações na física do jogo.

O processo de criação das outras plataformas é exatamente o mesmo, apenas não precisamos escalar a imagem.

Você pode ler o artigo original em inglês neste link: http://phaser.io/tutorials/making-your-first-phaser-3-game/part2

Está gostando desta sequência? Comente abaixo!