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

2017/3/19

java.lang.OutOfMemoryError: Java heap space

heyu heyu

2017/3/19

#
I get the following error : 
java.lang.OutOfMemoryError: Java heap space
	at java.awt.image.DataBufferInt.<init>(DataBufferInt.java:75)
	at java.awt.image.Raster.createPackedRaster(Raster.java:467)
	at java.awt.image.DirectColorModel.createCompatibleWritableRaster(DirectColorModel.java:1032)
	at java.awt.GraphicsConfiguration.createCompatibleImage(GraphicsConfiguration.java:186)
	at greenfoot.util.GraphicsUtilities.createCompatibleTranslucentImage(GraphicsUtilities.java:189)
	at greenfoot.GreenfootImage.<init>(GreenfootImage.java:130)
	at greenfoot.World.setBackground(World.java:160)
	at greenfoot.World.<init>(World.java:128)
	at greenfoot.World.<init>(World.java:108)
	at Wiese.<init>(Wiese.java:23)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
	at Pattern.<init>(Pattern.java:14)
	at Wiese.<init>(Wiese.java:191)
That is my code: 
import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Diese Klasse erstellt eine Welt für Kara. Sie enthaelt Einstellungen ueber
 * die Hoehe und Breite der Welt und initialisiert alle Actors.
 * 
 * @author Marco Jakob
 * @version 04.04.2011
 */
public class Wiese extends World 
{
    private static final int WORLD_WIDTH = 9;  // Anzahl der Zellen horizontal
    private static final int WORLD_HEIGHT = 25;  // Anzahl der Zellen vertikal

    private static final int CELL_SIZE = 28; // Groesse einer einzelnen Zelle

    /**
     * Erstellt eine Welt fuer Kara.
     */
    public Wiese() 
    {
        // Erzeugt eine neue Welt
        super(WORLD_WIDTH, WORLD_HEIGHT, CELL_SIZE);

        setPaintOrder(Kara.class, Tree.class, Mushroom.class, Leaf.class);
        Greenfoot.setSpeed(43);

        // Erzeuge die Anfangs-Objekte fuer die Welt.
        prepare();
    }
    
    public int getWorldHöhe()
    {
        return WORLD_HEIGHT;
    }
    
    public int getWorldBreite()
    {
        return WORLD_WIDTH;
    }
    
    
    
    public void runterLaufen(NxLvTree b)
    {
        boolean erstesMal = true;
        
        if(b.getLocationY() >= 0 && !b.isTreeGesetzt())
        {
            if(b.getLocationY() <= 24)
            {
                addObject(b,b.getLocationX(),b.getLocationY());
            }
            b.setTreeGesetzt();
            b.turn(90); b.move(1); b.turn(-90); 
        }
        else if(b.getLocationY() >= 24 && b.isTreeGesetzt())
        {
            removeObject(b);
            b.setTreeGesetzt();
        }
        else if(b.getLocationY() > 0 && b.getLocationY() < 24 && b.isTreeGesetzt()) 
        {
            b.turn(90); b.move(1); b.turn(-90);    
        }
        b.setLocationY();
    }
    
    /**
     * Bereite die Welt fuer den Programmstart vor. Das heisst: Erzeuge die Anfangs-
     * Objekte und fuege sie der Welt hinzu.
     * 
     * Tipp: Die Objekte zuerst mit der Maus in der Welt platzieren. Anschliessend 
     * Rechtsklick auf die Welt, dann 'Die Welt speichern' auswaehlen. So werden alle
     * Objekte automatisch in diese Methode geschrieben.
     */
    private void prepare() 
    {
        Tree tree = new Tree();
        addObject(tree,0,24);
        Tree tree2 = new Tree();
        addObject(tree2,0,23);
        Tree tree3 = new Tree();
        addObject(tree3,0,22);
        Tree tree4 = new Tree();
        addObject(tree4,0,21);
        Tree tree5 = new Tree();
        addObject(tree5,0,20);
        Tree tree6 = new Tree();
        addObject(tree6,0,19);
        Tree tree7 = new Tree();
        addObject(tree7,0,18);
        Tree tree8 = new Tree();
        addObject(tree8,0,17);
        Tree tree9 = new Tree();
        addObject(tree9,0,16);
        Tree tree10 = new Tree();
        addObject(tree10,0,15);
        Tree tree11 = new Tree();
        addObject(tree11,0,14);
        Tree tree12 = new Tree();
        addObject(tree12,0,13);
        Tree tree13 = new Tree();
        addObject(tree13,0,12);
        Tree tree14 = new Tree();
        addObject(tree14,0,11);
        Tree tree15 = new Tree();
        addObject(tree15,0,10);
        Tree tree16 = new Tree();
        addObject(tree16,0,9);
        Tree tree17 = new Tree();
        addObject(tree17,0,8);
        Tree tree18 = new Tree();
        addObject(tree18,0,7);
        Tree tree19 = new Tree();
        addObject(tree19,0,6);
        Tree tree20 = new Tree();
        addObject(tree20,0,5);
        Tree tree21 = new Tree();
        addObject(tree21,0,4);
        Tree tree22 = new Tree();
        addObject(tree22,0,3);
        Tree tree23 = new Tree();
        addObject(tree23,0,2);
        Tree tree24 = new Tree();
        addObject(tree24,0,1);
        Tree tree25 = new Tree();
        addObject(tree25,0,0);
        Tree tree26 = new Tree();
        addObject(tree26,8,0);
        Tree tree27 = new Tree();
        addObject(tree27,8,1);
        Tree tree28 = new Tree();
        addObject(tree28,8,2);
        Tree tree29 = new Tree();
        addObject(tree29,8,3);
        Tree tree30 = new Tree();
        addObject(tree30,8,4);
        Tree tree31 = new Tree();
        addObject(tree31,8,5);
        Tree tree32 = new Tree();
        addObject(tree32,8,6);
        Tree tree33 = new Tree();
        addObject(tree33,8,7);
        Tree tree34 = new Tree();
        addObject(tree34,8,8);
        Tree tree35 = new Tree();
        addObject(tree35,8,9);
        Tree tree36 = new Tree();
        addObject(tree36,8,10);
        Tree tree37 = new Tree();
        addObject(tree37,8,11);
        Tree tree38 = new Tree();
        addObject(tree38,8,12);
        Tree tree39 = new Tree();
        addObject(tree39,8,13);
        Tree tree40 = new Tree();
        addObject(tree40,8,14);
        Tree tree41 = new Tree();
        addObject(tree41,8,15);
        Tree tree42 = new Tree();
        addObject(tree42,8,16);
        Tree tree43 = new Tree();
        addObject(tree43,8,17);
        Tree tree44 = new Tree();
        addObject(tree44,8,18);
        Tree tree45 = new Tree();
        addObject(tree45,8,19);
        Tree tree46 = new Tree();
        addObject(tree46,8,20);
        Tree tree47 = new Tree();
        addObject(tree47,8,21);
        Tree tree48 = new Tree();
        addObject(tree48,8,22);
        Tree tree49 = new Tree();
        addObject(tree49,8,23);
        Tree tree50 = new Tree();
        addObject(tree50,8,24);

        MyKara mykara = new MyKara();
        addObject(mykara,4,24);
        mykara.turnLeft();
    }
    
    /*public void gruppe1(int verschiebung)
    {
        runterLaufen(b1);
        
    }*/
    
    Pattern a = new Pattern(5);
    NxLvTree aa[] = a.Pattern1();
    public void allMovingTrees()
    {
        //Hier wird später entschieden in welcher reinfolge die bäume runterlaufen und dem entsprechend aufgerufen
        
        
        for(int j = 0; j < a.getPattern1Length(); j++)
        {
            runterLaufen(aa[j]);
        }
    }
    
    
    long lastMove = System.currentTimeMillis();
    int speed = 200; //Speed gibt an wie schnell die bäume runterkommen
    public void act()
    {
        
        long curTime  = System.currentTimeMillis();
        if(curTime >= lastMove + speed)
        { 
            allMovingTrees();
            lastMove = curTime;
            
        }
        else
        {
        }
    }
    
}
import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Write a description of class Pattern1 here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Pattern extends Wiese
{
    int verschiebung;
    
    public Pattern(int verschiebung)
    {
        this.verschiebung = verschiebung;
    }
    //NxLvTree b1 = new NxLvTree(3,-1, false);
    //b1.runterLaufen(b1);
    
    NxLvTree gruppe1[] = new NxLvTree[4];
    public NxLvTree[] Pattern1()
    {
        gruppe1[0] = new NxLvTree(4, 1, false);
        gruppe1[1] = new NxLvTree(1, 1, false);
        gruppe1[2] = new NxLvTree(2, 1, false);
        gruppe1[3] = new NxLvTree(5, 1, false);
        
        return gruppe1;
    }
    public int getPattern1Length()
    {
        return gruppe1.length;
    }
}
import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Diese Klasse stellt einen Baum zur Verfuegung. 
 * 
 * Baeume sind ein Hindernis fuer Kara. Kara kann Baeume weder ueberqueren, noch
 * wegschieben.
 *
 * @author Marco Jakob
 * @version 20.01.2011
 */
public class Tree extends Actor
{
    
    
    protected void addedToWorld(World world)
    {
        if (getOneObjectAtOffset(0, 0, Kara.class) != null) 
        {
            System.out.println("Achtung: Es sollte kein Baum auf Kara gesetzt werden! (Feld " + getX() + ", " + getY() + ")");
        }
        else if (getOneObjectAtOffset(0, 0, Mushroom.class) != null) 
        {
            System.out.println("Achtung: Es sollte kein Baum auf einen Pilz gesetzt werden! (Feld " + getX() + ", " + getY() + ")");
        }
        else if (getOneObjectAtOffset(0, 0, Tree.class) != null) 
        {
            System.out.println("Achtung: Es sollten nicht zwei Baeume auf ein Feld gesetzt werden! (Feld " + getX() + ", " + getY() + ")");
        }
        else if (getOneObjectAtOffset(0, 0, Leaf.class) != null) 
        {
            System.out.println("Achtung: Es sollte kein Baum auf ein Blatt gesetzt werden! (Feld " + getX() + ", " + getY() + ")");
        }
    }       
}
import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Write a description of class BeweglicherTree here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class NxLvTree extends Tree
{
    
    int xK;
    int yK;
    boolean treeGesetzt;
    
    public NxLvTree(int xK, int yK, boolean treeGesetzt)
    {
        this.xK = xK;
        this.yK = yK;
        this.treeGesetzt = treeGesetzt;
    }
    
    public int getLocationX()
    {
        return xK;
    }
    
    public int getLocationY()
    {
        return yK;
    }
    
    public void setLocationY()
    {
        yK = yK + 1;  
    }
    
    public void setLocationY(int a)
    {
        yK = yK + a;  
    }
    
    public void moveDown()
    {
        turn(90); move(1); turn(-90);
    }
    
    public boolean isTreeGesetzt()
    {
        return treeGesetzt;
    }
    
    public void setTreeGesetzt()
    {
        treeGesetzt = !treeGesetzt;
    }
        
} 
import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Die Klasse MyKara ist eine Unterklasse von Kara.
 * Sie erbt damit alle Methoden der Klasse Kara:
 * 
 * Aktionen:    move(), turnLeft(), turnRight(), putLeaf(), removeLeaf()
 * Sensoren:    onLeaf(), treeFront(), treeLeft(), treeRight(), mushroomFront()
 */
public class MyKara extends Kara
{
    /**
     * In der Methode 'act()' koennen die Befehle fuer Kara programmiert werden.
     * Die Befehle werden dort nacheinander aufgerufen, wenn man nach dem 
     * 'Uebersetzen' (=kompilieren) den 'Act'-Knopf drueckt.
     * Beim druecken des 'Run'-Knopfes wird diese Methode immer wieder ausgefuehrt.
     */
    
    public void bewegen()
    {
        
        if(Greenfoot.isKeyDown("left"))
        {
            turnLeft(); 
            if(canMove())
            {
                move();
            }
            turnRight();
        }
        
        
        
        if(Greenfoot.isKeyDown("right"))
        {
            turnRight(); 
            if(canMove())
            {
                move(); 
            }
            turnLeft();
        }
    }
    
    
    
    
   
    
    public void act() 
    {
        bewegen();
        if(treeFront())
        {
            Greenfoot.stop();
        }
    }
}
The problem is, as the error shows in the class pattern and wiese. I have no images or something likes this in the programm.
Super_Hippo Super_Hippo

2017/3/19

#
First, try to restart Greenfoot. If that doesn't help, remove all the temporary variables in the prepare method. 
private void prepare()
{
    for (int i=0; i<25; i++)
    {
        addObject(new Tree(), 0, i);
        addObject(new Tree(), 8, i);
    }
    //add Kara
}
I am not sure why you have to many calls of the 'turn' method when moving or what the xK and yK in the NxLvTree (?) are representing. Code for moving the trees should probably go into the trees class. (Btw, there is no problem using äöüß in your code and comments.)
heyu heyu

2017/3/19

#
Ok I tried both and nothing worked. I want a diffrent between trees, wich are moving down and trees just standing around.
Super_Hippo Super_Hippo

2017/3/19

#
Try to open the java control panel and increase the space for temporary data.
danpost danpost

2017/3/19

#
Hippo, these types of scenarios (like Greeps, MyKara and JerooFoot) have the entire execution of the scenario run as if through the 'started' method of the world (sort of like the old top-down type programs before OOP was around). This is why you may find an abundance of turns and moves with 'while' loops. You may want to look at my JerooFoot Application scenario to see what I am talking about. It would be like the testing part -- not the building part. Refer to the 'go' method in the Jeroo class, which is run in its entirety when testing.
Super_Hippo Super_Hippo

2017/3/20

#
Interesting, I didn't know that. I am not really seeing the reason why one would like to use non-OOP programming in java though, but okay. The only thing I heard about was Greeps, but I thought that the Greeps (if that are the things moving around and trying to collect something I don't remember) had an act method and the user had to write the act method (which had some limitation of booleans), so the Greeps collect as much as possible on each map before the time runs out.
danpost danpost

2017/3/23

#
Super_Hippo wrote...
The only thing I heard about was Greeps, but I thought that the Greeps (if that are the things moving around and trying to collect something I don't remember) had an act method and the user had to write the act method (which had some limitation of booleans), so the Greeps collect as much as possible on each map before the time runs out.
You are right -- the Greeps scenario does have an act method that is executed repeatedly (needed because each map is run in a specific amount of time or act cycles). I should not have included that in my list. Maybe I should not have posted at all. I was rushed when I replied and after closer inspection, it may not be like those type at all.
You need to login to post a reply.