Meu cartaz Fractalizado!

Que tal construir um cartaz que tenha o formato de um Fractal? Acredito que em primeiro lugar você deve estar se perguntando o que é um Fractal?! Um Fractal pode ser entendido como uma construção geométrica que possui repetições em sua construção (se quiser saber mais acesse: https://teoriadacomplexidade.com.br/geometria-fractal/). Alguns exemplos de Fractais:

Como podemos observar acima, cada uma das figuras é obtida a partir de repetições e essas repetições podem ser construídas por meio de algoritmos matemáticos e também por programações. Hoje como nosso foco é construir um cartaz (que é 2D) com o formato de um Fractal, iremos utilizar o Inkscape (você pode obter ele gratuitamente em: https://inkscape.org/pt-br/) e usar a opção L-System em Extensões/Renderizar (L-Sistema em português e que você pode saber mais acessando esse link: http://www.cin.ufpe.br/~if114/Monografias/L-systems/Gramaticas/node13.html):

Como podemos  ver nas opções acima, temos os campos de preenchimento Axioma e Régua que funcionam como as leis de formação desse Fractal. Os demais campos se referem a quantidade de repetições, tamanho de lado e valor de ângulo direito/esquerdo.Se você clicar em ajuda (aba ao lado) irá entender o que cada simbologia significa.
Para entender melhor, vamos fazer passo-a passo a construção desse Fractal. Em primeiro lugar, observando a regra de construção básica que é a Régua, o código "F=F-F++F-F" pode ser entendido abaixo:

Observe que com esse processo você definiu a construção básica do seu Fractal e agora vai precisar de uma lei de construção para dar o formato da poligonal fechada, que é utilizando a opção Axioma com o seguinte código: "F++F++F". Basicamente esse código pede para repetir a construção da Régua (que é definida como F) três vezes com um ângulo no sentido horário de 120 graus (++) entre cada um deles. Apesar de em um primeiro momento toda essa construção parecer ser complicada, tudo é muito lógico e simples de ser entendido. Que tal aprimorar essa construção? Construir outros Fractais? Ou ainda fazer construções bem malucas? Tudo é válido para dar uma estilizada no seu cartaz! Deixe nos comentários abaixo suas descobertas e invenções. Até a próxima.

Movendo sólidos no OpenScad

Que tal construir uma mesa no OpenScad para posterior impressão? Essa será nossa motivação inicial para aprender a como movimentar sólidos no plano geométrico do OpenScad e para entendermos um nível inicial de programação com o uso do for (é um loop de programação que podemos traduzir como "enquanto").
Para começo de conversa, vamos modelar a mesa de cabeça para baixo de modo a facilitar a sua impressão 3D (então não se assuste com o surgimento de mesas ao contrário, afinal na impressão 3D ter uma boa base de aderência é fundamental).

Para construir o tablado usaremos um paralelepípedo fino que será definido pela linha de comando "cube" com valores de dimensão (40,40,5) e os pés da mesa serão construídos com quatro cilindros definidos pela linha de comando "cylinder" com valores de dimensão (30,2,2) e um número de faces igual a 100 (lembrando que quanto maior o valor, mais o cilindro será arredondado). Porém, temos um problema: como posicionar cada um desses sólidos no plano geométrico? A solução mais simples é o uso do "translate" (podemos entender como translação, ou posicionamento em valores de X,Y e Z):

cube([40,40,5], center=true); translate([18,18,0]) cylinder(30,2,2,$fn=100); translate([-18,18,0]) cylinder(30,2,2,$fn=100); translate([-18,-18,0]) cylinder(30,2,2,$fn=100); translate([18,-18,0]) cylinder(30,2,2,$fn=100);

Como podemos observar no código acima, o "translate" é usado antes do sólido construído e o posiciona pegando o ponto central do mesmo, por isso, ao invés de utilizar o ponto em X=20, usou-se o X=18, pois o cilindro possui raio 2, que é exatamente o seu centro. No caso do "cube" foi usado um "center=true" que nada mais é do que um "translate" no ponto zero de todos os eixos (0,0,0).
Existe uma segunda possibilidade de uso do "translate", mas ao invés de repetir o comando quatro vezes, é possível fazer o uso do loop (repetição) "for" e economizar na programação, como podemos ver abaixo:

cube([40,40,5], center=true); for (i=[0:3]){ rotate ([0,0,i*90])translate([18,18,0]) cylinder(30,2,2,$fn=100); }

Basicamente, temos um "enquanto" (for) que tem valores de i variando de 0 a 3 e que serão multiplicados dentro de um "rotate" no eixo x com base no valor 90, ou seja, teremos as posições, 0, 90, 180 e 270, que são os quatro cantos da mesa. Confira abaixo uma figura exemplificando isso:

Com essas duas propostas de movimentos baseadas no "translate" você poderá construir objetos mais complexos. Agora é com você. Que outras construções são possíveis de serem realizadas no OpenScad? Deixe nos comentários os códigos e fotos das suas construções e até a próxima.

A Geometria Analítica no OpenScad

Modelar no OpenScad é diferente de modelar usando o TinkerCad. Além de precisar usar comandos ao invés de manipulação de objetos, existe a necessidade de saber alguns conceitos da Geometria Analítica (ao invés de trabalhar com o comprimentos das formas usando o sistema de medidas, teremos o uso de coordenadas cartesianas). E esse é nosso objetivo hoje: dar os primeiros passos no mundo do OpenScad que, para produção de peças com muito detalhamento, é superior a diversos outros CADs disponíveis.
A primeira coisa é entender o que é um plano em R³ (plano com três dimensões: X, Y  e Z), cuja representação abaixo, mostra cada um dos eixos com seus respectivos pontos positivos e negativos, todos saindo da origem com valor zero (para saber mais, consulte: https://mundoeducacao.bol.uol.com.br/matematica/dimensoes-espaco.htm).

Para construir um cubo de lado 20 no OpenScad temos algumas formas de escrever o código. A primeira delas é apontando os valores dos lados do cubo em X, Y e Z (copie o código abaixo, cole ele no OpenScad e aperte F5 para gerar a forma geométrica):

cube([20,20,20]);

Note que, por ser um cubo, obrigatoriamente todos os lados tem de ser idênticos (caso tenha valores diferenciados nos eixos teremos um paralelepípedo, experimente isso!), por isso podemos resumir esse código como:

cube(20);

Para gerar um esfera de raio 3 podemos usar o código abaixo, onde o valor de r é o valor de raio e o valor $fn é o valor do número de faces de modo que valores mais altos deixam a esfera com uma aparência mais circular e valores menores fica mais poligonal:

sphere(r = 3, $fn=10);

É possível construir um cilindro de altura 40 e raio 20 (note que no cilindro temos dois raios, que são os dois valores 20 iguais. O que aconteceria caso os valores fosse diferentes?) com o seguinte comando:

cylinder(40,20,20,$fn=100);

Quando observamos as construções acima, notamos como o entendimento dos pontos no plano tridimensional faz toda a diferença para o correto uso dos valores nos comandos do OpenScad. E isso é a base para aprendizagem da Geometria Analítica. Se você quiser ver outros exemplos  prontos no OpenScad, clique em File/Examples e poderá usar diversas construções prontas e fazer alterações nelas para ir entendendo as especificidades desse software. Curtiu? Deixe nos comentários suas descobertas e produções. Até a próxima!

RPG Battle: como construir sua própria batalha de RPG.

Conforme o post anterior (https://vemfazermatematicaegames.blogspot.com/2018/11/a-matematica-em-uma-batalha-de-rpg.html) entendemos um pouco sobre como funciona a Matemática de uma batalha num RPG (lembrando que  é um exemplo construído, não regra geral). E você deve ter sentido vontade de alterar os tipos de personagens, os valores e tipos dos poderes ou até mesmo a fórmula que faz o cálculo da batalha. Vamos juntos entender a programação para poder fazer novas versões dele?

Para alterar os nomes ou quantidade de personagens aliados e oponentes temos que modificar os botões da tela inicial, seja alterando o nome ou acrescentando novos botões. No caso de acréscimo de personagens aliados é necessário alterar a quantidade de armazenamento de valores na Screen1, seguindo o padrão já existente (destacado em verde):

Em seguida, na screen de trabalho, deve ser alterado as estruturas listadas abaixo, cuja função é basicamente selecionar e ocultar quais botões de oponentes ficarão disponíveis onde pode ser necessário incluir novas variáveis globais que remetam as listas de poderes (iremos ver isso em seguida). Não esqueça de modificar também a entrada de programação responsável pelo fim de jogo (o procedimento Morto), pois ele desabilita todos os botões que não são necessários ao final da batalha:

Para alterar valores de poderes ou adicionar novos é necessário modificar diretamente na lista de valores aonde cada variável global está ligada a uma lista específica (em vermelho). Portanto, para alterar valores basta digitar novos valores e se quiser aumentar a quantidade de poderes, apenas clique na engrenagem azul e acrescente a quantidade desejada. Lembrando que se for aumentado a lista, deve ser colocado o novo número de itens na programação do contador (em verde). Também tenha atenção que essa programação foi construída para comparar listas com iguais quantidades, por isso se resolver fazer personagens com quantidade de poderes diferenciados, essa programação não serve e será necessário fazer uma grande alteração estrutural: 

Agora se você quer mudar a fórmula do calculo de batalha ou até mesmo os valores obtidos via dado D20, vai ser necessário modificar as estrutura de procedimento Dado Rolado e Calcular Batalha, como podemos ver na imagem abaixo:

Resumidamente, no procedimento Dado Rolado é calculado um valor aleatório entre 1 e 20 (dado D20) e são dadas duas situações: uma em que o dado é maior ou igual a 10 que beneficia o jogador (mais 0,5 para o player e -0,5 para o adversário) com um fator no calculo de batalha e a outra situação menor do que 10 que ocorre exatamente o contrário. Já no procedimento Calcular Batalha é feito o cálculo entre os valores tabelados de poderes do personagem contra o adversário em função do valor do dado tirado (com o fator acima descrito incluso) e resulta em duas situações: a primeira aonde o personagem vence (valor acima de zero) e a outra onde ele perde (valor abaixo de zero) em uma subtração direta. No caso da programação aqui apresentada, para cada uma das situações, é descontado o valor da vida apenas do perdedor e exite um operador lógico que aciona caso o valor da vida seja menor do que zero, trocando para o valor morto.
E por fim, temos o cálculo de Experiência usa a estrutura operacional que é mostrada abaixo e que preza por quanto mais batalhas, mais experiência adquirida:

É isso! Perceba que podem ser feitas muitas alterações na estrutura proposta: desde aumento da quantidade de valores de poderes ou quantidade de inimigos até a mudança efetiva do cálculo de batalha. Agora é sua vez. Faça a sua versão de um RPB Battle e deixe nos comentários suas descobertas e produções. Até mais!

A Matemática em um game de pegar bolinhas.

Hoje iremos criar um mini-game de caçar bolinhas, o Catchgame (disponível em: ai2.appinventor.mit.edu/?galleryId=5294338782396416), para ser jogado na tela do seu smartphone e observar os conceitos matemáticos envolvidos. Vamos lá?

A ideia do Catchgame é você coletar todas as bolinhas pretas da tela com a bolinha azul (maior), mas sem esbarrar nas vermelhas, pois o jogo reinicia. Cada vez que você coleta as 14 bolinhas pretas você avança um nível (no total são 13 níveis para vencer o game). A cada nível é diminuído meio segundo do total inicial, tornando-se um verdadeiro desafio os últimos níveis, sem contar que as bolinhas sempre são dispostas de modo aleatório. 

Para inserir o elemento bolinha você deve usar a opção bola dentro de uma pintura, que traça os limites de atuação dessa bola, que ficam no menu de Desenho e Animação (destacados em vermelho). A programação apontada com a flecha azul é responsável por fazer a bolinha Catador (bolinha azul maior) seguir o que o seu dedo toca na tela em posições de X e Y. Olha só o conceito de plano cartesiano aparecendo por aqui.

Indicado com a flecha verde está a programação responsável por fazer a contagem de pontos a cada vez que a bolinha Catador colidir com uma outra bolinha, até o valor máximo de 14 responsável por iniciar o próximo nível. Mas e quando colidir com a bolinha vermelha? Temos destacado com a flecha laranja as três programações responsáveis por isso e que reinicializam o nível.  

Mas e como gerar o posicionamento aleatório das bolinhas na tela? A programação abaixo explica isso. Selecionado em vermelho está a lista de bolinhas a serem distribuídas pela tela, em azul a lei de formação com valores aleatórios entre 30 e o valor máximo da tela de Largura e Altura (destacado em verde) menos os valores 40 e 200 respectivamente, para X e Y e para cada bolinha da lista acima. A flecha em laranja é uma garantia para que as bolinhas sempre estejam visíveis na tela, pois cada vez que uma é catada no game, ela deixa de aparecer até começar novamente um novo nível. Note que para as bolinhas vermelhas será preciso construir uma nova lista e para a bolinha Catador sempre será posicionada em X e Y iguais a zero, que são os valores fora do range randômico das demais, evitando as colisões sem o game estar devidamente iniciado. Aqui o entendimento de como funciona os pontos X e Y em um plano cartesiano se torna essencial.

Finalizando, temos algumas outras funcionalidade que já foram vistas em outras atividades aqui listadas no blog, tais como o uso do TinyDB para elaborar um placar (https://vemfazermatematicaegames.blogspot.com/2018/06/appinventor-2-construindo-um-placar.html) e a construção de um temporizador (https://vemfazermatematicaegames.blogspot.com/2019/01/vamos-desafiar.html). Agora é a sua vez. Como podemos melhorar esse game? Que tal construir fases mais desafiadoras com a possibilidade das bolinhas vermelhas ficarem mudando de local em uma mesma tentativa ou ao tocar as bolinhas vermelhas acabar o game, dentre outras possibilidades. Construa o seu CatchGame e depois venha comentar como foi sua construção e suas percepções sobre o que aprendeu e desenvolveu. Até a próxima!

Construindo um classificador de triângulos.

Que tal o desafio de construir um classificador de triângulos? A principio não parece ser tão complicado, mas e que tal que ele seja randômico na construção do tamanho de lado e de ângulos? Agora sim temos um grande desafio e que vai precisar de bastante Matemática para ser solucionado. No projeto Classificador de Triângulos (https://scratch.mit.edu/projects/289327362/) encontramos a solução para esse desafio.

Vamos começar pela forma de construção de um triângulo qualquer que é a pior situação apresentada. Ao construir um lado, um ângulo e outro lado (esse lado vai funcionar com valores maiores para ser um hipotenusa e dar condição de existência para o triângulo) todos randômicos, temos o mínimo necessário para dar forma ao tipo de triângulo que você quer. 

O problema reside em como fechar esse triângulo! Temos que ter a construção de um segundo ângulo que feche o triângulo, e por isso usamos a função seno (em verde), que com os valores dos lados oposto e da hipotenusa (o segundo lado foi construído propositalmente maior) saberemos o valor do ângulo com exatidão. Mas e a construção do terceiro lado? Simples, só ligar a construção de uma reta até o valor inicial em X e Y do primeiro lado.

Essa foi a construção para o caso do triângulo do tipo escaleno, como dito anteriormente o pior caso de construção. Para o caso do equilátero, teremos a alteração dos valores dos dois primeiros lados sendo exatamente iguais. Para o caso do equilátero, basta fixar o ângulo em 60 graus com valor de 3 lados idênticos (mas construídos com um valor randômico) e podemos usar um aponte para um valor randômico de ângulo para dar diversos posicionamentos ao triângulo equilátero (os demais não necessitam pois tem um valor randômico de construção de ângulo).

Por fim, basta colocar cada um dos tipos de triângulos baseados em classificação de lados em Mais Blocos e colocar dentro da programação inicial acoplando um placar. Que tal agora, construir um classificador de triângulos com base em ângulos (agudo, reto e obtuso)? Ou ainda algum outro tipo de classificação geométrica que não fique restrita apenas a triângulos? Que modificações são necessárias? Deixe nos comentários as suas novas construções e até a próxima!

MathMaker: o seu aplicativo de Matemática para aprender ...

Qualquer conceito matemático!
Se der uma rápida procurada na rede você irá encontrar diversos aplicativos matemáticos, mas, porque procurar um se você pode fazer o seu? Essa é a proposta do MathMaker, o aplicativo que vai ajudar você e seus amigos a aprender Matemática produzindo ele mesmo!
Em primeiro lugar, é importante escolher a temática (conceito, problemas) do game. No caso do MathMaker: Porcentagens (ai2.appinventor.mit.edu/?galleryId=4757974009643008) vai ser apresentado o conceito de porcentagem, alguns exemplos e um game para calcular porcentagens.

As primeiras telas trabalham diretamente com a conceituação e a apresentação de um problema contextualizado na forma de telas que foram produzidas em um editor de imagens, por isso não há grandes desafios, a não ser linkar os botões existentes.

Agora vem a tela (screen) que possui mais desafios de todas as outras: a "Praticando". Nela estão todos os cálculos e opções do game sobre porcentagens. Como podemos ver na imagem abaixo, está destacado com uma flecha (vermelha) os comandos responsáveis por dizer que se a pontuação ficou acima de 10 (que faz o usuário vencer o game) e em amarelo o processo de geração do número aleatório e de percentual aleatório a serem calculados, bem como o processo de cálculo do percentual (ele vai ser comparado com a resposta dada pelo usuário e irá verificar se é verdade ou falsa) e a atualização dos valores na tela. Falando especificamente do calculo percentual, não é algo muito complexo, já que para obter esse valor sempre será o número vezes o percentual divididos por 100 (fração razão 100). Apenas atente-se que foi usado o comando arredondar para ele não destoar dos demais resultados gerados de valores inteiros aleatórios.

O grande desafio ao construir esse aplicativo foi como criar botões de alternativas que mudassem de posição e que as respostas pudessem ser randômicas. Isso foi resolvido (mostrado na imagem abaixo) com a criação da variável global Botão que irá possuir o valor sorteado de 1 a 4 (destacado em vermelho) e, de acordo com o valor (em amarelo), é a posição da resposta correta (obtendo-se o valor calculado acima) e os demais são valores aleatórios entre 1 e 1000.
Ao lado temos que cada botão ao ser clicado faz o teste (em amarelo) verificando se o valor da variável Botão é a que foi sorteada (a exemplo, se Botão vale 1 o botão 2 é o correto e, assim por diante). Caso afirmativo, temos a resposta correta, adicionando-se um valor ao placar (1), atualizando o valor na tela e em seguida reiniciando o processo com um novo calculo percentual. Caso negativo, temos que é a resposta errada, subtrai-se um valor do placar (0,5) e o atualiza na tela e, mantem-se os mesmos valores na tela.

Com isso conseguiu-se estruturar um aplicativo de Matemática que explicou o conceito do que é uma porcentagem, um exemplo e um problema relacionados e aplicou-se um game de cálculos percentuais com placar (gamificação). E isso pode ser aplicado a outros conceitos matemáticos. Que tal testar? Mãos a obra e deixe nos comentários os links dos aplicativos que conseguiu construir. Até a próxima!