JPriuliFilter – Referencia

Apresentarei algumas funcionalidades do projeto JPriuli-Filter.

Tentarei ser breve neste post, por isso apresentarei as funcionalidades de uma forma bem resumida, porem com tudo que é necessário para usufruir deste pequeno projeto. Vamos lá!!

O funcionamento do Filter é simples, desde que entenda os itens abaixo:

•1ª- Todos os valores adicionados no filter são utilizados na construção da query
•2ª- Todas os critérios disponíveis para filtrar as consultas, ou seja as classes do projeto, estão no pacote net.priuli.filter.criterion e implementam a interface Criterion.
•3ª- Os valores adicionados no Filter são interpretados pelo FrameWork ORM e podem ocorrer erros. (Este erro é o erro do framework ORM).

# FactoryFilter.java

FactoryFilter.class – A fabrica ‘FactoryFilter’ é utilizada para instanciar um Filter. Podemos fazer da seguinte maneira:

Filter filter = FactoryFilter.createFilter()

# Filter.java

A implementação de um Filter armazena os critérios que serão usados para restringir uma consulta HQL. Abaixo apresentarei os métodos desta interface.

setDistinct(boolean)

Este método permite adicionar o comando distinct no select.

setRange(Range)

Este método permite restringir por quantidade ou paginar os resultados. Cada consulta utilizando um Range, terá uma nova pagina de resultados de acordo com a implementação do mesmo.
O projeto fornece duas classe, são elas: net.priuli.filter.criterion.RangeLimitImpl – Utilizado para paginação de resultados. Cada consulta usando este Range terá uma consulta de acordo com a pagina atual da paginação.
net.priuli.filter.criterion.RangeSimpleImp – Utilizado apenas para limitar uma quantidade de registros.

add(String, Object)

O método ADD é utilizado para adicionar os critérios no Filter.
O primeiro parâmetro é o nome do atributo ou relacionamento da entidade, já o segundo parâmetro é o valor que será utilizado na construção da query.

setCountOnly(boolean)

Este método permite realizar a contagem ao invés de retornar os dados. Vejamos:

Filter filter = FactoryFilter.createFilter();
filter.add("name","JOHN",LikeMode.ANYWHERE);
filter.setCountOnly(true);

//DAO 
Criteria criteria =  new CriteriaSelectBuilder<T>(session,persistentClass).build(filter);
			
Long qtd = (Long)criteria.uniqueResult()

#Critérios

As condições do SQL são representadas por classes que implementam a interface Criterion.

AND

Para adicionarmos o critério And, no filter, basta adicionar o nome do campo e o valor que o campo deve ter.

Filter filter = FactoryFilter.createFilter();
filter.add("id",  1L);

OR

A condição OR restringe por um ou outro valor.

	Filter filter = FactoryFilter.createFilter();
	filter.add("number", new Or(20L, 22L));

NOT EQUALS

A condição NotEquals é usada da seguinte maneira.

Filter filter = FactoryFilter.createFilter();
filter.add("name",  new NotEqual("Wil Wheaton"))

LIKE

O comando Like do SQL pode ser usado, adicionando a classe Like no método add() do filter.

filter.add("name",new Like("JOHN",LikeMode.START));

O LikeMode é um Enum e tem os seguintes valores: LikeMode.START; LikeMode.END; LikeMode.ANYWHERE;


IN

Os valores de tipo Collection são utilizadas como IN pelo filter. De qualquer modo o projeto oferece a classe net.priuli.filter.criterion.In

List numbers = new ArrayList();
numbers.add(65865422L);
numbers.add(89548345L);

Filter filter = FactoryFilter.createFilter();
filter.add("number", numbers);

NOT IN

A condição Not In pode ser obtida através da classe net.priuli.filter.NotIn.

	NotIn<Long> numbers = new NotIn<Long>();
	numbers.add(65865422L);
	numbers.add(89548345L);
		
	Filter filter = FactoryFilter.createFilter();
	filter.add("phones.number", numbers);
	

JOIN

A realização de Join é a novidade das atualizações acima da versão 2.0.
O join pode ser feito pela interface Filter, desde que exista as anotações de relacionamento nas entidades.

Filter filter = FactoryFilter.createFilter();	 
filter.add("phones.number", new Or(5683543L,89548345L));

personDAO.find(filter);

No exemplo, usamos um join (‘phones.number’) onde a entidade Person, da personDAO, terá um join com a entidade Phone (phones.xx). Para baixar exemplos, clique AQUI

BETWEEN

A classe Between restringe o resultado para que esteja entre dois valores.

Between between = new Between<Long>(5683543L, 89548345L)

Filter filter = FactoryFilter.createFilter("number", between );

LIMITER

A classe Limiter permite limitar o resultado através de um campo individualmente.

Limiter<Date> limiter = new Limiter<Date>(  date, LimiterMode.LESS_THAN_OR_EQUAL);

filter.add("birthday", limiter);

As possíveis constantes aceitas do Limiter são: LimiterMode.GREATER_THAN; LimiterMode.GREATER_THAN_OR_EQUAL; LimiterMode.LESS_THAN; LimiterMode.LESS_THAN_OR_EQUAL

FETCH

O fetch, muitas vezes, é necessário para evitar o Lazy Loader. Podemos usa-lo da seguinte maneira:

Filter filter = FactoryFilter.createFilter();
filter.add("phones", new Fetch(JoinMode.LEFT));

ORDER

Para ordenarmos o resultado, usamos a classe Order.

filter.add(new Order("name",OrderMode.ASC));

O orderMode define o tipo da ordenação podendo ser: OrderMode.ASC ou OrderMode.DESC

# CriterionFactory.java

É possível diminuir o acoplamento usando a classe net.priuli.filter.utils.CriterionFactory. Esta classe cria as implementações como veremos a seguir:

filter.add("number", CriterionFactory.between(5683543L, 89548345L));

O código fica mais enxuto em comparação com o que foi apresentado acima.
+ exemplos:

filter.add("number", CriterionFactory.notIn(new Long[]{1,5,6,3}));

Todas as funcionalidades aqui descritas estão disponíveis na versão 2.1+

Tail Recursion

Este é a continuação do artigo sobre recursão.

Neste post vamos entender o conceito de Tail Recursion, que também pode ser chamado de Recursão em Cauda, nada mas é do que uma técnica para otimizar os algoritmos recursivos. Conforme vimos no artigo anterior, a medida que a recursão cresce, o consumo de memoria Stack(Pilha) também cresce, levando um gasto excessivo para resolver o problema principal. Para evitarmos este consumo, que afeta o desempenho do algoritmo, é necessário usar o conceito de Tail Recursion.
Algoritmos Tail Recursion tem um desempenho próximo a de uma interação do tipo ‘for’, portando de comportamento assintótico de O(n).

Para usufruirmos do desempenho aqui citado, o algoritmo não deve realizar operações que dependam do resultado de métodos recursivo. Mas a frente veremos o porquê.

O compilador

A maneira como um compilador ou uma linguagem são arquitetados podem interferir na implementação do Tail Recursion, em geral linguagem funcionais não tem problemas para implementar este tipo de conceito.
O compilador precisa armazenar os endereços, assim como o estado das execuções dos métodos que precisam esperar um resultado de outro método. Essa rotina consome muito recurso, levando a um baixo desempenho para os algoritmos recursivos. Apesar disso, é possível diminuir este consumo.
O conceito de Tail Recursion envolve o compilador e também o Programador, este ultimo deve permitir que o algoritmo possa ser otimizado. Como ? veremos a seguir.

A chamada recursiva deve ser a última instrução a ser executada. O programador deve ter certeza que sua solução atenda esta frase para implementar um algoritmo Tail Recursion, o resto fica com o compilador.
O compilador deve reconhecer que salvar os endereçamentos e ou instruções serão um desperdício para os algoritmos Tail Recursion.
Se não houver instruções adicionais para executar, ou seja Tail Recursion, então não há necessidade de armazenar o ponteiro de instrução na pilha.


Algorítimos – Recursão x Recursão em Cauda x Interação

Os algoritmos a seguir implementam o algoritmo de Fibonacci em Java utilizando Recursão tradicional, Recursão em cauda e Interação. Tais algoritmos foram usados em um pequeno benchmark.

public interface Fibonacci {
	public long calcula(long n);
}

1ª Algoritmo – Uso de interação:

public class AlgoritmoFibonnacciInterativo implements Fibonacci {

	public long calcula(long n){

		long anterior = -1;
		long resultado = 1;

		for(long i=0; i &amp;lt;= n; ++i){
			long soma = resultado + anterior;
			anterior = resultado ;
			resultado = soma;
		}
		return resultado;
	}
}

2ª Algoritmo – Uso de Recursão tradicional:

public class AlgoritmoFibonnacciRecursivo implements Fibonacci{

	public long calcula(long n){
		if(n==0||n==1){
			return n;
		}else{
			return calcula(n-1)+calcula(n-2);
		}
	}

}

3ª Algoritmo – Uso de Recursão em Cauda:

public class AlgoritmoFibonnacciTailRecursion implements Fibonacci{


	public long calcula(long n){
		return fibonnacci(n, 0, 1);
	}
	
	private long fibonnacci(long n, long primeiro, long segundo){
		if( n == 0 ){ 
			return primeiro;
		}
		return fibonnacci(n-1, segundo, primeiro+segundo);
                //Tailrecursion porque a chamada recursiva é a ultima instrução a ser executada.
	}

}

Benchmark

Nos testes apenas foram contabilizados o tempo dos métodos calcula(), desconsiderando o tempo de inicialização das classes e construtores. Cada teste foi realizado individualmente em um Intel Core 2 Duo CPU, E7500 2.93Chz, 4G 64Bits – Windows 7 Ultimate

O teste foi realizado na IDE Eclipse com o complemento ‘Eclipse Test & Performance Tools Platform Project’ (TPTP)

N Resultado Interativo (Segundos) Recursivo (Segundos) Tail Recursion (Segundos)
10 55 0,000005 0,001312 0,000103
20 6765 0,000005 0,483866 0,000171
25 75025 0,000006 5,037891 0,000211
30 832040 0,000005 0,000301
40 102334155 0,000005 0,000314
100 3736710778780430000 0,000007 0,000715
1000 817770325994397000 0,000026 0,007581

Referencias

http://blogs.msdn.com/b/chrsmith/archive/2008/08/07/understanding-tail-recursion.aspx

http://c2.com/cgi/wiki?TailRecursion

http://algol.dcc.ufla.br/~bruno/aulas/lp2/recursao.html

http://www.eclipse.org/tptp/

Estrutura de Dados e Algoritmos: Padrões de Projetos Orientados a Objetos Com Java – Livro

Recursividade

inceptionnaescola A recursão pode ser vista por muitos como um bicho de sete cabeça, porem muitas vezes a recursividade pode ser a melhor maneira de resolver um determinado problema, também pode ser a forma mais legível e simples do que a forma interativa.

Na programação a recursividade é um método que invoca a si próprio, ou seja uma função que se invoca recursivamente. De forma geral o problema é dividido em outros problemas menores até não existir mas nenhum problema para ser resolvido, para isso o compilador precisa armazenar as instruções, ponteiros e endereçamento na memoria Stack para cada chamada de método recursivo. Enquanto a recursividade ocorre a instrução atual, (antes da chamada recursiva), é congelada para dar vez ao próximo método recursivo, isso continua ocorrendo até que o próximo método recursivo termine.

Funcionamento

Conforme uma pilha, cada método fica aguardando o próximo terminar. O estado atual de cada método recursivo é guardado na memoria conforme a imagem a seguir.
recursao_1-1
Enquanto a chamada recursiva continua a memoria é consumida ate sua exaustão, quando isso ocorre um erro de StackOverflow é lançado. Por este motivo a recursão tradicional é menos eficiente que a iteração.

É possível aumentar a memoria alocada para as chamadas recursivas, no Java basta adicionar na vm o parametro -Xss256m, mas o problema continuará porem será postergado.

recursao_2

O estado do processamento dos métodos anteriores ficam na memoria até o fim de cada método recursivo.

Existe uma técnica chamada de Tail Recursion para evitar o consumo excessivo da memória Stack, que apresentarei no próximo post.

Ordenação por Counting Sort

O Counting Sort é um tipo de algoritmo utilizado para ordenar vetores de tipos inteiros onde os valores estão entre 0 e M-1. A ideia é utilizar recipientes para organizar e classificar os dados e então retorna-los. Este tipo de algoritmo faz uso de um vetor auxiliar, onde é feito a separação e numeração das ocorrências dos dados de entrada, a qual os valores do vetor são usados como índices em um outro vetor.

A implementação de um algorítimo de CountingSort requer varias operações, em geral são usados as seguintes etapas:

  • 1 – Inicializar os elementos do vetor auxiliar com zeros
  • 2 – Jogar os valores do vetor de entrada como índice no vetor auxiliar
  • 3 – Ordenar o vetor auxiliar não vazios
  • 4 – Transferir os valores do vetor auxiliar para o vetor de entrada

Exemplo do Algoritmo de Counting Sort em Java

public static void ordena(int[] a, int m){
		int n = a.length;
		
		int vetorAuxiliar[] = new int[m];
		
		//1ª - (Inicializar com zero)
		for(int i = 0; i < m; i++){
			vetorAuxiliar[i] = 0;
		}
		
		//2ª - Contagem das ocorrencias
		for(int i = 0; i < n; i++){
			vetorAuxiliar[a[i]]++;
		}

		//3ª - Ordenando os indices do vetor auxiliar
		int sum = 0;				
		for(int i = 1; i < m; i++){
			int dum = vetorAuxiliar[i];
			vetorAuxiliar[i] = sum;
			sum += dum;
		}		
		int vetorOrdenado[] = new int[n];
		for(int i = 0; i < n; i++){
			vetorOrdenado[vetorAuxiliar[a[i]]] = a[i];
			vetorAuxiliar[a[i]]++;
		}
		
		//4ª Retornando os valores ordenados para o vetor de entrada
		for (int i = 0; i < n; i++){
			a[i] = vetorOrdenado[i];
		}
	}

O algoritmo acima tem complexidade linear O(m+n) para valores inteiros, mesmo tendo acesso constante aos índices do vetor o algoritmo é eficiente para este tipo de problema. Note que o código acima não utiliza nenhum comando ‘if’ para ordenar o vetor. Concluo que o poder do algoritmo esta no fato de utilizar os próprios valores do vetor como índice em um outro vetor, desta forma que os valores ficam ordenados, porem a forma mais eficiente deste tipo de algoritmo se dá apenas com valores do tipo inteiro e que devem estar uniformemente espalhados no vetor de entrada para poder ser usado como índice.

Considerando um vetor com os dados {6,8,1,0,4,1,9,8,2,7}, o algoritmo apresentado realizará as seguintes operações:

exemplo_vetor_bs-pequeno

Referencia:
http://en.wikipedia.org/wiki/Counting_sort
http://www.cse.iitk.ac.in/users/dsrkg/cs210/applets/sortingII/countingSort/count.html
http://freevideolectures.com/Course/2501/COMP1927-Data-Structures-and-Algorithms/10
Estrutura de Dados e Algoritmos: Padrões de Projetos Orientados a Objetos Com Java – Livro

JPriuli Filter 2.0

Nesta nova versão, o projeto vem com novas funcionalidades para de deixar o código mais simples, mas também possui vários recursos para facilitar as consultas das entidades do Hiberbate ou JPA.
O projeto sofreu uma grande refatoração e por isto não mantem compatibilidade com a versão anterior. Porem, nesta nova versão existe a integração com o JPA2.

Segue, em ordem, as informações de como utilizar o projeto:

net.priuli.filter.Filter
Esta classe armazena os parâmetros que deverão ser usado como condições na sua consulta do JPA2 ou do Hibernate. Esta classe é um Map<String,Object> e a partir dela que as consultas são construídas.

net.priuli.filter.hibernate.CriteriaSelectBuilder
A classe acima transforma um ‘Filter’ em um objeto Criteria do Hibernate.

net.priuli.filter.jpa.QuerySelectBuilder
A classe acima transforma um ‘Filter’ em um objeto Query do JPA2.

Classes do pacote net.priuli.filter.criterion
São classes utilizadas para criar as condições e restrições da consulta, ou seja são os parâmetros que são adicionadas no objeto Filter.

Abaixo estão as classes do pacote ‘net.priuli.filter.criterion’:

  • Between.java – Adiciona uma condição Between no Filter
  • Fetch.java – Ativa o Hibernate/JPA Fetch
  • Ignore.java – Ignora uma condição dentro do Filter
  • JoinMode.java – Permite usar uma união (join) na query
  • Like.java – Adiciona uma condição like no Filter
  • LikeMode.java – Tipos do Like
  • Limiter.java – Permite limitar valores (maior,menor,igual)
  • LimiterMode.java – tipos do limite
  • NotEqual.java – Adiciona uma condição != no Filter
  • Order.java – Permite ordenar o resultado
  • OrderMode.java – Tipos de ordenação
  • Range.java – Permite paginar os resultados.
  • RangeLimitImpl.java – Tipo de paginação via limite
  • RangeSimpleImpl.java – Tipo de paginação normal

As classes abaixo são opcionais mas permitem construir uma classe Filter a partir de uma entidade, ou seja as classes abaixo copiam os valores não-nulos de uma entidade e criam um Filter com estes valores.

net.priuli.filter.hibernate.HibernateFilterBuilder
Constrói um Filter a partir de uma entidade do hibernate. Todas as informações não nulas da entidade serão convertidas em condições e carregadas no Filter, inclusive os relacionamentos (join).

net.priuli.filter.jpa.JPAFilterBuider
Constrói um Filter a partir de uma entidade do JPA2. Todas as informações não nulas da entidade serão convertidas em condições e carregadas no Filter, inclusive os relacionamentos (join).

Códigos

Criando consultas Hibernate

Exemplo hibernate

Filter filter = FactoryFilter.createFilter("phones.number", new Between<Long>(5683543L, 89548345L));</p>

filter.add(new Order("phones.number",OrderMode.ASC));
filter.add(new Order("name",OrderMode.ASC));

Criteria criteria = new CriteriaSelectBuilder<Person>(session,Person.class).build(filter);

List<Person> person = criteria.list();

O código acima ira gerar um Hql similar:

select p from Person p inner join Phone ph on ph.person = p.id where p.number between 5683543 and 89548345 order by p.name asc, ph.number asc

Exemplo JPA2

Filter filter = FactoryFilter.createFilter();
filter.add("name",  new Like("JOHN",LikeMode.START));

Query query = new QuerySelectBuilder<Person>(entityManager, Person.class).build(filter);
List<Person> people = query.getResultList();

O código acima ira gerar um hql similar:

select p from Person p where p.name like 'JOHN%'

Links:

Código de exemplos: Exemplos

Projeto(SVN,CODE,DOWNLOAD): JPriuliFilter Download

Agradecimentos: Flavio Henrique Faria (Tester)

JPriuli Filter 2.0 (English)

Priuli-Filter

 

Priuli-Filter is a project to facilitate the development of a system with ORM frameworks, allowing the module to search for entities of any system can be made ​​in a generic way, besides making it easier and more dynamic creation of ‘Selects’

How it works?

 

Having all the information required to load an object (entity), simply use the features of the filter to get these fields filled in and turn it into an object Criteria (Hibernate) or CriteriaBuilder (JPA2). The filter dynamically creates a Criteria \ CriteriaBuilder with all the restrictions found in an entity (Scanner) or implementing a Filter. Much like the Example.create () in Hibernate.

What should I know?

 

The filter is very simple to use, to conduct a search of an ‘entity’ is necessary to inform the filter, which fields should be used as search criteria, the filter created will inform the search criteria for ORM (Hibernate, Jpa2. ..)

Are three classes of design that make up the filter, they are:

 
net.priuli.filter

The Filter interface is a Map, it extends Map <String, Object>, and is used to store the information you entered as a condition for a WHERE query.
The interface can be used in several cases where there is need for some kind of filter.

 

net.priuli.filter.utils.HibernateUtils

This class has methods that make up a Filter to a Hibernate Criteria object. The data are processed in a Filter Restrictions and added to a Hibernate Criteria.

 

net.priuli.filter.utils.ScannerHibernateEntity

This class does something similar to Example.create (), it covers the attributes of an object and obtains the values ​​filled in to create some restrictions that will be used for a sql query. The difference is that this class can get the id of second object level that the ‘Example of Hibernate’ does not.

And the code?

A small and simple example to understand how the filter. First download the latest version of http://sourceforge.net/projects/priuli-filter/ sourceforge project, you can also see source code in svn, and the versions available.
 Now, imagine the following entities, Person and Phone, where Person can have a one phone, and phone can have n number of Person.

Person

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Phone

 

 

 

 

 

 

 

 

 

 

In its implementation of the DAO class, create a method that will return a list of people, from a the criteria of an implementation of a ‘Filter’, would look something like this:

 

 

 

 

 

HibernateUtils.buildCriteria(filter,session,persistentClass)  Filter will transform into a hibernate Criteria object containing all the restrictions that were in the filter.

Now we need to create the filter, for this we use class FactoryFilter.createFilter (), this class simply creates implementations of the interface ‘Filter’ can be used with hibernate or jpa..
We imagine that at some point we need to search in database, all persons who have the name ‘Steve’.

 

 

 

The above code, is the same as we execute this query:

SELECT * FROM PERSON WHERE NM_PERSON = ‘Steve’

Now imagine that there is a system screen, the user choose what he wants to filter, and JSF injecting the Entity containing the information that the user typed. In this scenario the filter can solve well:
Let see:

What you write and controller to inject the object, the ScannerJPAEntity will automatically add in a Filter, which will create the proper query with the right conditions. In the above we are always asking you to sort by name Order By Desc

Now imagine, if you need to create a new field in the Entity ‘Person’. just add this field in the query screen of your system, you simply create the field in the entity and creates on the screen, the method of filter you no longer have to move because the Filter detects the fields by reflection of the entity. This is a good advantage because you less  maintenance in code.

More  Example:

The example in this article ends here, the full sample can be obtained at this link:
http://sourceforge.net/projects/priuli-filter/files/examples/ExamplePriuliFilterStandalone.zip/download

Robocode – Primeiro Robô

Uma boa maneira de apreender a programar é jogando, esta é a minha ideia sobre este jogo. De maneira simples é possível aprender o básico de uma linguagem e ao mesmo tempo desenvolver o raciocino.

Robocode mistura o mundo de programação com competição. Tanto na linguagem Java como .Net, o jogo disponibiliza alguns códigos para facilitar o desenvolvimento dos robôs.

O que é o RoboCode ?

Robocode é um jogo de competição que permite que os robô do jogo sejam programáveis pelo usuário. O jogo fornece alguns métodos e classes que são usados na programação destes robôs, algumas classes tem mais recursos que outras, em geral temos a classe robocode.AdvancedRobot e a classe robocode.Robot

Antes da programação é necessário entender o básico do jogo. Primeiro, a regra é ganhar do oponente. Segundo, o robô na verdade é um tanque de guerra. Temos ainda mas três itens importante sobre o jogo, logo abaixo.


Movimentação – Os robôs têm três tipos de movimentos: o radar, a torre e a esteira, cada uma delas tem movimentos independentes.

Tiros – Os tiros são disparados pela torre e podem ter um dano diferente. Ao disparar é possível ajustar o dano do disparo, o método em Java para atirar é fire(1).

Munição – A munição é a própria energia do robô. Em outras palavras, se o robô atirar no oponente e errar o tiro o jogo irá descontar o tiro da energia do robô, mas caso o tiro acerte o jogo irá retirar a energia do oponente e adicionar no robô que acerto o alvo.

Quais os métodos ?

Os métodos necessários para criar um rodo do Robocode, estão descritos a seguir:

public void run()

Quando uma partida for iniciada pelo Robocode, o primeiro método a ser invocado será o método run() da classe do robô. Este método é onde seu código inicia e sempre deve estar em execução, em um loop até o final do jogo.

onScannedRobot(ScannedRobotEvent e)

O método onScannedRobot(ScannedRobotEvent e) é um dos mais importante para a lógica do seu robô, este método é invocado quando o radar encontrar algum alvo. No parâmetro deste método são enviadas as informações do alvo dentro do objeto ScannedRobotEvent, como por exemplo as informações de posição, nome, velocidade, distancia e outras informações do alvo. Com estas informações é possível calcular e montar uma boa estratégia

/**
*onScannedRobot: Quando o radar localizar um oponente o método será invocado.
*/
public void onScannedRobot(ScannedRobotEvent e){

	String nomeOponente = e.getName().;
	double posicaoRadar = getRadarHeading();
	double alvo = e.getBearing();
	double alvoVelocidade = e.getVelocity();
	double alvoDistancia = e.getDistance();

}

onHitWall(HitWallEvent e)

O método acima é invocado quando o robô bate na parede. A implementação deste método deve redirecionar o robô para que o mesmo não fique batendo na parede infinitamente.

onHitByBullet(HitByBulletEvent e)

Quando o robô levar um tiro do oponente este método será invocado. Aqui é possível fazer alguma estratégia para fugir dos tiros.

O Robocode possuí vários métodos, todos eles pode ser visto na documentação do jogo.


Criando meu primeiro robô

Primeiro vamos ‘Extender’ a classe Robot do Robocode, nela vamos sobrescrever o método run() e onScannedRobot(..). Primeiro vamos fazer o robô andar para frente, girar a torre 360 graus depois andar para traz, girar novamente a torre 360 graus e atirar no primeiro alvo que ele encontrar:

import robocode.*;

public class MyFirstRobot extends Robot {

	public void run(){
		setColors(Color.BLUE, Color.RED, Color.GRAY, Color.GREEN, Color.WHITE;
		while(true){
			ahear(100);//Move 100 pixels a frente
			turnGunRight(360);//vira a torre 360 graus a direita
			back(100);//anda 100 pixels para traz
			turnGunRight(360);////vira a torre 360 graus a direita
		}
	}

	public void onScannedRobot(ScannedRobotEvent e){
		fire(1);//Disparando tiro de dado 1;
	}

}

Links para competição: LIGA. FT – Unicamp
Robô para download: PriuliDestroyer – Primeira versão do robô do Felipe Priuli
Referencia: Robowiki.net Robocode Sourceforge
Repositório de Robos: Robocode Repository

Atualizado em 01/01/2012