Para cortar a imagem, em tamanhos iguais, faça assim:
[code]
/**
* Split the given image into several smaller equally sized parts. The parts
* are numbered sequentially from left to right and top to down.
*
* @param img The image to be splited.
* @param columns Number of columns to split the original image.
* @param lines Number of lines to split the original image
* @return An array, containing the splited result.
* @throws IllegalArgumentException If the image is null or if columns or
* lines are equal or less than zero.
*/
public BufferedImage[] splitImage(BufferedImage img, int columns, int lines)
{
if (img == null)
throw new IllegalArgumentException("You must provide an image to split!");
if (columns < 0 || lines < 0)
throw new IllegalArgumentException("Columns or lines must be greater than zero!");
if (columns == 1 && lines == 1)
return new BufferedImage[] {img};
BufferedImage[] result = new BufferedImage[columns * lines];
int width = img.getWidth() / columns;
int height = img.getHeight() / lines;
int count = 0;
for (int col = 0; col < columns; col++)
for (int lin = 0; lin < lines; lin++)
{
BufferedImage copy = BufferedImage copy = new BufferedImage(width, height,
img.getTransparency());
Graphics2D surface = copy.createGraphics();
surface.drawImage(img,
0,
0,
width,
height,
width * col,
height * lin,
(width * col) + width,
(height * lin) + height,
null);
surface.dispose();
result[count++] = copy;
}
return result;
}[/code]
Esse método monta um vetor, contendo em cada índice uma parte da imagem.
Eu montei esse método quando desenvolvi o meu jogo, que pode ser baixado com os fontes no tópico:
http://www.guj.com.br/posts/list/48344.java
Dê uma olhada na classe ImageWorker, que tem várias coisas úteis desse tipo.
Quanto ao flicking. Essa é uma questão delicada. Tudo vai depender da taxa de frames por segundo que você estiver mantendo. Não tente colocar uma taxa maior que 75, pois esse é o máximo que um monitor pode desenhar.
Além disso, pesquise sobre a classe BufferStrategy. Ela permite que você faça a sua aplicação com double buffering, evitando não só o flicking como também o tearing.
E, como na dica que te passei, leia atentamente os primeiros capítulos do livro Killer Game Programming in Java.
http://fivedots.coe.psu.ac.th/~ad/jg/
Uma excelente dica (explicada no capítulo 2 do Killer) é separar a taxa de frames por segundo da taxa de updates por segundo.
Se for comprar esse livro na Amazon (eu fiz isso), compre também o livro Developing Games in Java, do Brackeen. Enquanto o Killer é mais teórico e se atém mais aos conceitos, o Brackeen é mais prático. Outra coisa interessante é que cada um implementa uma técnica para controlar o Animation Framework (parte mais importante do jogo). Eu particularmente prefiro a técnica do Killer, que é fazer uma classe que mantenha a taxa de updates por segundo constante e evitar calculos com diferenças de tempo pela aplicação inteira.