hello im a newbie and im programming a snake game. but how i can set a counter which counts my eaten objects and show it after the time is up? oh and how i can set a timer?(smt like this= u have 60 sec time to eat as much as u can and after this the game will stop and the counter shows the eaten object(f.e. 12).? heres my code
import greenfoot.*; // (World, Actor, GreenfootImage, and Greenfoot)
import java.util.List;
import javax.swing.JOptionPane;
import java.awt.Color;
import java.awt.Graphics;
/**
* Klasse für Spinnen-Welt-Objekte.
*/
public class SpinnenWelt extends World
{
/**
* Erzeugt eine Welt mit 20x15 Feldern der Größe 40.
* Die Welt ist mit gelben Bodenplatten belegt und von Hindernissen umrahmt.
*/
public SpinnenWelt() {
super(400, 300, 1);
setBackground("hintergrund.jpg");
randZiehen();
schlangeSetzen();
randomEssen();
}
/**
* Erzeugt eine Welt mit breite x hoehe Feldern der Größe 40.
* Die Welt ist mit gelben Bodenplatten belegt und von Hindernissen umrahmt.
* @param breite die Breite der Welt
* @param hoehe die Höhe der Welt
*/
public SpinnenWelt(int breite, int hoehe) {
super(breite, hoehe, 40);
randZiehen();
}
/**
* Setzt ein Hindernis auf (x,y) sofern der Platz innerhalb der Welt liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void hindernisSetzen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
addObject(new Hindernis(),x,y);
}
}
/**
* Entfernt ein Hindernis von (x,y) sofern der Platz innerhalb der Welt liegt und dort eins liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void hindernisEntfernen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
List hindernisse = getObjectsAt(x,y,Hindernis.class);
if(hindernisse.size() > 0) {
removeObject((Actor)hindernisse.get(0));
}
}
}
/**
* Setzt eine Klatsche auf (x,y) sofern der Platz innerhalb der Welt liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void klatscheSetzen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
addObject(new Klatsche(),x,y);
}
}
/**
* Entfernt eine Klatsche von (x,y) sofern der Platz innerhalb der Welt liegt und dort eine liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void klatscheEntfernen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
List klatschen = getObjectsAt(x,y,Klatsche.class);
if(klatschen.size() > 0) {
removeObject((Actor)klatschen.get(0));
}
}
}
/**
* Setzt eine Fliege auf (x,y) sofern der Platz innerhalb der Welt liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void fliegeSetzen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
addObject(new Fliege(),x,y);
}
}
/**
* Entfernt eine Fliege von (x,y) sofern der Platz innerhalb der Welt liegt und dort eine liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void fliegeEntfernen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
List fliegen = getObjectsAt(x,y,Fliege.class);
if(fliegen.size() > 0) {
removeObject((Actor)fliegen.get(0));
}
}
}
/**
* Setzt eine Spinne ohne Fliegen auf (x,y) sofern der Platz innerhalb der Welt liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void spinneSetzen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
addObject(new Spinne(),x,y);
}
}
/**
* Setzt eine Spinne mit einer gegebenen Anzahl Fliegen auf (x,y) sofern der Platz innerhalb der Welt liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void spinneSetzen(int x, int y, int fliegen) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
addObject(new Spinne(fliegen),x,y);
}
}
/**
* Entfernt eine Spinne von (x,y) sofern der Platz innerhalb der Welt liegt und dort eine liegt.
* @param x die Spalte
* @param y die Zeile
*/
public void spinneEntfernen(int x, int y) {
if(!(x < 1 || x > getWidth() -2 || y < 2 || y > getHeight() -2)) {
List spinnen = getObjectsAt(x,y,Spinne.class);
if(spinnen.size() > 0) {
removeObject((Actor)spinnen.get(0));
}
}
}
private void randZiehen() {
for(int i=0;i<getWidth();i++) {
addObject(new Hindernis(),i,0);
addObject(new Hindernis(),i,getHeight()-1);
}
for(int i=1;i<getHeight();i++) {
addObject(new Hindernis(),0,i);
addObject(new Hindernis(),getWidth()-1,i);
}
}
public void act(){
}
public void schlangeSetzen(){
addObject(new schlange(),10,10);
}
public void randomEssen(){
addObject(new Fliege(),130,150);
}
}import greenfoot.*; // (World, Actor, GreenfootImage, and Greenfoot)
import java.util.List;
import javax.swing.JOptionPane;
//import java.io.*;
/**
* Klasse für Objekte vom Typ Spinne.
* @author Mathias Müller
* @version 29.08.2006
*/
public class Spinne extends Actor
{
private int aktionenProSekunde;
private int fliegen;
private boolean nachrichten;
private boolean geklatscht;
/**
* Erzeugt ein Spinne-Objekt ohne Fliegen mit 4 Aktionen pro Sekunde.
*/
public Spinne()
{
aktionenProSekunde = 90;
fliegen = 0;
nachrichten = true;
geklatscht = false;
}
/**
* Erzeugt ein Spinne-Objekt mit einer gegebenen Anzahl Fliegen und 4 Aktionen pro Sekunde.
* @param fliegen die Anzahl der gefressenen Fliegen
*/
public Spinne(int fliegen)
{
aktionenProSekunde = 200;
if(fliegen < 0) {
fliegen = 0;
}
this.fliegen = fliegen;
nachrichten = true;
geklatscht = false;
}
/**
* Die Spinne dreht sich um 90° entgegen dem Uhrzeigersinn. Wirkungslos bei geklatschter Spinne.
*/
public void linksDrehen() {
if(!geklatscht) {
pause();
setRotation((getRotation()+270) % 360);
pause();
}
}
/**
* Die Spinne dreht sich um 90° im Uhrzeigersinn. Wirkungslos bei geklatschter Spinne.
*/
public void rechtsDrehen() {
if(!geklatscht) {
pause();
setRotation((getRotation()+90) % 360);
pause();
}
}
/**
* Die Spinne geht einen Schritt in Blickrichtung, wenn sie nicht vor einem Hindernis steht. Wirkungslos bei geklatschter Spinne.
* Läuft sie dabei auf eine Klatsche, wird sie geklatscht.
*/
public void schritt() {
if(!geklatscht) {
//pause();
//warten(100);
boolean kv = klatscheVorn();
int richtung = getRotation();
int x = 0;
int y = 0;
switch(richtung) {
case 0:
x = getX() + 1;
y = getY();
break;
case 90:
x = getX();
y = getY()+1;
break;
case 180:
x = getX()-1;
y = getY();
break;
case 270:
x = getX();
y = getY()-1;
break;
}
if(!hindernisVorn()) {
setLocation(x,y);
if(kv) {
geklatscht = true;
setImage("images/thekla_geklatscht.png");
warten(100);
if(nachrichten) {
JOptionPane.showMessageDialog(null,"Die Spinne wurde geklatscht.","Fehler",JOptionPane.ERROR_MESSAGE);
}
}
pause();
}
else {
if(nachrichten) {
JOptionPane.showMessageDialog(null,"GAME OVER.","Fehler",JOptionPane.ERROR_MESSAGE);
Greenfoot.setWorld(new SpinnenWelt());
}
}
}
}
/**
* Die Spinne frisst eine Fliege, falls mindestens eine auf dem Platz liegt. Wirkungslos bei geklatschter Spinne.
*/
public void fliegeFressen() {
if(!geklatscht) {
pause();
Actor fliege = getOneObjectAtOffset(0,0,Fliege.class);
if(fliege != null) {
fliegen++;
getWorld().removeObject(fliege);
pause();
}
else {
if(nachrichten) {
JOptionPane.showMessageDialog(null,"Auf dem Platz liegt keine Fliege.","Fehler",JOptionPane.ERROR_MESSAGE);
}
}
}
}
/**
* Die Spinne wird mit anzahl zusŠtzlichen Fliegen gefŸttert. Wirkungslos bei geklatschter Spinne.
*/
public void fliegenFuettern(int anzahl) {
if(!geklatscht) {
fliegen +=anzahl;
}
}
/**
* Die Spinne spuckt eine Fliege aus, falls sie mindestens eine gefressen hat. Wirkungslos bei geklatschter Spinne.
*/
public void fliegeAusspucken() {
if(!geklatscht) {
pause();
if(fliegen>0) {
getWorld().addObject(new Fliege(),getX(),getY());
setLocation(getX(),getY());
fliegen--;
pause();
}
else {
if(nachrichten) {
JOptionPane.showMessageDialog(null,"Die Spinne hat keine Fliege gefressen.","Fehler",JOptionPane.ERROR_MESSAGE);
}
}
}
}
/**
* Prüft, ob auf dem Platz vor der Spinne eine Klatsche lauert.
* @return true: Klatsche, false: keine Klatsche, bei geklatschter Spinne: immer false
*/
public boolean klatscheVorn() {
if(!geklatscht) {
int dx = 0;
int dy = 0;
int richtung = getRotation();
switch(richtung) {
case 0:
dx = 1; break;
case 90:
dy = 1; break;
case 180:
dx = -1; break;
case 270:
dy = -1; break;
}
Actor klatsche = getOneObjectAtOffset(dx,dy,Klatsche.class);
return klatsche != null;
}
else {
return false;
}
}
/**
* Prüft, ob auf dem Platz vor der Spinne ein Hindernis liegt.
* @return true: Hindernis, false: kein Hindernis, bei geklatschter Spinne: immer false
*/
public boolean hindernisVorn() {
if(!geklatscht) {
int dx = 0;
int dy = 0;
int richtung = getRotation();
switch(richtung) {
case 0:
dx = 1; break;
case 90:
dy = 1; break;
case 180:
dx = -1; break;
case 270:
dy = -1; break;
}
Actor klatsche = getOneObjectAtOffset(dx,dy,Hindernis.class);
return klatsche != null;
}
else {
return false;
}
}
/**
* Prüft, ob rechts neben der Spinne ein Hindernis liegt.
* @return true: Hindernis, false: kein Hindernis, bei geklatschter Spinne: immer false
*/
public boolean hindernisRechts() {
if(!geklatscht) {
int dx = 0;
int dy = 0;
int richtung = getRotation();
switch(richtung) {
case 0:
dy = 1; break;
case 90:
dx = -1; break;
case 180:
dy = -1; break;
case 270:
dx = 1; break;
}
Actor klatsche = getOneObjectAtOffset(dx,dy,Hindernis.class);
return klatsche != null;
}
else {
return false;
}
}
/**
* Prüft, ob links neben der Spinne ein Hindernis liegt.
* @return true: Hindernis, false: kein Hindernis, bei geklatschter Spinne: immer false
*/
public boolean hindernisLinks() {
if(!geklatscht) {
int dx = 0;
int dy = 0;
int richtung = getRotation();
switch(richtung) {
case 0:
dy = -1; break;
case 90:
dx = 1; break;
case 180:
dy = 1; break;
case 270:
dx = -1; break;
}
Actor klatsche = getOneObjectAtOffset(dx,dy,Hindernis.class);
return klatsche != null;
}
else {
return false;
}
}
/**
* Prüft, ob auf dem Platz der Spinne mindestens eine Fliege liegt.
* @return true: Fliege(n) am Platz, false: keine Fliegen am Platz, bei geklatschter Fliege: immer false
*/
public boolean fliegeAmPlatz() {
if(!geklatscht) {
Actor fliege = getOneObjectAtOffset(0,0,Fliege.class);
return fliege != null;
}
else {
return false;
}
}
/**
* Liefert die Anzahl der Fliegen auf dem Platz der Spinne.
* @return die Anzahl der Fliegen auf Platz der Spinne, bei geklatschter Spinne: immer 0
*/
public int fliegenAmPlatz() {
if(!geklatscht) {
List fliegen = getObjectsAtOffset(0,0,Fliege.class);
return fliegen.size();
}
else {
return 0;
}
}
/**
* Prüft, ob die Spinne mindestens eine Fliege gefressen hat.
* @return true: Fliege(n) gefressen, false: keine Fliege gefressen, bei geklatschter Spinne: immer false
*/
public boolean fliegeGefressen() {
if(!geklatscht) {
return fliegen > 0;
}
else {
return false;
}
}
/**
* Liefert die Anzahl der Fliegen, die die Spinne gefressen hat.
* @return die Anzahl der Fliegen, die die Spinne gefressen hat, bei geklatschter Spinne: immer 0
*/
public int fliegenGefressen() {
if(!geklatscht) {
return fliegen;
}
else {
return 0;
}
}
/**
* Schaltet die Anzeige von Fehlern und Warnungen ein.
*/
public void nachrichtenZeigen() {
if(!geklatscht) {
nachrichten = true;
}
}
/**
* Schaltet die Anzeige von Fehlern und Warnungen aus.
*/
public void nachrichtenVerbergen() {
if(!geklatscht) {
nachrichten = false;
}
}
/**
* Legt das Tempo der Programmausführung fest.
* @param die Anzahl der Aktionen pro Sekunde
*/
public void tempo(int aktionenProSekunde) {
this.aktionenProSekunde = aktionenProSekunde;
}
/**
* Die Spinne unterbricht die Programmausführung für eine gegebene Zeit.
* @param die Länge der Unterbrechung in Millisekunden
*/
public void warten(int milliSekunden) {
try {
Thread.sleep(milliSekunden);
greenfoot.core.WorldHandler.getInstance().repaint();
}
catch(InterruptedException ie) {
}
}
private void pause() {
try {
Thread.sleep(500/aktionenProSekunde);
greenfoot.core.WorldHandler.getInstance().repaint();
}
catch(InterruptedException ie) {
}
}
/*public void weltSpeichern(String name)
throws FileNotFoundException,IOException {
FileOutputStream fos = new FileOutputStream(name);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(getWorld());
}
public void weltLesen(String name)
throws FileNotFoundException,IOException,ClassNotFoundException {
FileInputStream fos = new FileInputStream(name);
ObjectInputStream oos = new ObjectInputStream(fos);
SpinnenWelt temp = (SpinnenWelt)oos.readObject();
super.setWorld(null);
}*/
public void act() {
}
}import greenfoot.*; // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)
/**
* Write a description of class schlange here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class schlange extends Spinne
{
public void act(){
schritt();
bewegen();
if(fliegeAmPlatz()){
fliegeFressen();
getWorld().addObject(new Fliege(), Greenfoot.getRandomNumber(getWorld().getWidth()), Greenfoot.getRandomNumber(getWorld().getHeight()));
}
}
public void essen(){
if(fliegeAmPlatz()){
fliegeFressen();
}
}
public void schleife(){
if(!hindernisVorn()){
schritt();
}
}
public void bewegen()
{ if(Greenfoot.isKeyDown("left")){
setRotation(180);
schritt();
}
if(Greenfoot.isKeyDown("right")){
setRotation(0);
schritt();
}
if(Greenfoot.isKeyDown("up")){
setRotation(-90);
schritt();
}
if
(Greenfoot.isKeyDown("down")){
setRotation(90);
schritt();
}
{
schritt();
}
}
}
