hoje a tarde fiz o primeiro teste de animação com o Kinect e Unity 3D ( http://unity3d.com/).

Primeiro vamos ao vídeo:

Primeiro instalei os drivers do Kinect (http://www.brekel.com/?page_id=170).

Depois utilizei esse projeto (https://github.com/OpenNI/UnityWrapper) que integra o Unity com as dll’s do Kinect e tcharam! \o/

O objetivo de usar o Kinect é animar personagens de forma bem simples e barata.

Já o Unity 3D é uma engine um framework uma ferramenta completa de desenvolvimento de games!

Em breve, mais notícias

o/

Oi gente, tudo blz? =D

Depois de muito tempo sem postar, volto hoje com um post contando os motivos da minha escolha pelo PS3 em vez do XBox 360, ou o Wii ou mesmo o meu querido PC.

Antes de comprar meu PS3 (em janeiro desse ano), pesquisei muito, vi vídeos, li artigos, pensei, pesquisei novamente, pensei mais um pouquinho e só então decidi! =D

Lembrando que esse são os MEUS motivos para escolher o PS3, o que não significa que ele é o melhor console dessa geração! Ele é sim o melhor console PARA MIM! O XBox 360 pode ser o melhor console para você, o Wii o melhor para o seu filho, o PC o melhor para o seu primo, e por ai vai. Cada plataforma (consoles, pc e portáteis) pode ser a melhor opção pra cada pessoa, saiba escolher a melhor baseado no seu gosto e nas suas necessidades. Por isso que acho que essa guerra entre sonystas e caixistas é ridícula!

Comecei a fazer esse post e percebi que não ia terminar nem tão cedo. Então, resolvi quebrá-lo em algumas partes.

Vamos então aos primeiros motivos…

1º – Porque um console?

Antes de decidir sobre o PS3, tive que decidir se mudaria para um console ou continuaria jogando no PC.

O grande problema de ser um gamer de PC são as “constantes” atualizações que você precisa fazer no seu hardware (principalmente placa de vídeo) para poder jogar os lançamentos. Isso é um problema pelo menos pra mim que não tenho dinheiro sobrando!

Fazendo algumas contas, vi que a longo prazo, um console era a melhor opção, porque não exigia upgrades, e duraria vários anos (vide a longevidade do Ps2).

Então, decidi que iria comprar um console e parar de jogar no PC. Quando decidi isso, coincidiu com uma época que precisava muito de um notebook. Então, resolvi vender meu desktop, comprar um notebook memória e processamento suficientes sem me preocupar com placa gráfica. Ou seja, compraria um notebook mais modesto, que atendesse todas as minhas necessidades computacionais, e deixaria pra investir em um console (ainda não tinha certeza de qual). E foi isso o que fiz! Escolhi um dual core de 3GB de RAM e fiquei feliz da vida =D.

2º – Porque não um Wii?

Agora começava minha busca pelo console da nova geração!

Sempre gostei mais da diversão do que dos gráficos nos jogos, então o Wii (com gráficos inferiores) seria uma ótima opção para mim. Ainda mais com o Wiimote, o controle revolucionario com sensor de movimentos que a grande Nintendo inventou!

O trunfo do Wii eram seus jogos casuais aliados ao seu controle bem intuitivo. Mais intuitivo pra jogar tenis que simular o movimento da raquete, só se você tiver uma raquete! Opa, mas você pode encaixar uma raquete no seu Wiimote!!! Também pode usar outros acessórios incluindo pistolas, volantes e até sabres de luz! =D

Só que o trunfo foi também o problema do Wii. Que ganhou muitos jogos casuais, e poucos jogos mais hardcore. Também achei o Wii ótimo para jogar entre amigos, é realmente muito divertido! Mas para jogar em casa achei que eu iria cansar rápido.

Outro problema foi o Wiimote. Ué? Mas o Wiimote não era a revolução do Wii???

O problema é que a Nintendo vendeu o Wiimote como muito mais do que realmente era. O sensor de movimentos tem pouquissima precisão. E em vez de fazer o movimento de uma raquete de tenis, você podia simplesmente dar uma chacoalhada qualquer no controle que seu personagem iria fazer o mesmo movimento. Também foi muito decepcionante ver que meus socos no ar não eram seguidos pelo pergonagem no jogo de boxe. =/

Então, com o fator diversão bem reduzido (pra mim), exclui o Wii das minhas opções! Sobrando apenas o PS3 e o XBox 360.

3º – A questão dos jogos piratas

Antes de decidir que mudaria para os consoles, achava o XBox 360 a melhor opção exatamente porque permitia a utilização de jogos piratas. Vamos falar sério! Os preços dos jogos originais no Brasil são altíssimos! Com os impostos que o governo cobra, estão praticamente incentivando a pirataria! Mas isso não vem ao caso aqui, o fato é que eu iria escolher o XBox 360, mas ai veio a onda de banimento…

Essa onda de banimento no XBox 360 é algo bem polêmico. Pode-se dizer que a Microsoft sempre permitiu a pirataria no XBox 360. Afinal ela sempre soube da pirataria, mas nunca fez nada. Não fez nada porque é boazinha? Não! A Microsoft fez isso como estratégia para popularizar seu console. E depois, quando muita gente já tinha o XBox 360, ela começou a banir os usuários com o console destravado da Live (rede online do XBox 360). Li até que poderia limitar algumas funções do HD do console. A Microsoft tinha todo o direito legal de banir essa galera, e poderia ter banido desde o começo, mas o fez depois que conseguiu popularizar seu console. E ainda pior, fazia ondas de banimentos dias após lançamentos de grandes jogos (como Modern Warfare 2), ou seja, depois que muita gente comprava consoles especialmente para jogar esses lançamentos, a Microsoft fazia uma onda de banimento.

Novamente digo que a Microsoft tinha todo o direito legal de fazer isso. Mas mostra uma falta de respeito com seus consumidores (de consoles). Diferente da Sony, que foi justa que sempre lutando contra a pirataria no Ps3. Uma política coerente, mesmo que rigorosa, é um sinal de respeito ao consumidor.

E com essa história de banimentos decidi que iria partir para jogos originais. Mas não são muito caros?

Jogos originais são caros sim. Mas nas minhas pesquisas, li um artigo (não lembro qual) que abriu minha cabeça. Resumindo, ele dizia: “É melhor ter poucos jogos caros que você os aproveita melhor e dá mais valor a eles, do que ter vários jogos piratas que muitas vezes você não tem tempo para terminá-los e alguns você nem joga”. Percebi que isso se encaixava perfeitamente no meu caso. Principalmente porque eu teria pouco tempo livre (devido ao mestrado e trabalho) para jogar, e que não adiantaria ter um monte de jogos piratas se não teria tempo para jogá-los.

Agora pensando apenas em jogos originais (que possuem praticamente o mesmo preço no PS3 e no XBox 360), comecei a comparar os 2 consoles. E veio o principal diferencial PRA MIM entre os dois consoles…

4º – Os jogos exclusivos

Se tem uma coisa que vende console, são os jogos exclusivos! Também conhecidos como “killer apps”. Que no caso dos consoles, são aqueles jogos exclusivos que fazem o jogador optar por uma plataforma ou outra.

Fiz uma pesquisa dos jogos exclusivos de cada console que EU gostaria muito de jogar:

Exclusivos do PS3:

• Metal Gear Solid 4 – Esse era o jogo que mais queria jogar. Principalmente porque acompanho a série desde o primeiro MGS lá do primeiro Playstation.
• Uncharted 1 e 2 – Vou apenas indicar este vídeo que vi na época e achei fodaralhaço! Não preciso falar mais nada né?
• God of War 1, 2 e 3 – Nunca joguei nenhum God of War, mas só ouço falar bem e vejos ótimos vídeos com batalhas épicas contra deuses gigantescos, mortes violentamente lindas, e história sensacional! =D
• Heavy Rain – Pelo que lí, seria uma evolução do jogo “Indigo Profecy” que achei sensacional! Um filme jogavel!

Exclusivos do XBox 360:

• Left 4 Dead – Jogo de matar zumbis atletas from hell onde 500 zilhões deles vem correndo pra cima de você e sua equipe. Matar zumbis é sempre uma ótima diversão. =D
• Fable II – Joguei o primeiro Fable e achei sensacional. É um RPG pela idéia de evoluir o personagem. Mas são suas ações que evoluem o personagem, não um monte de números, configurações e itens.
• Alan Wake – Na época o jogo ainda estava sendo produzido e prometia revolucionar e bla bla bla. Mas depois que vi o lançamento… nheem ¬¬

Foram os exclusivos que me fizeram decidir pelo PS3. “Ahh mas você nem colocou Halo, nem Gears of War, nem Mass Effect”. Não coloquei porque esses exclusivos não me atrairam nem um pouco. Não sou muito fã de FPS. Prefiro jogos TPS (Third Person Shooter) ou de plataforma. E também gosto de boas histórias, por isso que coloquei Alan Wake, e uma guerra contra alienígenas não é história, é desculpa pra dar tiro!

Depois de analisar os exclusivos de cada console, reparei que a maioria dos exclusivos do XBox 360 eram FPS. Os exclusivos do PS3 possuem estilos mais variados, e mais jogos de aventura (que gosto mais).

Então decidi pelo PS3 porque os jogos exclusivos ME agradam mais. Se você gosta mais de FPS, sugiro optar pelo XBox 360.

5º – Só isso???

Bem… existem vários outros motivos que REFORÇARAM minha escolha pelo PS3, e esses motivos que vou deixar para o próximo post pq esse já está bem grande…

Filed under: Games Tagged: Consoles, Games, PS3 ]]> http://raphaelmarques.wordpress.com/2010/06/26/porque-eu-escolhi-o-ps3-parte-1/feed/ 7 Raphael Marques escolha ps3 http://raphaelmarques.wordpress.com/2010/03/24/tutorial-jogo-da-memoria-com-javafx/ http://raphaelmarques.wordpress.com/2010/03/24/tutorial-jogo-da-memoria-com-javafx/#comments Thu, 25 Mar 2010 02:20:09 +0000 Raphael Marques http://raphaelmarques.wordpress.com/?p=390 ]]> Finalmente outro tutorial! =D

Dessa vez vou mostrar como fazer um simples jogo da memória em JavaFX.

O jogo vai ter duas telas (tela inicial, e tela do jogo em si) e toda a parte visual será carregada de arquivos FXZ (em vez de configurar todos os componentes pelo código).

O resultado é esse:

Vocês podem executar o jogo clicando aqui.

Vamos começar então…

Nesse tutorial vou usar os seguintes programas:

• Corel Draw X4 (pode ser qualquer editor de sua preferencia que gere arquivos no formato SVG)
• JavaFX 1.2
• JavaFX Prodution Suite (SVG to JavaFX Graphics Converter) baixe aqui
• NetBeans 6.8 com o plugin para JavaFX 1.2

O primeiro passo é criar os elementos visuais do jogo (telas, botoes, cartas, etc). Fiz isso utilizando o Corel Draw X4. Fiz cada tela com a proporção 4×3 para poder encaixar em uma tela 640×480 ou 800×600.

Você pode utilizar o editor gráfico que vc quiser, o importante é agrupar os elementos e dar nomes a eles. Neste caso, agrupei os elementos das telas em dois grupos principais: “titulo” e “jogo”. Dentro de cada tela, agrupei os botoes com suas sombras: “iniciar”, “sair” e “misturar”. Também dei um nome diferente para cada carta. O outros elementos que não terão funcionalidades agrupei nomeando de “resto”.

Depois de tudo criado e nomeado, exportei cada tela para o formato SVG. Ajustei a largura pra 640 pixels  e ativei a opção de converter os textos em curvas (isso é importante pra você não precisar se preocupar com a fonte utilizada).

Com os arquivos SVG’s criados (com o editor que você preferir), você os converte para FXZ utilizando o “SVG to JavaFX Graphics Converter”, ferramenta que vem no JavaFX Production Suite. Lembre de desmarcar a opção “Preserve “JFX:” IDs only”.

Agora só precisamos copiar os 2 arquivos gerados (titulo.fxz e jogo.fxz) para o projeto do NetBeans e começar a programar! =D

Vamos começar criando o arquivo JogoDaMemoria.fx. Criamos a função procurarNode(…) que procura por um Node (elemento visual) dentro de outros Nodes. Vou usar essa função para procurar os botoes e as cartas dentro de cada tela usando o nome que dei a cada elemento no Corel Draw.

function procurarNode(root:Node, id:String):Node{
    if(root.id == id)
        return root;

    if(root instanceof Group){
        var group = root as Group;
        for(node in group.content){
            var n = procurarNode(node,id);
            if(n != null)
                return n;
        }
    }
    return null;
}

A função procurarNode(…) recebe um Node raiz, e um nome para procurar os elementos recursivamente dentro do Node raiz. Quando você agrupa os elementos como fiz no Corel, eles são carregados pelo JavaFX como objetos da classe Group, e cada Group tem um atributo ‘content’ que pode ter outros Nodes dentro.

Agora que já sei procurar um elemento visual dentro de uma tela, vou criar a classe do jogo carregando todos os elementos necessários:

class Game extends CustomNode{

    //telas do jogo
    var telaTitulo = FXDLoader.load("{__DIR__}titulo.fxz");
    var telaJogo = FXDLoader.load("{__DIR__}jogo.fxz");

    //botoes da titleScreen
    var tituloIniciar = procurarNode(telaTitulo,"iniciar");
    var tituloSair = procurarNode(telaTitulo,"sair");

    //botoes da gameScreen
    var jogoMisturar = procurarNode(telaJogo,"misturar");
    var jogoSair = procurarNode(telaJogo,"sair");

    //cartas da gameScreen
    var cartas = for(i in [1..18]) procurarNode(telaJogo,"carta{i}") as Rectangle;

    //cores das cartas
    var cores = [
        Color.GREEN,Color.GREEN,Color.GREEN,
        Color.RED,Color.RED,Color.RED,
        Color.BLUE,Color.BLUE,Color.BLUE,
        Color.CYAN,Color.CYAN,Color.CYAN,
        Color.MAGENTA,Color.MAGENTA,Color.MAGENTA,
        Color.YELLOW,Color.YELLOW,Color.YELLOW,
    ];

    //cartas abertas pelo jogador
    var cartasAbertas:Rectangle[] = [];

    //tela que esta sendo exibida
    var telaAtual = telaTitulo;
}

A classe Game é subclasse de CustomNode e portanto se torna um elemento visual.

Para carregar um arquivo FXZ para uma variavel (do tipo Node) é só usar a seguinte comando:

var <variavel> = FXDLoader.load(<caminho para o arquivo>);

Com o Node de uma tela carregado, para encontrar um elemento dentro desse Node é só usar a função criada:

var <elemento> = procurarNode(<variavel Node>, <nome do elemento procurado>);

Com esses comandos a classe carrega as duas telas e seus botoes.

Para buscar as cartas utilisamos um for resultando em uma sequência de todas as cartas (da “carta1″ até a “carta18″):

var cartas = for(i in [1..18]) procurarNode(telaJogo,”carta{i}”) as Rectangle;

Pra quem não conhece muito, o for em JavaFX retorna uma sequência (array/lista) com os elementos processados em cada passo do for. Nesse caso, retorno uma carta “procurarNode(…) as Rectangle;” convertida para Rectangle em cada passo do for.

E como eu sei que as cartas são do tipo Rectangle? E como sei que os Nodes são do tipo Group? Pelo NetBeans você pode abrir o arquivo FXZ, clicar no botão “Source”, ver o texto contido no arquivo FXZ e procurar pelos IDs das cartas:

Rectangle {
    id: "carta1"
    fill: Color.WHITE
    ...
}

Os elementos que você desenha podem ser de vários tipos, é preciso olhar no arquivo FXZ pra saber o tipo, ou então utilize os elementos como Node, mas ai você não terá acesso a muitos atributos do objeto. No caso do jogo da memória, foi preciso saber o tipo das cartas para poder alterar a cor de preenchimento já que Node não possui esse atributo.

Depois crio uma sequência com as cores que vou utilizar. Nesse jogo, utilizei 3 objetos de cada cor, então, tenho que abrir três cartas iguais a cada jogada.

A variável ‘cartasAbertas’ serve pra guardar quais cartas foram abertas na tentativa de abrir cartas iguais. E a variável ‘telaAtual’ guarda, OBVIAMENTE, a referência para a tela que está sendo mostrada! =O

Esses são todos os atributos que precisamos criar! Agora vamos às funções!

A primeira função é a que define o que será exibido na tela. Neste caso, a ‘telaAtual’ é exibida e atualizada automaticamente se a variável for alterada (por causa do bind):

	override function create():Node{
		Group{
			content: bind telaAtual
		}
	}

Criamos agora a função ‘config’ que define o que vai ocorrer quando clicar em cada botao e carta:

	function config(){
		tituloIniciar.onMousePressed = function(event){
			changeScreen(telaJogo);//mudar de tela
		}
		tituloSair.onMousePressed = function(event){
			FX.exit();//sair da aplicação
		}
		jogoMisturar.onMousePressed = function(event){
			randomCards();//misturar as cores das cartas
		}
		jogoSair.onMousePressed = function(event){
			changeScreen(telaTitulo);//mudar de tela
		}

		for(carta in cartas){
			carta.onMousePressed = function(event){
				//função com a lógica de qdo clicar em uma carta
				selecionarCarta(carta);
			}
		}
	}

Chamamos a função ‘config’ no construtor da classe:

    init{
        config();
    }

Agora a função de muda de uma tela para outra (quando muda de tela, as cartas são embaralhadas):

	function changeScreen(screen:Node){
		telaAtual = screen;
		if(telaAtual == telaJogo)
			randomCards();
	}

A função que embaralha a sequência de cores das cartas e as deixa escondidas (pintadas de cinza):

	function randomCards():Void{
		//embaralha as cartas
		cores = Sequences.shuffle(cores) as Color[];

		//esconde todas as cartas
		for(carta in cartas){
			carta.fill = Color.GRAY;
		}

		//fecha todas as cartas abertas
		delete cartasAbertas;
	}

E finalmente a parte lógica do jogo que define o que acontece quando clico em uma carta:

	function selecionarCarta(carta:Rectangle):Void{

		//se abriu 3 cartas e nao eram iguais
		if(sizeof cartasAbertas == 3){
			//esconde as 3 cartas abertas
			for(c in cartasAbertas){
				c.fill = Color.GRAY;
			}
			delete cartasAbertas;
		}else{
			//se a carta esta escondida
			if(carta.fill == Color.GRAY){
				//pinta a carta com sua cor especifica
				carta.fill = cores[Sequences.indexOf(cartas, carta)];

				//insere nas cartasAbertas
				insert carta into cartasAbertas;

				//se abriu 3 e eram iguais
				if(sizeof cartasAbertas == 3 and
					cartasAbertas[0].fill == cartasAbertas[1].fill and
					cartasAbertas[0].fill == cartasAbertas[2].fill){

					//continuam abertas
					delete cartasAbertas;
				}
			}
		}
	}

Essa função ‘selecionarCarta’ tenta abrir a carta clicada e adioná-la na sequência ‘cartasAbertas’, se forem abertas 3 cartas diferentes, então no próximo clique as 3 cartas erradas são fechadas, já se forem abertas 3 cartas iguais, elas permanecem abertas. Simples assim! =D

Classe finalizada! \o/ \o/ \o/ \o/

Ué? Só isso? =P

Ainda falta exibir um objeto da classe que criamos, pra isso criamos um Stage:

Stage {
    title: "Jogo da Memoria"
    scene: Scene {
        content: Game{}
    }
}

Agora sim, só executar!

Esse foi apenas um exemplo de um jogo simples que envolve apenas cliques com o mouse, alteração de atributos de alguns elementos e mudança entre telas. Quantos jogos você conhece que só precisam disso???

Quem quiser os arquivos FXZ podem baixar aqui e aqui.

E pra finalizar, o código completo:

import javafx.scene.CustomNode;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.fxd.FXDLoader;
import javafx.scene.Scene;
import javafx.stage.Stage;
import javafx.scene.paint.Color;
import javafx.util.Sequences;
import javafx.scene.Cursor;
import javafx.scene.shape.Rectangle;

//procura um Node com o id especificado
function procurarNode(root:Node, id:String):Node{
	if(root.id == id)
		return root;

	if(root instanceof Group){
		var group = root as Group;
		for(node in group.content){
			var n = procurarNode(node,id);
			if(n != null)
				return n;
		}
	}
	return null;
}

class Game extends CustomNode{

	//telas do jogo
	var telaTitulo = FXDLoader.load("{__DIR__}titulo.fxz");
	var telaJogo = FXDLoader.load("{__DIR__}jogo.fxz");

	//botoes da titleScreen
	var tituloIniciar = procurarNode(telaTitulo,"iniciar");
	var tituloSair = procurarNode(telaTitulo,"sair");

	//botoes da gameScreen
	var jogoMisturar = procurarNode(telaJogo,"misturar");
	var jogoSair = procurarNode(telaJogo,"sair");

	//cartas da gameScreen
	var cartas = for(i in [1..18]) procurarNode(telaJogo,"carta{i}") as Rectangle;

	//cores das cartas
	var cores = [
		Color.GREEN,Color.GREEN,Color.GREEN,
		Color.RED,Color.RED,Color.RED,
		Color.BLUE,Color.BLUE,Color.BLUE,
		Color.CYAN,Color.CYAN,Color.CYAN,
		Color.MAGENTA,Color.MAGENTA,Color.MAGENTA,
		Color.YELLOW,Color.YELLOW,Color.YELLOW,
	];

	//cartas abertas pelo jogador
	var cartasAbertas:Rectangle[] = [];

	//tela que esta sendo exibida
	var telaAtual = telaTitulo;

	init{
		config();
	}

	override function create():Node{
		Group{
			content: bind telaAtual
		}
	}

	//configura os eventos de click dos botoes e cardas
	//configura o cursor do mouse sobre os componentes
	function config(){
		tituloIniciar.onMousePressed = function(event){
			changeScreen(telaJogo);
		}
		tituloSair.onMousePressed = function(event){
			FX.exit();
		}
		jogoMisturar.onMousePressed = function(event){
			randomCards();
		}
		jogoSair.onMousePressed = function(event){
			changeScreen(telaTitulo)
		}

		for(carta in cartas){
			carta.cursor = Cursor.HAND;
			carta.onMousePressed = function(event){
				selecionarCarta(carta);
			}
		}

		tituloIniciar.cursor = Cursor.HAND;
		tituloSair.cursor = Cursor.HAND;
		jogoMisturar.cursor = Cursor.HAND;
		jogoSair.cursor = Cursor.HAND;

	}

	//muda de uma tela para outra
	function changeScreen(screen:Node){
		telaAtual = screen;
		if(telaAtual == telaJogo)
			randomCards();
	}

	function randomCards():Void{
		//embaralha as cartas
		cores = Sequences.shuffle(cores) as Color[];

		//esconde todas as cartas
		for(carta in cartas){
			carta.fill = Color.GRAY;
		}

		//fecha todas as cartas abertas
		delete cartasAbertas;
	}

	//call when click on a card
	function selecionarCarta(carta:Rectangle):Void{

		//se abriu 3 cartas e nao eram iguais
		if(sizeof cartasAbertas == 3){
			//esconde as 3 cartas abertas
			for(c in cartasAbertas){
				c.fill = Color.GRAY;
			}
			delete cartasAbertas;
		}else{
			//se a carta esta escondida
			if(carta.fill == Color.GRAY){
				//pinta a carta com sua cor especifica
				carta.fill = cores[Sequences.indexOf(cartas, carta)];

				//insere nas cartasAbertas
				insert carta into cartasAbertas;

				//se abriu 3 e eram iguais
				if(sizeof cartasAbertas == 3 and
					cartasAbertas[0].fill == cartasAbertas[1].fill and
					cartasAbertas[0].fill == cartasAbertas[2].fill){

					//continuam abertas
					delete cartasAbertas;
				}
			}
		}
	}
}

Stage {
	title: "Jogo da Memoria"
	scene: Scene {
		content: Game{}
	}
}

Mas porque eu que só programo em Java iria falar de Python? Porque? PORQUE???

Simplesmente porque Python também é útil na vida de um pesquisador que programa em Java!

Eu vou falar aqui do quanto Python está sendo útil pra mim nesses últimos tempos (calma, não to falando de 2012) que estou finalizando meu mestrado.

Essa história começou quando assisti a uma palestra do Yuri Malheiros falando sobre Python. Achei bem interessante, facílimo de programar, e só! Não me empolgou tanto. Depois de um tempo, a Sun lançou o JavaFX e fiquei admirado com as facilidades que o JavaFX Script oferecia! Mas pensei, o Python também é fácil assim, mas o JavaFX Script é tipado! =D

Para exemplificar essas facilidades, vou mostrar como criar uma função que recebe um array e retorna um outro array com os quadrados de cada elemento, em seguida uso essa função para saber os quadrados do array [4,8,15,16,23,42], tudo isso tentando economizar o máximo possível de código:

Em Java:

public class Quadrado{
    static int[] quadrado(int[] array){
        int[] resultado = new int[array.length];
        for(int i = 0; i < array.length; i++)
            resultado[i] = array[i] * array[i];
        return resultado;
    }
    public static void main(String[] args){
        System.out.println(Arrays.toString(
            quadrado(new int[]{4,8,15,16,23,42})))
    }
}

Em JavaFX Script:

function quadrado(array: Integer[]){
    for(i in array) i*i;
}
println(quadrado([4,8,15,16,23,42]));

Em Python:

def quadrado(array):
    return [i*i for i in array]
print(quadrado([4,8,15,16,23,42]))

O quadrado desses números dá pra fazer “na mão”, mas imagine que vc precise saber o quadrado de muito mais números, e números bem maiores, é mais fácil fazer um programa que calcule isso que usar a véia calculadora do Windows.

Fazer essa simples operação em Java é bem chato! Você tem que escrever MUITO código! Em JavaFX Script e Python posso dizer que a facilidade é a mesma, tudo bem simples, nem precisa criar classe alguma!

Mas é na hora de executar o código que Python supera as outras alternativas. Python não precisa compilar, ele é interpretado diretamente, vc testa num único passo, rapidinho! E se vc quiser, nem precisa criar arquivo nenhum, vc pode usar o terminal do Python onde tudo é executado a medida que vc digita!

O modo terminal do Python é uma maravilha para pesquisadores como eu, que precisam constantemente fazer esse tipo de calculo. Usar o terminal do Python como uma calculadora é ótimo! Vc pode fazer as contas simples, como também criar funções e reusá-las!

Olha ai o terminal do python:

Obs: Eu sei que Python não se resume a isso, que pode fazer muito mais coisa, sistemas completos, bla bla bla, eu sei!

Mas só Python faz isso? NÃO! Deve haver outras linguagens e ferramentas com essas facilidades, mas eu conhecia Python, resolvi utilizar e me ajudou MUITO na minha pesquisa.

O importante é vc conhecer as alternativas, saber que outras linguagens podem resolver um pequeno problema que a sua linguagem favorita não resolve ou te dá muito trabalho!

Python me ajudou muito, espero que ajude vcs também! =D

Pra quem se interessou, pode aprender mais sobre Python no site oficial: http://python.org/

O JavaFX Authoring Tool tah demorando muito! =/

Bem legal pra quem está começando e quer aprender uns "macetes"

olhae: http://javafx.com/learn/howto.jsp

Aproveitando um pouco as “férias”, um desenho (inspirado em um post desse site) feito com bic preta e colorido no photoshop. Gostei do efeito de sombra que consegui utilizando técnicas simples.

Nada muito tchananan, só pra passar o tempo mesmo =D

Aqui tem as instruções se vc também quiser essa facilidade!

Uma imagem legal do Cheeks pra testar (é o mesmo cara que faz os desenhos do “Spectacular Spiderman” e “Hellboy Animated”, adoro o estilo dele)…

Se funcionar… só posto por aqui agora! =D

obs: a categoria não funcionou, provavelmente porque a categoria que testei (wordpress) ainda não existia, mas o resto funcionou perfeitamente! \o/

De volta ao blog (estou muito ocupado com o mestrado) para dar uma ótima notícia!

Finalmente um editor visual para JavaFX que preste! Não é uma Brastemp mas já é muito bom!

Ele é baseado em estados, cada estado do seu programa pode ter componentes diferentes ou configurações diferentes dos componenetes padrão. Whaaaaat??? Não entendeu né? Eu explico.

Imagine que sua aplicação seja um instalador do estilo next>next>next>finish. Você precisa dos botões de next, previous e finish, digamos que tenha uma imagem constante no topo da tela de instalação e o conteudo central da janela muda a cada tela. Com o JavaFX Composer, vc não precisa alternar quais componentes são visiveis em cada tela, vc simplismente cria uma única versão dos componentes com as características básicas (imagem no topo, botao na parte de baixo), e define suas “especialidades” de cada estado. Então, por exemplo, o botao “previous” vai estar desabilitado no 1º estado e habilitado nos outros, o botao “finish” vai estar habilitado apenas no último estado, apenas no 2º estado vai aparecer 3 checkboxs. Tudo isso vc configura visualmente em cada estado, e o código gerado pelo Composer se vira pra alternar entre as configurações dos componentes em cada estado.

Pelo que vi, voce pode fazer qualquer alteração (tamanho, posição, texto, layout, …) em um componente de um estado para outro, incluindo a execução de eventos (onClick, onPressed, …) diferentes para cada estado.

Vejam esse vídeo e entendam o que estou falando:

Para rodar o Composer vc precisa do NetBeans 6.8 (devidamente configurado com JavaFX) e instalar o plugin do Composer pelo gerenciador de plugins (inclusive ele vem com alguns exemplos).

Em breve faço algumas coisas com o Composer e mostro aqui!

o/

O evento foi muito legal, aprendi muito! Muito bem organizado pelo Rogério Moraes (http://rogeriomoraescarvalho.spaces.live.com/) (obrigado pelo convite).

\o/

Segue os slides da apresentação:

Infelizmente, por causa da internet não consegui fazer uma demostração. Mas nesse link coloquei vários exemplos (basta clicar no link e executar o arquivo .jnlp que é baixado).

Nesse outro link vc pode executar o RaceFX, um joguinho de corrida feito em JavaFX utilizando Sockets e baixar o projeto para o NetBeans. (executar: “RaceFX3.jnlp”, código: “src completo.zip”)

Além dos links presentes na apresentação, recomendo os tutoriais e outras apresentações dese blog.

Aproveitem =D

Gravei a apresentação mas ainda não estou com o arquivo do vídeo, assim que tiver posto aqui também! =D

Participem =D

No dia 18 de setembro de 2009, Elenilson Vieira (http://blogs.sun.com/elenilsonvieira/), Embaixador da Sun na UFPB, estará realizando, juntamente com o Programa de Educação Tutorial de Computação (PET.Com – http://www.pet.di.ufpb.br/) da Universidade Federal da Paraíba (UFPB – http://www.ufpb.br/), o II Sun Day, um dia de apresentações sobre tecnologias da Sun. O evento será realizado no Auditório do CCEN, ao lado do Departamento de Informática (DI – http://www.di.ufpb.br/) da UFPB.

A programação do evento:

9:00 - Java Collections (Tomaz Lavieri – Certificado Java 6)

10:30 - JavaME no Mercado Mobile (Erisvaldo Junior – Graduando em Ciência da Computação pela UFPB e pesquisador do Labteve. http://www.erisvaldojunior.com/)

12:00 - Coffee-Break

14:00 - JavaFX 1.2 (Raphael Marques – Mestrando em Informática pela UFPB. http://raphaelmarques.wordpress.com/)

15:00 - Integração do Sun SPOT com a TV Digital Brasileira (Ricardo Mendes – Graduando em Ciência da Computação pela UFPB e pesquisador do LAVID)

16:00 - JavaEE: Desenvolvendo Aplicações Baseadas em Ajax (Diego Pessoa – Mestrando em Informática pela UFPB)

17:00 - Coffee-Break

Eu os encontro lá!

fonte: http://blogs.sun.com/elenilsonvieira/entry/convite_ii_sun_day

A alguns dias encontrei a Phys2D (uma engine de física 2D escrita em Java) e comecei a usar. Gostei muito, é MUITO BEM orientada a objetos, facil de usar (apesar da falta de documentação), e tem alta performance. Mas enquando refazia o jogo de sinuca utilizando Phys2D me deparei com  um problema grave da Phys2D!!! Ela não implementa CCD (continuous collision detection) que serve para que um objeto nunca passe atravez de outro não importa a velocidade que ele esteja. Sem o CCD, quando uma bola de sinuca muito rápida bate nas bordas da mesa, ela simplismente escapa da mesa e xau! Adeus bolinha! Tentei algumas configurações para melhorar a detecção de colisão mas não adiantou! Se a bolinha colidir muito rápido, xau!

Então, fui atraz da JBox2D que já tinha visto o nome mas não dei importancia porque já estava utilizando a Phys2D. Primeiro fiquei impressionado com os exemplos do site do JBox2D!!! (os exemplos do Phys2D simplismente não rodaram). Também já tinha lido que a JBox2D era uma simples conversao da Box2D que é implementada em C. E não tinha nada de Orientação a Objeto (o que dificulta na integração com código Java). Fui testar já que a JBox2D implementava o precioso CCD além de ser um pouco mais rápido que o Phys2D. Realmente implementa como pude ver no manual da engine original Box2D (bem completo, só que voltado para programadores C). O problema do JBox2D é que não existe Orientação a Objeto nenhuma ali! É terrivel! Acesso direto às variaveis internas! Apesar da documentação, é complicado (pra um programador Java) criar algo complexo com JBox2D.

Atualmente ainda estou decidindo se fico com a facilidade e simplicidade do Phys2D sem o CCD, ou se enfrento a complexidade do JBox2D com o CCD. Estou inclinado a decidir pelo JBox2D porque dependendo dos jogos que for criar, o CCD pode ser essencial!!! (ou quem sabe incluir CCD no código do Phys2D???).

Ainda vou estudar melhor as possibilidades, e qdo decidir posto aqui! =D

Obs.: recomendo efusivamente que vejam os exemplos do JBox2D!

Update: dei uma olhada no código das 2 engines! São bem complexas! To achando melhor criar classes Wrap para o JBox2D.

Foi proposto um desafio aos alunos! Formular um algorítmo que detecte quando ocorre a colisão entre 2 carros! E parar o carro de traz! Detalhe é que os 2 carros podem estar em qualquer posição, em qualquer ângulo!

=D

Esses são os slides utilizados:

Ministrarei um mini-curso de JavaFX no Campus I da Universidade Federal da Paraíba (especificamente no Departamento de Informática) nos dias 7, 8 e 9 de julho, das 17 ás 20 horas. Esse mini-curso está sendo organizado por Elenilson Vieira (Embaixador da Sun).

Conteúdo Programático:

• Plataforma JavaFX
• JavaFX Script
• GUIs com JavaFX
• Até o término do curso será criada uma aplicação utilizando vários dos conceitos vistos.

O mini-curso tem vagas prioritariamente para o Campus I da UFPB. Para fazer a inscrição, basta enviar um e-mail com nome e matrícula para minicursojavafxufpb@gmail.com e aguardar a confirmação.

São 18 vagas para os computadores do Ada e 3 vagas para notebooks (as vagas já estão quase todas preenchidas, mas não custa nada tentar).

Vale salientar que não é necessário pagar nada pelo mini-curso.

Ao fundo é um quadriculado para notar a movimentação do carro (que está sempre na mesma posição da tela). A linha azul é a velocidade do carro e a vermelha é a aceleração.

O resultado pode ser conferido pelo JavaWebStart clicando aqui. Infelizmente o google-sites não aceita scripts no html para que eu possa mostrar como um applet! =/

A partir desse básico posso evoluir para várias possibilidades! =D (ainda não decidi)

É apenas uma demonstração de física de um carro 2D (visão de cima), mas  pra fazer esse pequeno carro se movimentar de forma “realista” é preciso usar alguns conceitos descritos a seguir:

Movimentação independente do framerate

O básico que vejo em muitos tutoriais por ai sobre o loop principal de um jogo eh:

while(true){
    capturaComandos();//teclado e mouse
    atualizaVariaveis();//lógica do jogo e posição dos personagens
    redesenha();//desenha tudo na tela
}

Vamos imaginar que um objeto do jogo tenha uma posição (x,y) e uma velocidade (vx,vy). A ideia básica desse loop é capturar as ações do teclado e mouse, e em seguida atualizar a posição (x,y) do objeto.

void atualizaVariaveis(){
    x += vx;
    y += vy;
}

Mas existe um problema ai! Sempre que o loop for executado, a posição do objeto será alterada, sem importar a velocidade que o loop eh executado. Traduzindo, se seu computador for lento, seu objeto vai se mover lentamente, e se seu computador for rápido, seu objeto vai se mover rapidamente! Isso porque a chamada da função atualizaVariaveis() depende básicamente da velocidade do seu computador e da pláca de vídeo!

Uma solução é colocar um ‘sleep(time)’ no loop para fazer o computador ‘dormir’ por um tempo determinado. Esse ‘time’ deve ser calculado de forma que no final, o loop seja chamado sempre a mesma quantidade de vezes por segundo! Vc define um framerate (ex: 30 frames por segundo) e faz os cálculos do ‘time’ baseado no framerate. Assim seu jogo terá a mesma velocidade sempre, 30fps.

Mas essa técnica ainda tem um defeito, se o computador do seu amigo (pra quem vc quer mostrar o jogo) for muito lento e não suportar os 30fps, o jogo fatalmente ficará lento! =/

Para solucionar isso vc deve fazer a movimentação independente do framerate! Igual qualquer jogo profissional faz! Já reparou que em jogos profissionais o framerate varia durante o jogo, mas os objetos em cena se movem na mesma velocidade? Esses jogos tentam tirar o máximo da máquina pra alcançar o melhor framerate! Com mais frames por segundo o jogo parece mais suave e confortavel de jogar! Mas isso sem deixar os objetos mais rápidos ou lentos que o normal!

E como fazer isso? Como movimentar objetos independente do framerate?

O segredo é passar para a função de atualização um parametro referente à passagem de tempo desde a última chamada da função! Assim, a função sabe quanto tempo se passou desde a última chamada para atualizar as variaveis baseadas nesse tempo!

//time em milissegundos
void atualizaVariaveis(long time){
    float factor = time / 1000f;
    x += vx * factor;
    y += vy * factor;
}

E o loop ficaria assim:

long tempoAnterior = System.currentTimeMillis();
while(true){
    capturaComandos();
    long tempoAtual = System.currentTimeMillis();
    long tempoDecorrido = newTime - lastTime;
    tempoAnterior = tempoAtual;
    atualizaVariaveis(tempoDecorrido);
    redesenha();
}

Dessa forma, definindo a velocidade em distância por segundos, e o ‘time’ em milissegundos, a posição do objeto é atualizada de acordo com o tempo decorrido desde a última atualização.

Se passou 1000ms, ‘factor’ assumirá o valor 1.0 (1 segundo). Se passou 500ms, ‘factor’ assumirá o valor 0.5 (meio segundo).

Representação de um carro

Depois de fugir um pouco do assunto, vamos começar a falar do carro =D

Para representar o carro utilizei as seguintes variáveis:

• x,y (posição do carro)
• velocity (velocidade do carro)
• angleVelocity (ângulo da movimentação do carro em radianos)
• vel_max (valor máximo que a variavel ‘velocity’ pode assumir)
• turnAngle (velocidade de giro do carro)
• aceleration (aceleração do carro)
• friction (atrito quando o carro anda de frente)
• lateralFriction (atrito quando o carro derrapa de lado)

Com essas variáveis, o ângulo em que o carro se movimenta pode ser diferente do ângulo em que ele acelera! Possibilitando a simulação de derrapagens em curvas! Separei a fricção normal da fricção lateral para que o carro desacelere mais no sentido lateral que no sentido do carro (direção das rodas).

Atualização das variáveis

A primeira variável a atualizar é o ângulo do carro quando giramos para esquerda ou direita:

if(left){//quando a seta para esquerda estiver pressionada
    angleCar += turnAngle * factor;
}
if(right){//quando a seta para direita estiver pressionada
    angleCar -= turnAngle * factor;
}

Reparem que a rotação do carro também depende de ‘factor’ para que o carro sempre gire com a mesma intensidade independente do framerate.

Agora a aceleração:

if(up){//quando a seta para cima estiver pressionada
    var vxc = Math.cos(angleVelocity) * velocity;
    var vyc = Math.sin(angleVelocity) * velocity;
    var va = aceleration * factor;
    var vxa = Math.cos(angleCar) * va;
    var vya = Math.sin(angleCar) * va;
    var vx = (vxc + vxa);
    var vy = (vyc + vya);
    var v = Math.sqrt(vx*vx + vy*vy);
    var a = Math.atan2(vy, vx);
    velocity = Math.min(v,vel_max);
    angleVelocity = a;
}

O que eu faço nesse código é calcular as componentes x e y da velocidade e da aceleração (multiplicadas por ‘factor’ também).  Somar as componentes que dá o efeito de aceleração, e por fim, calcular o novo ângulo e intensidade  da velocidade (que não pode passar da velocidade máxima).

Depois disso, vem a parte do atrito! O código é bem complexo, envolve muita noção de vetores e trigonometria, e não vou me aprofundar muito nisso. Mas basicamente eu separo a velocidade em duas componentes, uma componente com o mesmo sentido do carro (normal), e outra componente transversal ao sentido do carro (lateral). As componentes ‘normal’ e ‘lateral’ são subtraidas de ‘friction’ e ‘lateralFriction’ respectivamente. E depois junto as novas componentes ‘normal’ e ‘lateral’ para formar a nova velocidade (intensidade e ângulo). Assim, se o carro está se movendo de lado ele irá parar mais rápido do que se estivesse se movendo de frente.

Depois que calculei os ângulos e velocidades novos, atualizo a posição (x,y) do carro:

x += Math.cos(angleVelocity) * velocity * factor;
y += Math.sin(angleVelocity) * velocity * factor;

Novamente lembrando que deve-se multiplicar a velocidade por ‘factor’ para que o carro se movimente independente do framerate.

Configurações do carro

Pode parecer estranho que algumas variáveis como a fricção sejam variáveis e não constantes. Mas isso é útil para desenvolver um jogo onde existam carros diferentes, com comportamenteo diferentes. Cada carro com sua aceleração e giro. Ou pra simular óleo na pista (vc pode diminuir temporariamente a aceleração e o atrito) fazendo o carro deslisar.

Nesse teste utilizei as seguintes configurações:

aceleration: 200
vel_max: 400
turnAngle: 90°
friction: 50;
lateralFriction: 400;

Com essas configurações o carro apresentou uma boa velocidade e aceleração, também com um bom controle em curvas.

Dificuldades encontradas

Bem, a principal dificuldade foi desenvolver a parte do atrito lateral! O resto das contas foram simples.

Uma coisa é muito importante! As funções trigonométricas de Java presentes na classe Math utilizam ângulos em radianos (em vários momentos errei utilizando valores em graus nas contas) e o JavaFX utiliza ângulos em graus para fazer a rotação! Então é preciso atenção para trabalhar com ângulos!

Esses estagiarios… tsc tsc tsc

Falei sobre os operadores java: compostos, aritméticos, lógicos, relacionais, instanceof, condicional.

Os slides:

O Seven mostra o nome dos discos removiveis na hora de remover com segurança! AEEEWWW SENSACIONAL SENSACIONAL =D

Tah e dai? Grande merda neh? É que a uns meses eu reclamei exatamente disso com um amigo meu. “Bem que o Windows podia mostrar o nome dos drivers, em vez de mostrar só a letra da unidade…”. Antes qdo eu ia remover um de vários pendrivers, tinha que abrir o Explorer pra saber a unidade dele! =D

Ah, também coloquei um pendrive pra mostrar no post, mas por algum motivo o Seven nem mostrou o nome dele (nem no Explorer). FAIL!!! Mas a intenção foi boa! =D

Alem da lentidao e do monte de firulinhas inuteis, o vista não me apresentou mtas vantagens em relação ao XP! Além de ter dado um trabalhão pra fazer os drivers de vídeo e som funcionarem corretamente!

Hoje instalei o Windows Seven aqui (mantendo o HD com o XP eh claro =D) e to gostando do que to vendo! Estou achando as firulinhas do Seven bem mais úteis que as firulinhas do Vista! E isso que tah me chamando atenção =D

Outro ponto importante é a velocidade! Claro que ão tah mais rapido que o XP, mas nao tah lento como o Vista neh! Consigo trabalhar sem ter raiva de janelas que não abrem, etc…

Clique para ampliar

Esse é o desktop aqui, podem ver a nova barra de tarefas do Seven, a nova calculadora (modo programador \o/), o novo Paint (finalmente).

Tenho que destacar essa nova barra de tarefas! É genial! Os icones são ao mesmo tempo atalho e botão para a janela aberta! E nada de nomes (tomara que eu não tenha problemas com isso), soh os ícones agora! O que economiza muito espaço, importantíssimo pra quem trabalha com um monte de janela aberta (repararam neh?).

Uma coisa que gostei: Fui criar atalhos para algumas pastas que mais uso, e qdo arrastei o atalho pra barra de tarefas, ele simplismente se fundiu com o atalho do WindowsExplorer que já existe! Clicando com o botao direito nos icones permite acessar os ultimos arquivos aberto com o programa respectivo ao ícone (assim como as pastas que adicionei como atalho pro Explorer \o/). É bem produtivo e organizado! É isso que espero de um bom SO. Que me ajude a organizar meu trabalho! Um SO não deve ser um FIM, mas sim um MEIO pra atingir algo! No meu caso, o FIM é a produtividade!

Até agora, não tive nenhum problema com os aplicativos que usava no XP! Exceto o driver de rede e som que não foram reconhecidos automaticamente (situação engraçada: quando não conseguiu detectar a rede, ele ofereceu a opção de buscar ajuda online! ¬¬) Mas com o cd da placamãe resolvi o problema da rede. O do som foi diferente. Usei um driver de som pro Vista, e não funcionou! Ai uma das opções era obter um driver do Windows Update, escolhi essa opção (a net jah tava funcionando) e depois de alguns minutos baixando uns drivers meu Winamp começou a tocar música! \o/

É o que ficava me perguntando, porque o Ubuntu reconhece melhor os meus drivers que o poderoso Windows? Bem, só de fazer meu som funcionar baixando o driver apropriado automaticamente já contou muitos pontos comigo! =D

Por enquanto é isso! Estou muito satisfeito com o Seven! (e olha que nem é a versão final).

E será que muitos também farão a migração como eu? XP>>Vista>>XP>>Seven ???

O objetivo do minicurso é que os alunos que até agora só aprenderam uma linguagem aprendam a outra. Dominar as duas linguagens é muito importante!

A seguir estão os slides utilizados:

E os códigos dos exercícios feitos durante o minicurso nas duas linguagens:

Java:

import java.util.Scanner;
//nao precisa importar a classe Math porque a JVM ja faz isso

public class Exercicio1 {

    public static float area(int raio){
        return (float)Math.PI * raio * raio;
    }

    public static float perimetro(int raio){
        return 2 * (float)Math.PI * raio;
    }

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        while(true){

            System.out.print("digite um raio: ");
            int raio = scan.nextInt();
            System.out.println("vc digitou: " + raio);

            if(raio < 0)
                break;

            float area = area(raio);
            float perimetro = perimetro(raio);

            System.out.println("a area eh: " + area);
            System.out.println("o perimetro eh: " + perimetro);

            System.out.println();

        }//fim do while
    }//fim do main
}//fim da classe

import java.util.Scanner;

public class Exercicio2 {

    public static float notaDaFinal(float media){
        //calcula quanto o aluno precisa tirar na final
        //0.6 * media + 0.4 * notaDaFinal >= 5
        return (50 - 6 * media) / 4;
    }

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        System.out.print("digite o numero de notas: ");
        int n = scan.nextInt();
        System.out.println("vc digitou: " + n);

        float[] notas = new float[n];

        for (int i = 0; i < notas.length; i++) {
            System.out.print("digite a " + (i+1) + "a nota: ");
            notas[i] = scan.nextFloat();
        }

        float media = 0;
        //o nome eh foreach, mas se usa a palavra reservada for
        //foreach eh apenas para leitura do array!
        //nao serve pra escrita!
        for(float f : notas) {
            media += f;
        }
        media /= n;

        System.out.println("a media eh: " + media);

        if(media >= 7){
            System.out.println("o aluno foi aprovado!");
        }else{
            if(media < 4){
                System.out.println("o aluno foi reprovado!");
            }else{
                float notaDaFinal = notaDaFinal(media);
                System.out.println("o aluno vai pra final precisando de " + notaDaFinal);
            }
        }

    }//fim do main
}//fim da classe

C:

#include <stdio.h>

#define PI 3.1416

float CalculaArea(int raio){
    return PI * raio * raio;
}

float CalculaPerimetro(int raio){
    return 2 * PI * raio;
}

int main() {

    while(1){

        int raio;
        printf("digite um raio: ");
        scanf("%d", &raio);
        printf("vc digitou: %d\n", raio);

        if(raio < 0)
            break;

        float area = CalculaArea(raio);
        float perimetro = CalculaPerimetro(raio);

        printf("a area eh: %f\n", area);
        printf("o perimetro eh: %f\n", perimetro);

        printf("\n");
    }

    return 0;
}

#include <stdio.h>

float NotaDaFinal(float media){
    //calcula quanto o aluno precisa tirar na final
    //0.6 * media + 0.4 * notaDaFinal >= 5
    return (50 - 6 * media) / 4;
}

int main() {

    int n;
    printf("digite o numero de notas: ");
    scanf("%d", &n);
    printf("vc digitou: %d\n", n);

    float *notas = (float*) malloc( sizeof(float) * n );

    int i;
    for (i = 0; i < n; ++i) {
        printf("digite a %da nota: ", i+1);
        scanf("%f", notas+i);
    }

    float media = 0;
    for (i = 0; i < n; ++i) {
        media += notas[i];
    }
    media /= n;

    printf("a media eh: %f\n", media);

    if(media >= 7){
        printf("o aluno foi aprovado!\n");
    }else{
        if(media < 4){
            printf("o aluno foi reprovado!\n");
        }else{
            float notaDaFinal = NotaDaFinal(media);
            printf("o aluno vai pra final precisando de %f\n", notaDaFinal);
        }
    }

    //liberar memoria alocada com malloc
    free(notas);

    return 0;
}

Abaixo estão os slides! =D

Os exemplos demonstrados foram tirados do javafx.com ou feitos por mim mesmo.

Alguns deles até já foram postados nesse blog.

Notei que o pessoal gostou mesmo da facilidade que é programar em JavaFX Script! o/

Farei uma apresentaçao sobre JavaFX no “Sun Day” e um minicurso
“Java && C” no dia dos minicursos.

O PET.Com, em parceria com o Departamento de Informática, convida todos os alunos e professores para a I Semana da Computação DI/UFPB. A Semana da Computação surgiu da idéia de agrupar em um único evento algumas atividades planejadas para o decorrer dos semestre letivos no DI, e contará com o apoio da Microsoft Corporation e da Sun Microsystems.

PROGRAMAÇÃO

22/04 – Microsoft Day

23/04 – Recepção dos Feras

24/04 – Sun Day

25/04 – Mini-cursos

Fonte: http://petccufpb.wordpress.com/

Acredito que a qualidade da palestra é independente do tempo de apresentação! Depende sim, entre outros fatores, da qualidade do palestrante, do interesse do público pelo assunto abordado, e do planejamento da palestra!

E é essa parte do planejamento que vou falar aqui!

O mais importante sobre o tempo de uma palestra, é saber utilizá-lo!

Gandalf : “A Wizard is never late. He always arrives exactly when he means to.”

Dado um tema da palestra, o segredo é planejar:

• o que daria pra falar em X minutos?
• o que mostrar nesse tempo?
• do que será mostrado, o que detalhar e o que não detalhar?
• do que será detalhado, qual nível de detalhamento?
• em quais momentos vou apenas falar sem mostrar slides?
• vou apresentar algum vídeo? de quantos minutos?

O Sun Day foi organizado por outro amigo, Elenilson Vieira, embaixador da Sun na UFPB.