Can someone help me with this,
I am right now working on a Snake program and I want to move the snake forward with the move forward, how can I do this ?
I am right now working on a Snake program and I want to move the snake forward with the move forward, how can I do this ?
Java:
public class Queue<ContentType> {
/* --------- Anfang der privaten inneren Klasse -------------- */
public class QueueNode {
private ContentType content = null;
private QueueNode nextNode = null;
/**
* Ein neues Objekt vom Typ QueueNode<ContentType> wird erschaffen.
* Der Inhalt wird per Parameter gesetzt. Der Verweis ist leer.
*
* @param pContent das Inhaltselement des Knotens vom Typ ContentType
*/
public QueueNode(ContentType pContent) {
content = pContent;
nextNode = null;
}
/**
* Der Verweis wird auf das Objekt, das als Parameter uebergeben wird,
* gesetzt.
*
* @param pNext der Nachfolger des Knotens
*/
public void setNext(QueueNode pNext) {
nextNode = pNext;
}
/**
* Liefert das naechste Element des aktuellen Knotens.
*
* @return das Objekt vom Typ QueueNode, auf das der aktuelle Verweis zeigt
*/
public QueueNode getNext() {
return nextNode;
}
/**
* Liefert das Inhaltsobjekt des Knotens vom Typ ContentType.
*
* @return das Inhaltsobjekt des Knotens
*/
public ContentType getContent() {
return content;
}
}
/* ----------- Ende der privaten inneren Klasse -------------- */
public QueueNode head;
protected QueueNode tail;
/**
* Eine leere Schlange wird erzeugt.
* Objekte, die in dieser Schlange verwaltet werden, muessen vom Typ
* ContentType sein.
*/
public Queue() {
head = null;
tail = null;
}
/**
* Die Anfrage liefert den Wert true, wenn die Schlange keine Objekte enthaelt,
* sonst liefert sie den Wert false.
*
* @return true, falls die Schlange leer ist, sonst false
*/
public boolean isEmpty() {
if (head == null) {
return true;
}
else {
return false;
}
}
/**
* Das Objekt pContentType wird an die Schlange angehaengt.
* Falls pContentType gleich null ist, bleibt die Schlange unveraendert.
*
* @param pContent
* das anzuhaengende Objekt vom Typ ContentType
*/
public void enqueue(ContentType pContent) {
if (pContent != null) {
QueueNode newNode = new QueueNode(pContent);
if (this.isEmpty()){
head = newNode;
tail = newNode;
}
else {
tail.setNext(newNode);
tail = newNode;
}
}
}
/**
* Das erste Objekt wird aus der Schlange entfernt.
* Falls die Schlange leer ist, wird sie nicht veraendert.
*/
public void dequeue() {
if(!this.isEmpty()){
head = head.getNext();
}
}
/**
* Die Anfrage liefert das erste Objekt der Schlange.
* Die Schlange bleibt unveraendert.
* Falls die Schlange leer ist, wird null zurueckgegeben.
*
* @return das erste Objekt der Schlange vom Typ ContentType oder null,
* falls die Schlange leer ist
*/
public ContentType front() {
if (this.isEmpty()){
return null;
} else {
return head.getContent();
}
}
private void pause() {
try {
Thread.sleep(500);
} catch(Exception e) {}
}
}
Java:
public class SnakeContent
{
private int x,y;
public SnakeContent(int x,int y){
this.x=x;
this.y=y;
}
public int X(){
return x;
}
public int Y(){
return y;
}
public void move(int dx,int dy){
x=x+dx;
y=y+dy;
}
public void setX(int x){this.x=x;}
public void setY(int y){this.y=y;}
@Override
public String toString(){
return "X: "+x+" "+"Y: "+y;
}
}
Java:
public class Snake
{
private Queue<SnakeContent> snakequeue=new Queue<SnakeContent>();
public SnakeContent head;
private SnakeContent[] temp;
/**
* Konstruktor für Objekte der Klasse Snake
*/
public Snake(int x,int y)
{
head=new SnakeContent(x,y);
snakequeue.enqueue(head);
for(int i=1;i<=10;i++){
insertSnakeContent(new SnakeContent(x+i,y));
}
}
public Queue<SnakeContent> getSnakeQueue(){
return snakequeue;
}
public void insertSnakeContent(SnakeContent content){
snakequeue.enqueue(content);
}
}