# Mehrere Steine gleichzeitig setzen und bewegen



## SSJ (16. Apr 2009)

Tag erstemal an alle,
ich und ein Projektpartner sind dabei, das Spiel 'Muehle' zu programmieren. Mein Partner programmiert das Spiel, ich programmiere die graphische Oberflaeche.
Soweit steht alles, mein Problem ist, dass ich zwei Steine setzen kann, und einen davon auch bewegen kann. Aber


der schwarze Stein, den ich bewegen kann, kann ich nicht ziehen. Die Methode dazu habe ich zwar, aber sie wird offenbar nie gelesen ("//Stein ziehen")
Den zweiten Stein, den blauen, kann ich nicht bewegen, egal was ich versucht habe
Ich wuerde gern weitere Steine einfuegen, z.B. rot oder grau, oder auch wieder schwarz und blau; es muessen ja am Schluss pro Farbe neun Steine sein
Die Punkte sind hinter dem Feld, sie muessen aber davor sein; wo liegt da mein Fehler?
Kann mir jemand Korrekturen zu diesen vier Punkten angeben?
Erwaehnen sollte ich noch, dass ich keine Algorithmen mehr brauche, sondern konkrete Ansaetze; denn mein Problem liegt nur noch an der Ausfuehrung der Algorithmen,
danke fuer Eure Hilfe!


```
package nix;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;





public class Stones {
    
    public static void main(String[] args) {

        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                createAndShowGUI(); 
            }
        });
    }

    public static void createAndShowGUI() {
        
        JFrame f = new JFrame("Spielfeld");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
        f.add(new MyPanel());
        f.setSize(500,500);
        f.setVisible(true);
    } 

}

class MyPanel extends JPanel {

    /**
     * 
     */
    
    //start field
    
    public void paint(Graphics g) {
        
        // paint stones
        super.paintComponent(g);       
        g.drawString("",10,20);
        g.drawString("",10,20);
        blackSquare.paintSquare(g);
        blueSquare.paintSquare(g);
//        redSquare.paintSquare(g);
        
        
        // paint field
        Dimension size = getSize();
        int d = Math.min(size.width, size.height); // diameter
        int ed = d/30; // Punktgroesse
        int x = (size.width - d)/2;
        int y = (size.height - d)/2;
        
       
              
 /*       // field background color
          g.fillRect(x, y, d, d);
          g.setColor(Color.red);
             g.drawRect(x, y, d, d);
*/ 
        
        // draw dots
  
        g.fillRect(x+((1)*(d/9))-(ed/2), y+d/9-(ed/2), ed, ed); // oberste linie 1
        g.fillRect(x+((1)*(d/2))-(ed/2), y+d/9-(ed/2), ed, ed); // oberste linie 2
        g.fillRect((int) (x+((1)*(d/1.1))-(ed/2)), y+d/9-(ed/2), ed, ed); // oberste linie 3
        
        g.fillRect((int) (x+((1)*(d/5))-(ed/2)), (int) (y+d/4-(ed/2)), ed, ed); // zweite linie 1
        g.fillRect(x+((1)*(d/2))-(ed/2), y+d/4-(ed/2), ed, ed); // zweite linie 2
        g.fillRect((int) (x+((1)*(d/1.2))-(ed/4)), (int) (y+d/4-(ed/2)), ed, ed); // zweite linie 3
        
        g.fillRect((int) (x+((1)*(d/3))-(ed/2)), (int) (y+d/3-(ed/2)), ed, ed); // dritte linie 1
        g.fillRect((int) (x+((1)*(d/2))-(ed/2)), (int) (y+d/3-(ed/2)), ed, ed); // dritte linie 2
        g.fillRect((int) (x+((1)*(d/1.5))-(ed/2)), (int) (y+d/3-(ed/2)), ed, ed); // dritte linie 3
        
        g.fillRect(x+((1)*(d/9))-(ed/2), y+d/2-(ed/2), ed, ed); // vierte linie 1
        g.fillRect((int) (x+((1)*(d/5))-(ed/2)), (int) (y+d/2-(ed/2)), ed, ed); // vierte linie 2
        g.fillRect((int) (x+((1)*(d/3))-(ed/2)), (int) (y+d/2-(ed/2)), ed, ed); // vierte linie 3
        g.fillRect((int) (x+((1)*(d/1.5))-(ed/2)), (int) (y+d/2-(ed/2)), ed, ed); // vierte linie 4
        g.fillRect((int) (x+((1)*(d/1.2))-(ed/4)), (int) (y+d/2-(ed/2)), ed, ed); // vierte linie 5
        g.fillRect((int) (x+((1)*(d/1.1))-(ed/2)), y+d/2-(ed/2), ed, ed); // vierte linie 6
        
        g.fillRect((int) (x+((1)*(d/3))-(ed/2)), (int) (y+d/1.5-(ed/2)), ed, ed); // fuenfte linie 1
        g.fillRect((int) (x+((1)*(d/2))-(ed/2)), (int) (y+d/1.5-(ed/2)), ed, ed); // fuente linie 2
        g.fillRect((int) (x+((1)*(d/1.5))-(ed/2)), (int) (y+d/1.5-(ed/2)), ed, ed); // fuente linie 3
        
        g.fillRect((int) (x+((1)*(d/5))-(ed/2)), (int) (y+d/1.3-(ed/2)), ed, ed); // sechste linie 1
        g.fillRect(x+((1)*(d/2))-(ed/2), (int) (y+d/1.3-(ed/2)), ed, ed); // sechste linie 2
        g.fillRect((int) (x+((1)*(d/1.2))-(ed/4)), (int) (y+d/1.3-(ed/2)), ed, ed); // sechste linie 3
        
        g.fillRect(x+((1)*(d/9))-(ed/2), (int) (y+d/1.1-(ed/2)), ed, ed); // siebte linie 1
        g.fillRect(x+((1)*(d/2))-(ed/2), (int) (y+d/1.1-(ed/2)), ed, ed); // siebte linie 2
        g.fillRect((int) (x+((1)*(d/1.1))-(ed/2)), (int) (y+d/1.1-(ed/2)), ed, ed); // siebte linie 3
        

        //draw rectangles
      
       g.drawRect(x+((1)*(d/9))-(ed/2), y+d/9-(ed/2), (int) (d/1.21), (int) (d/1.21)); // aussen
       g.drawRect((int) (x+((1)*(d/5))-(ed/2)), (int) (y+d/4-(ed/2)), (int) (d/1.49), (int) (d/1.815)); // mitte
       g.drawRect((int) (x+((1)*(d/3))-(ed/2)), (int) (y+d/3-(ed/2)), (int) (d/2.74), (int) (d/2.74)); // innen
       
       //draw lines
       
       g.drawLine((int) (x+((1)*(d/1.96))-(ed/2.9)), y+d/9-(ed/2), (int) (x+((1)*(d/1.96))-(ed/2.9)), (int) (y+d/3-(ed/2))); // Nord
       g.drawLine((int) (x+((1)*(d/1.96))-(ed/2.9)), (int) (y+d/1.1-(ed/2)), (int) (x+((1)*(d/1.96))-(ed/2.9)), (int) (y+d/1.5-(ed/2))); // Sued
       g.drawLine((int) x+((1)*(d/9))-(ed/2), (int) (y+d/2-(ed/7.5)), (int) (x+((1)*(d/3))-(ed/2)), (int) (y+d/2-(ed/7.5))); // West
       g.drawLine((int) (x+((1)*(d/1.5))-(ed/2)), (int) (y+d/2-(ed/7.5)), (int) (x+((1)*(d/1.1))-(ed/2)), (int) ((int) y+d/2-(ed/7.5))); // Ost
   
    }




    
    //end field

    
    
    private static final long serialVersionUID = -5500035608091446717L;
    
    BlackSquare blackSquare = new BlackSquare();
    BlueSquare blueSquare = new BlueSquare();
//    RedSquare redSquare = new RedSquare();
//    GraySquare graySquare = new GraySquare();

    public MyPanel() {


        setBorder(BorderFactory.createLineBorder(Color.red));
        setBorder(BorderFactory.createLineBorder(Color.yellow));

        addMouseListener(new MouseAdapter(){
            public void mousePressed(MouseEvent e){
                moveSquare(e.getX(),e.getY());
            }
        });}
            //Stein ziehen
        //addMouseMotionListener(new MouseAdapter(){
            public void mouseDragged(MouseEvent e){
                moveSquare(e.getX(),e.getY());
            }
            
            
        

    

    private void moveSquare(int x1, int y1){

        
        final int CURR_X = blackSquare.getX();
        final int CURR_Y = blackSquare.getY();
        final int CURR_W = blackSquare.getWidth();
        final int CURR_H = blackSquare.getHeight();
        final int OFFSET = 1;
        
  //      final int CURR_X = blueSquare.getX();
        
      

        if ((CURR_X!=x1) || (CURR_Y!=y1)) {

            // The square is moving, repaint background 
            // over the old square location. 
            repaint(CURR_X,CURR_Y,CURR_W+OFFSET,CURR_H+OFFSET);

            // Update coordinates.
            blackSquare.setX(x1);
            blackSquare.setY(y1);
//            blueSquare.setX(x1);
//            blueSquare.setY(y1);


            // Repaint the square at the new location.
            repaint(blackSquare.getX(), blackSquare.getY(), 
                    blackSquare.getWidth()+OFFSET, 
                    blackSquare.getHeight()+OFFSET);
          
            repaint(blueSquare.getX(), blueSquare.getY(), 
                    blueSquare.getWidth()+OFFSET, 
                    blueSquare.getHeight()+OFFSET);
                    
        }
    }
    
    

    public Dimension getPreferredSize() {
        return new Dimension(250,200);
    }
    

    }  



abstract class Square{
    public int xPos;
    public int yPos;
    public int width;
    public int height;
    public Color line;
    public Color filling;

    protected void setAll(int xPos,int yPos, int width, int height, Color line, Color filling){ 
        this.xPos = xPos;
        this.yPos = yPos;
        this.width = width;
        this.height = height;
        this.line = line;
        this.filling = filling;
    }
    public void setX(int xPos){ 
        this.xPos = xPos;
    }
    
    public void setX1(int xPos){
        this.xPos = xPos;
    }

    public int getX(){
        return xPos;
    }

    public void setY(int yPos){
        this.yPos = yPos;
    }
    
    public void setY1(int yPos){
        this.yPos = yPos;
    }

    public int getY(){
        return yPos;
    }

    public int getWidth(){
        return width;
    } 

    public int getHeight(){
        return height;
    }

    public void paintSquare(Graphics g){
        g.setColor(filling);
        g.fillRect(xPos,yPos,width,height);
        g.setColor(line);
        g.drawRect(xPos,yPos,width,height);  
    }
}

class BlackSquare extends Square{
    BlackSquare(){
        this.setAll(100,100,
            25,25, Color.BLACK,Color.BLACK);
    }
}

class BlueSquare extends Square{
    BlueSquare(){
        this.setAll(25,25,
            25,25,
            Color.BLUE,Color.BLUE);
    }
    
class GraySquare extends Square{
    GraySquare(){
        this.setAll(50, 50,
                50, 50,
                Color.GRAY, Color.GRAY);
    }
}
    
class RedSquare extends Square{
    RedSquare(){
        this.setAll(35, 35, 
                40, 40, 
                Color.RED, Color.RED);
    }
}
    
    
    
}
```


----------



## Evolver (17. Apr 2009)

1. Du hast das addMouseMotionListener auskommentiert, also wird beim 'draggen' (ziehen) auch keine Methode von dir aufgerufen.
2. Wie soll sich der zweite steinbewegen, wenn du in deiner moveSquare-Methode nur den schwarzen stein behandelts?
3. Dann füge eben mehr ein. Mach ein Array mit den Steinen, und prüfe (auch in Bezug auf deinen Punkt 2), ob die Mosoposition beim MousePressed einem bestimmten Stein entspricht. Diesen merkst du dir und ziehst dann genau den bei MouseDragged.
4. Das Spielfeld befindet sich über den Steinen, weil du es nach ihnen zeichnest. Zeichne die Steine nach dem Spielfeld.


----------



## SSJ (19. Apr 2009)

Wenn das auskommentieren wegnehme, compiliert der Code nicht mehr, und ich scheitere bei der Fehlerbehebung, weil er mir keine Vorschlaege gibt, und ich nicht weiss, was nicht stimmt;
Wenn ich auch den blauen Stein behandele, compiliert er auch nicht, auch hier scheitere ich bei der Fehlerbehebung;
ich habe versucht noch einen roten und grauen Stein einzufuegen, aber diese werden nicht erkannt und auch nicht gezeichnet; auch hier komme ich nicht weiter;
ich habe den Code fuers Feld unter dem der Steine gelegt, das Feld befindet sich immer noch ueber den Steinen;

ich waere froh, wenn du den Code bei dir laufen lassen wuerdest,


Gruss


----------



## Schandro (19. Apr 2009)

Deine Zeile mit addMouseMotionListener kompiliert deshalb nicht, weil sie innerhalb einer Methode aufgerufen werden muss. Bei dir steht der Aufruf ja mitten in der Klasse..


----------



## Evolver (19. Apr 2009)

Nagut, ich war mal sehr gütig und habe die groben Fehler aus dem Code entfernt. Auch wenn man es schöner machen könnte.

```
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.BorderFactory;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;


public class Stones
{

	public static void main(String[] args)
	{
		SwingUtilities.invokeLater(new Runnable()
		{
			public void run()
			{
				createAndShowGUI();
			}
		});
	}

	
	public static void createAndShowGUI()
	{
		JFrame f = new JFrame("Spielfeld");
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.add(new MyPanel());
		f.setSize(500, 500);
		f.setVisible(true);
	}

}

class MyPanel extends JPanel
{

	// start field
	public void paint(Graphics g)
	{
		super.paintComponent(g);
		g.drawString("", 10, 20);
		g.drawString("", 10, 20);

		// paint field
		Dimension size = getSize();
		int d = Math.min(size.width, size.height); // diameter
		int ed = d / 30; // Punktgroesse
		int x = (size.width - d) / 2;
		int y = (size.height - d) / 2;


		// draw dots
		g.fillRect(x + ((1) * (d / 9)) - (ed / 2), y + d / 9 - (ed / 2), ed, ed); // oberste linie 1
		g.fillRect(x + ((1) * (d / 2)) - (ed / 2), y + d / 9 - (ed / 2), ed, ed); // oberste linie 2
		g.fillRect((int) (x + ((1) * (d / 1.1)) - (ed / 2)), y + d / 9 - (ed / 2), ed, ed); // oberste linie 3

		g.fillRect((int) (x + ((1) * (d / 5)) - (ed / 2)), (int) (y + d / 4 - (ed / 2)), ed, ed); // zweite linie 1
		g .fillRect(x + ((1) * (d / 2)) - (ed / 2), y + d / 4 - (ed / 2), ed, ed); // zweite linie 2
		g.fillRect((int) (x + ((1) * (d / 1.2)) - (ed / 4)), (int) (y + d / 4 - (ed / 2)), ed, ed); // zweite linie 3

		g.fillRect((int) (x + ((1) * (d / 3)) - (ed / 2)), (int) (y + d / 3 - (ed / 2)), ed, ed); // dritte linie 1
		g.fillRect((int) (x + ((1) * (d / 2)) - (ed / 2)), (int) (y + d / 3 - (ed / 2)), ed, ed); // dritte linie 2
		g.fillRect((int) (x + ((1) * (d / 1.5)) - (ed / 2)), (int) (y + d / 3 - (ed / 2)), ed, ed); // dritte linie 3

		g.fillRect(x + ((1) * (d / 9)) - (ed / 2), y + d / 2 - (ed / 2), ed, ed); // vierte linie 1
		g.fillRect((int) (x + ((1) * (d / 5)) - (ed / 2)), (int) (y + d / 2 - (ed / 2)), ed, ed); // vierte linie 2
		g.fillRect((int) (x + ((1) * (d / 3)) - (ed / 2)), (int) (y + d / 2 - (ed / 2)), ed, ed); // vierte linie 3
		g.fillRect((int) (x + ((1) * (d / 1.5)) - (ed / 2)), (int) (y + d / 2 - (ed / 2)), ed, ed); // vierte linie 4
		g.fillRect((int) (x + ((1) * (d / 1.2)) - (ed / 4)), (int) (y + d / 2 - (ed / 2)), ed, ed); // vierte linie 5
		g.fillRect((int) (x + ((1) * (d / 1.1)) - (ed / 2)), y + d / 2 - (ed / 2), ed, ed); // vierte linie 6

		g.fillRect((int) (x + ((1) * (d / 3)) - (ed / 2)), (int) (y + d / 1.5 - (ed / 2)), ed, ed); // fuenfte linie 1
		g.fillRect((int) (x + ((1) * (d / 2)) - (ed / 2)), (int) (y + d / 1.5 - (ed / 2)), ed, ed); // fuente linie 2
		g.fillRect((int) (x + ((1) * (d / 1.5)) - (ed / 2)), (int) (y + d / 1.5 - (ed / 2)), ed, ed); // fuente linie 3

		g.fillRect((int) (x + ((1) * (d / 5)) - (ed / 2)), (int) (y + d / 1.3 - (ed / 2)), ed, ed); // sechste linie 1
		g.fillRect(x + ((1) * (d / 2)) - (ed / 2), (int) (y + d / 1.3 - (ed / 2)), ed, ed); // sechste linie 2
		g.fillRect((int) (x + ((1) * (d / 1.2)) - (ed / 4)), (int) (y + d / 1.3 - (ed / 2)), ed, ed); // sechste linie 3

		g.fillRect(x + ((1) * (d / 9)) - (ed / 2), (int) (y + d / 1.1 - (ed / 2)), ed, ed); // siebte linie 1
		g.fillRect(x + ((1) * (d / 2)) - (ed / 2), (int) (y + d / 1.1 - (ed / 2)), ed, ed); // siebte linie 2
		g.fillRect((int) (x + ((1) * (d / 1.1)) - (ed / 2)), (int) (y + d / 1.1 - (ed / 2)), ed, ed); // siebte linie 3

		// draw rectangles
		g.drawRect(x + ((1) * (d / 9)) - (ed / 2), y + d / 9 - (ed / 2), (int) (d / 1.21), (int) (d / 1.21)); // aussen
		g.drawRect((int) (x + ((1) * (d / 5)) - (ed / 2)), (int) (y + d / 4 - (ed / 2)), (int) (d / 1.49), (int) (d / 1.815)); // mitte
		g.drawRect((int) (x + ((1) * (d / 3)) - (ed / 2)), (int) (y + d / 3 - (ed / 2)), (int) (d / 2.74), (int) (d / 2.74)); // innen

		// draw lines
		g.drawLine((int) (x + ((1) * (d / 1.96)) - (ed / 2.9)), y + d / 9 - (ed / 2), (int) (x + ((1) * (d / 1.96)) - (ed / 2.9)), (int) (y + d / 3 - (ed / 2))); // Nord
		g.drawLine((int) (x + ((1) * (d / 1.96)) - (ed / 2.9)), (int) (y + d / 1.1 - (ed / 2)), (int) (x + ((1) * (d / 1.96)) - (ed / 2.9)), (int) (y + d / 1.5 - (ed / 2))); // Sued
		g.drawLine((int) x + ((1) * (d / 9)) - (ed / 2), (int) (y + d / 2 - (ed / 7.5)), (int) (x + ((1) * (d / 3)) - (ed / 2)), (int) (y + d / 2 - (ed / 7.5))); // West
		g.drawLine((int) (x + ((1) * (d / 1.5)) - (ed / 2)), (int) (y + d / 2 - (ed / 7.5)), (int) (x + ((1) * (d / 1.1)) - (ed / 2)), (int) ((int) y + d / 2 - (ed / 7.5))); // Ost

		// stones
		for( Square currentSquare : squares )
			currentSquare.paintSquare(g);
	}

	// end field

	private static final long serialVersionUID = -5500035608091446717L;

	private Square[] squares;
	private int selectedSquareIndex;

	public MyPanel()
	{
		squares = new Square[] { new BlackSquare(), new BlueSquare(), new RedSquare(), new GraySquare() };
		selectedSquareIndex = -1;
		
		setBorder(BorderFactory.createLineBorder(Color.red));
		setBorder(BorderFactory.createLineBorder(Color.yellow));

		addMouseListener(new MouseAdapter()
		{
			public void mousePressed(MouseEvent e)
			{
				for( int i=0; i<squares.length; ++i )
				{
					Rectangle squareRect = new Rectangle(squares[i].getX(), squares[i].getY(), squares[i].getWidth(), squares[i].getHeight());
					if( squareRect.contains(e.getX(), e.getY()) )
					{
						selectedSquareIndex = i;
						break;
					}
				}
			}
			
			public void mouseReleased(MouseEvent e)
			{
				selectedSquareIndex = -1;
			}
		});

		// Stein ziehen
		addMouseMotionListener(new MouseAdapter()
		{
			public void mouseDragged(MouseEvent e)
			{
				moveSquare(e.getX(), e.getY());
			}
		});
	}

	
	private void moveSquare(int x1, int y1)
	{
		if( selectedSquareIndex<0 )
			return;
		
		final int CURR_X = squares[selectedSquareIndex].getX();
		final int CURR_Y = squares[selectedSquareIndex].getY();
		final int CURR_W = squares[selectedSquareIndex].getWidth();
		final int CURR_H = squares[selectedSquareIndex].getHeight();
		final int OFFSET = 1;

		// final int CURR_X = blueSquare.getX();

		if ((CURR_X != x1) || (CURR_Y != y1))
		{

			// The square is moving, repaint background
			// over the old square location.
			repaint(CURR_X, CURR_Y, CURR_W + OFFSET, CURR_H + OFFSET);

			// Update coordinates.
			squares[selectedSquareIndex].setX(x1);
			squares[selectedSquareIndex].setY(y1);

			// Repaint the square at the new location.
			repaint(squares[selectedSquareIndex].getX(), squares[selectedSquareIndex].getY(), squares[selectedSquareIndex].getWidth() + OFFSET, squares[selectedSquareIndex].getHeight() + OFFSET);
		}
	}

	public Dimension getPreferredSize()
	{
		return new Dimension(250, 200);
	}

}


// was sinn macht: extends Rectangle
abstract class Square
{
	public int xPos;
	public int yPos;
	public int width;
	public int height;
	public Color line;
	public Color filling;

	protected void setAll(int xPos, int yPos, int width, int height, Color line, Color filling)
	{
		this.xPos = xPos;
		this.yPos = yPos;
		this.width = width;
		this.height = height;
		this.line = line;
		this.filling = filling;
	}

	public void setX(int xPos)
	{
		this.xPos = xPos;
	}

	public void setX1(int xPos)
	{
		this.xPos = xPos;
	}

	public int getX()
	{
		return xPos;
	}

	public void setY(int yPos)
	{
		this.yPos = yPos;
	}

	public void setY1(int yPos)
	{
		this.yPos = yPos;
	}

	public int getY()
	{
		return yPos;
	}

	public int getWidth()
	{
		return width;
	}

	public int getHeight()
	{
		return height;
	}

	public void paintSquare(Graphics g)
	{
		g.setColor(filling);
		g.fillRect(xPos, yPos, width, height);
		g.setColor(line);
		g.drawRect(xPos, yPos, width, height);
	}
}

class BlackSquare extends Square
{
	BlackSquare()
	{
		this.setAll(100, 100, 25, 25, Color.BLACK, Color.BLACK);
	}
}

class BlueSquare extends Square
{
	BlueSquare()
	{
		this.setAll(25, 25, 25, 25, Color.BLUE, Color.BLUE);
	}
}

class GraySquare extends Square
{
	GraySquare()
	{
		this.setAll(50, 50, 50, 50, Color.GRAY, Color.GRAY);
	}
}

class RedSquare extends Square
{
	RedSquare()
	{
		this.setAll(35, 35, 40, 40, Color.RED, Color.RED);
	}
}
```


----------

