Methoden Kleines Problem mit meinem Glücksrad...

FraxxeY

Mitglied
Heyho,

hab mir als Ziel gesetzt, ein png-Glücksrad auf Knopfdruck animiert zu drehen und random zu stoppen.

Bin relativ unerfahren, und hab mir aus dem Internet alles zusammengereimt was ging.

Der Code:
Java:
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JLabel;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.Color;
import java.io.File;
import java.io.IOException;
import java.util.Random;
import javax.swing.JButton;


public class ROULETTE extends JFrame
{
    /**
    *
    */
    private static final long serialVersionUID = 1L;
    private final int farbe = 2500140;
    private JLabel bg;
    private JLabel scheibe, ping;
    private static int gerollt;
    private int mpk;
    private Random roll;
    private static int multi;
    private JButton button;

    public static void main(String[] args)
    {
        new ROULETTE();
        Random roll = new Random();
        gerollt = roll.nextInt(101);
        System.out.println(gerollt);
       }
 
 
 
   
    public ROULETTE()
    {
        super("Roulette");
        setSize(1280, 720);
        setLayout(null);
        setResizable(false);
        setLocationRelativeTo(null);
        setVisible(true);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        getContentPane().setBackground(Color.darkGray);
             
        scheibe = new wheel();
        scheibe.setBounds(10,10,5000,5000);
        add(scheibe);
     
        ping = new pinger();
        ping.setBounds(10,10,5000,5000);
        add(ping);
     
        bg = new paintComponents();
        add(bg);
     
        button = new JButton("Spielen");
        button.setBounds(465, 500, 35, 10); //x, y, breite, hoehe
        add(button);
        repaint();
    }
    public class paintComponents extends JLabel
    {
      /**
        *
        */
        private static final long serialVersionUID = 1L;

        public void paintComponent(Graphics g)
      {
          super.paintComponent(g);
          g.setColor(new Color(farbe));
          g.fillRect(0, 0, 1280, 720);
       
       
      }
    }
 
    public class wheel extends JLabel
    {
 
        /**
        *
        */
        private static final long serialVersionUID = 1L;

        public void paintComponent(Graphics g)
        {
            int i = 0;
         
         
         
            do
            {
                i = i +1;
                BufferedImage rad = LoadImage("neu2.png");
           
              Graphics2D g2d = (Graphics2D) g;
                AffineTransform at = AffineTransform.getTranslateInstance(430,10);
                at.rotate(Math.toRadians(i), rad.getWidth()/2, rad.getHeight()/2);
                g2d.drawImage(rad, at, null);
              repaint();
            }
            while (i < gerollt);

        }
     
        BufferedImage LoadImage(String FileName)
        {
       
            BufferedImage img = null;
         
            try{
                img = ImageIO.read(new File(FileName));
            }catch(IOException e){
            }
         
            return img;
        }
     }
 
    public class pinger extends JLabel
    {

        /**
        *
        */
        private static final long serialVersionUID = 1L;
        public void paintComponent(Graphics g)
        {
            BufferedImage anzeige = LoadImage("anzeige.png");
            Graphics2D g2d = (Graphics2D) g;
         
            g2d.drawImage(anzeige, 0,0 , null);
            repaint();
        } 
         
            BufferedImage LoadImage(String FileName)
            {
                BufferedImage img = null;
             
                try{
                    img = ImageIO.read(new File(FileName));
                }catch(IOException e){
                }
             
                return img; 
        }
    }
}


("pinger" ist ein kleines Dreieck, das zeigen soll in welchem Feld das Rad steht)



Das Problem: Das Rad dreht sich nicht. Wenn ich in der paintComponent eine lokale Variable drinnen lasse (hier i), und in Math.toRadians i++ mach, dann dreht sich das animiert.

Aber ich bekomm das nicht hin, es auf Befehl random weit drehen zu lassen und das Feld unten in der Mitte auszulesen!

Mein Rad hat 54 Felder, also pro Feld wären 6,66 Grad zu drehen. Heißt: Ich hätte die random Zahl gerundet, und dem Programm gesagt dass nach z.B. 30 Grad drehen rot unten ist. Nur so als Beispiel. Geht das einfacher?

Und wie kann ich das Rad jetzt richtig drehen lassen?

MFG
 
Zuletzt bearbeitet:
In dem Code habe ich Fehler festgestellt. Nach meinem Experiment wirft der so Fehlermeldungen in Eclipse und wird überhaupt nicht ausgeführt. Ein Grund dafür sehe ich, in der main. Die Aufrufe von pack() und visible(true) sind üblicherweise der Abschluß.
 
Und wir dürfen jetzt raten um welche Fehlermeldungen es geht ???
Gibt es denn auch was zu gewinnen ???

http://www.java-forum.org/forum-faq-beitraege/7407-man-fragen-richtig-stellt.html

Gruß Klaus
Es gibt keine, das Rad dreht einfach nicht. Manchmal startet das Programm mit gedrehtem Rad das dann ungeplant irgendwie andersrum abgebildet wird, aber das Rad soll sich ja sichtbar drehen, also das bild soll sich für ein paar Sekunden drehen.
 
Ich habe mal sowas programmiert. Wenn man auf den Button klickt, verschiebt sich das Quadrat. Genauso kann sich dann das Glücksrad drehen. Du musst aber dafür einen Timer nutzen.

Java:
package code;

public class Rad {
  
    public static void main(String[] args){
    Spielfeld sf= new Spielfeld();
    sf.Spielen();
    }
  
}

Java:
package code;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Spielfeld implements ActionListener{

    private JFrame frame;
    private JPanel panel;
    private JButton spiel;
    private Blatt malblatt;
    private int zahl;
  
    public void Spielfeld(){
      
    }
  
    public void Spielen(){
        frame= new JFrame();
        panel= new JPanel();
        spiel= new JButton("Spielen");
        malblatt= new Blatt();
        spiel.addActionListener(this);
        panel.add(malblatt);
        panel.add(spiel);
        frame.add(panel);
        frame.pack();
        frame.setVisible(true);  
      
    }
  
    public void actionPerformed( ActionEvent ae){
        if(ae.getSource()==this.spiel){
            zahl++;
            malblatt.SetZahl(zahl);
            frame.repaint();
        }
    }
}

Java:
package code;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JLabel;

public class Blatt extends JLabel{
  
      
    Dimension layoutSize;
    int zahl=0;
  
    public Blatt(){
        super();
    }
  
    @Override
    public Dimension getPreferredSize() {
        layoutSize = super.getPreferredSize();
        int max = Math.max(layoutSize.width, layoutSize.height);
        return new Dimension(max + 200, max + 200);
    }

    @Override
    public void paintComponent(final Graphics g){
        super.paintComponent(g);
        g.setColor(Color.RED);
        g.fillRect(10+10*zahl,10,20,20);
    }
  
    public void SetZahl(int z){
        this.zahl=z;
  
    }

}
 
Zuletzt bearbeitet von einem Moderator:
Ich habe mal sowas programmiert. Wenn man auf den Button klickt, verschiebt sich das Quadrat. Genauso kann sich dann das Glücksrad drehen. Du musst aber dafür einen Timer nutzen.

Danke, werde mir das morgen mal genauer ansehen! Den Timer für was genau? Und für was benötigt man ein Override in einer Klasse ohne Supermethode? Oder ist da eine?

Gruß
 
wenn du den Code durchsiehst, dann fällt dir ein ActionListener auf. Dieser löst ein Neuzeichnen aus. Wenn du also dein Rad n-mal weiterderhen willst, musst du n-mal repaint mit einem Action-Listener aufrufen. So ein auslösendes Event können außer Buttons u.ä. auch Timer auslösen. Google mal danach.
Ansonsten halte ich dein Vorgehen für zu zeitaufwändig. Ein Pixel-Bild zu drehen dauert schon seine Zeit. Besser finde ich es, das Glücksrad aus Tortenstückchen zusammenzusetzen. Das ist weniger ressourcenintensiv, und läßt sich leichter verwalten.
 

Zurück
Oben