This site requires JavaScript, please enable it in your browser!
Greenfoot back
kingderkilla
kingderkilla wrote ...

2014/3/22

Can someone help me with my game?

kingderkilla kingderkilla

2014/3/22

#
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();      
}
}

}
kingderkilla kingderkilla

2014/3/22

#
[Disallowed URL]
kingderkilla kingderkilla

2014/3/22

#
[Disallowed URL]
kingderkilla kingderkilla

2014/3/22

#
You need to login to post a reply.