projekt gry, przyłączanie ogona

Cześć,
piszę na zaliczenie grę, która ma działać podobnie jak snake. Typ chodzi i zbiera zwierzęta z pola, które powinny być przyłączane do jego 'ogona'.
Tyle udało mi się napisać:

 
import java.awt.Color;
import javax.swing.JFrame;




public class Schronisko extends JFrame {
	public Schronisko(){
		add(new Pole());
        setBackground(Color.black);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(17*40, 14*40);
        setLocationRelativeTo(null);
        setTitle("SCHRONISKO");
        setResizable(false);
        setVisible(true);
        Pole.rysuj();
	}
	
	
	public static void main(String[] args){
		new Schronisko();
		
	}

}

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;

import javax.swing.ImageIcon;
import javax.swing.JPanel;


public class Pole extends JPanel  {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	static int pole[][] = new int[13][17];
	Image cegla;
	Image kot;
	Image pies;
	Image head;
	private Ruch ruch1= new Ruch(this);
	
	public Pole(){
		this.setFocusable(true);
		addKeyListener(ruch1);
	}
	public static void rysuj(){
		int tablica[][]={
		{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
    	        {1,0,0,3,0,3,0,0,0,3,1,1,1,0,0,3,1},
    	        {1,0,0,0,0,3,0,0,0,3,1,0,0,0,0,0,1},
    	        {1,0,0,3,0,3,0,0,0,3,1,0,1,0,0,3,1},
    	        {1,0,0,0,0,3,0,0,0,3,1,0,1,0,0,0,1},
    	        {1,0,0,3,0,3,0,0,0,0,0,0,1,0,0,3,1},
    	        {1,0,0,0,0,3,0,0,0,0,0,1,1,0,0,0,1},
    	        {1,0,0,0,0,0,0,0,4,0,0,1,1,0,0,3,1},
    	        {1,0,0,0,0,3,0,0,0,0,0,1,1,0,0,0,1},
    	        {1,0,0,0,0,3,0,0,0,3,0,1,1,0,0,3,1},
    	        {1,0,0,0,0,3,0,0,0,3,0,0,0,0,0,0,1},
    	        {1,0,0,0,0,3,0,0,0,0,0,0,0,0,0,3,1},
    	        {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}
		};
		for (int i = 0; i< tablica.length; i++){
	    	for (int j =0; j<tablica[i].length; j++ ) {
	    		Pole.pole[i][j] = tablica[i][j];
	    	}
		}
	}
	public void paint(Graphics g) {
		
		ImageIcon iic = new ImageIcon(this.getClass().getResource("cegłam.png"));
		cegla = iic.getImage();
		ImageIcon iid = new ImageIcon(this.getClass().getResource("kotzm.png"));
	    kot = iid.getImage();

	    ImageIcon iia = new ImageIcon(this.getClass().getResource("kotbm.png"));
	    pies = iia.getImage();
	            
	    ImageIcon iih = new ImageIcon(this.getClass().getResource("smm.png"));
	    head = iih.getImage();
	    	rysujPole(g);
	}
	    	public void rysujPole(Graphics g){
	    		
	        	for (int i=0; i<pole.length; i++){
	        		for (int j=0; j<pole[0].length; j++){
	        			switch(pole[i][j])
	        			{
	        			case 0:
	        				g.setColor(Color.BLACK);
	        				g.fillRect(40*j, 40*i, 40, 40);
	        				break;
	        			case 1:
	        				g.drawImage(cegla, 40*j,  40*i, this);
	        				break;
	        			case 2:
	        				g.drawImage(kot, 40*j,  40*i, this);
	        				break;
	        			case 3:
	        				g.drawImage(pies, 40*j,  40*i, this);
	        				break;
	        			case 4:
	        					g.drawImage(head, 40*j,  40*i, this);
	        				break;
	        				
	        			
	        			}
	        		
	        		}
	        	}
	        }

	
}

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class Ruch implements KeyListener {
	private Pole pole1;
	int poz1 = 7;
	int poz2 = 8;
	public Ruch(Pole pole1) {
		this.pole1= pole1;// TODO Auto-generated constructor stub
	}

	public void kierunek(){
		
		
	}
	
	public void keyPressed(KeyEvent e) {
	    		
	        	int key = e.getKeyCode();
	        	switch(key){
	        	
	        	case KeyEvent.VK_LEFT:
	        		if(Pole.pole[poz1][poz2-1]==0)
	        		{
	        			Pole.pole[poz1][poz2-1]=4;
	        			Pole.pole[poz1][poz2]=0;
	        			poz2--;
	        		}
	        		else if((Pole.pole[poz1][poz2-1]==3))
	        		{
	        			//dodaj
	        		}
	        		else if((Pole.pole[poz1][poz2-1]==1))
	        		{
	        			//KONIEC
	        		}
	        		break;
	        	case KeyEvent.VK_UP:
	        		if(Pole.pole[poz1-1][poz2]==0)
	        		{
	        			Pole.pole[poz1-1][poz2]=4;
	        			Pole.pole[poz1][poz2]=0;
	        			poz1--;
	        		}
	        		break;
	        	case KeyEvent.VK_RIGHT:
	        		if(Pole.pole[poz1][poz2+1]==0)
	        		{
	        			Pole.pole[poz1][poz2+1]=4;
	        			Pole.pole[poz1][poz2]=0;
	        			poz2++;
	        		}
	        		break;
	        	case KeyEvent.VK_DOWN:
	        		if(Pole.pole[poz1+1][poz2]==0 )
	        		{
	        			Pole.pole[poz1+1][poz2]=4;
	        			Pole.pole[poz1][poz2]=0;
	        			poz1++;
	        		}
	        		break;
	        	}
	        	pole1.repaint();
	        }

			@Override
			public void keyReleased(KeyEvent e) {
				// TODO Auto-generated method stub
				
			}

			@Override
			public void keyTyped(KeyEvent e) {
				// TODO Auto-generated method stub
				
			}
		


}

W klasie ruch możliwy jest już ruch typka po całej planszy. Ale nie umiem rozwiązać problemu jak po 'spotkaniu' ze zwierzęciem, ma sie ono w tej tablicy dwuwymiarowej przyłączyć do typka i podążać za nim.. proszę o pomoc

Stwórz klasę Point, która będzie przechowywała współrzędne X i Y. Stwórz klasę SnakeElement, która będzie dziedziczyła po tej klasie, SnakeFood to samo. I jakąś główną klasę w której zdefiniujesz sobie metodę odpowiedzialną za ruch. W tej metodzie sprawdzaj czy pozycja głowy węża równa się pozycji jedzenia, jeżeli tak, to dodaj nowy element do tablicy/listy aż w końcu w metodzie odpowiedzialnej za wizualizację tego wszystkiego napisz, że jeżeli długość węża jest równa 1, to wyświetlam 1 element(obrazek, kwadracik), jeżeli 2 to 2. Tak w OGÓLNYM skrócie.

Pomijając juz sam kod - przemyśl sobie to: czym innym jest plansza po której się poruszasz, a czym innym ten Twój wąż. O ile do przechowywania planszy z jej statyczną zawartością (cegły, koty itp.) tablica jest dobra, to stworzy same problemy jeśli chcesz (i to jeszcze w tej samej tablicy) przechowywać pozycję/rozłożenie swojego węża. Osobno rysujesz planszę, osobno rysujesz węża.

Tu już nawet w tej najprostszym wariancie nie jest potrzebne tworzenie nowych klas, ale wykorzystanie istniejących możliwości. Przechowywanie pozycji wszystkich elementów węża (na początku sama głowa, później w miarę jedzenia dodajesz kolejne człony powinna wystarczyć lista:

LinkedList<Point> snake = new LinkedList<Point>();
snake.add(new Point(8, 8));

W ten sposób masz już "pojemnik" na węża i od razu ustawiony pierwszy człon, którym się poruszasz. Poruszanie się czymś takim na planszy jest banalne - dodajesz na początku listy nowy punkt, jaki wynika z wykonanego ruchu, a ostatni element z listy usuwasz (ew. rysujesz w tym miejscu na planszy pustem miejsce - zamazujesz to co się przesuwa do przodu), tym samym wąż "zrobi krok do przodu". Rysujesz przechodząc po kolei przez elementy listy rysując węża na kolejnych punktach, które ta lista przechowuje.

Jeśli chodzi o powiększanie węża, kiedy natrafi na jedzenie - po wykonaniu ruchu sprawdzasz sobie co jest w tablicy na pozycji jaka została zapamiętana w pierwszym elemencie tablicy, czyli coś w stylu:

Point head = snake.getFirst();
int value = tablica[head.x][head.y];

Sprawdzasz co ten value reprezentuje (jeśli cegłę, to zapewne kończysz grę). Jeśli jakiś "pokarm", to masz powód, żeby przedłużać węża, tutaj tylko pytanie, czy będziesz go za każdym razem przedłużał o jedną jednostkę, czy np. za kota dasz dwie a za psa trzy - to już zależy od Ciebie. Tyle razy o ile ma się wydłużyć wąż pomijasz sobie wtedy ten punkt, o którym wcześniej pisałem: a ostatni element z listy usuwasz. Ot, wsio... ;)

To może takie nie do końca bardzo poprawne rozwiązanie, ale względnie łatwe do "wytłumaczenia" i zastosowania :]