daily pastebin goal
29%
SHARE
TWEET

[java] TICTACTOE 6.3

Enton95 Mar 30th, 2011 735 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. //Klasse KI
  2. public class KI
  3. {   private SPIELFELD sp;
  4.      
  5.     public KI()
  6.     {
  7.         // stein --> comp sp.fuellen(3,4)
  8.         // Gewinnen des Gegners wird verhindert
  9.        
  10.             if ((sp.wertholen(0, 0) == 3)
  11.                  && (sp.wertholen(2, 0) == 3))
  12.                 sp.fuellen(2,4);
  13.             if ((sp.wertholen(0, 1) == 3)
  14.                  && (sp.wertholen(2, 1) == 3))
  15.                 sp.fuellen(5,4);
  16.             if ((sp.wertholen(0, 2) == 3)
  17.                  && (sp.wertholen(2, 2) == 3))
  18.                 sp.fuellen(8,4);
  19.              if ( (sp.wertholen(0, 0) == 3)
  20.                  && (sp.wertholen(1, 0) == 3))
  21.                  sp.fuellen(3,4);
  22.               if ( (sp.wertholen(0, 1) == 3)
  23.                  && (sp.wertholen(1, 1) == 3))
  24.                  sp.fuellen(6,4);
  25.               if ( (sp.wertholen(0, 2) == 3)
  26.                  && (sp.wertholen(1, 2) == 3))
  27.                  sp.fuellen(9,4);
  28.              if ( (sp.wertholen(1, 0) == 3)
  29.                  && (sp.wertholen(2, 0) == 3))
  30.                  sp.fuellen(1,4);
  31.              if ( (sp.wertholen(1, 1) == 3)
  32.                  && (sp.wertholen(2, 1) == 3))
  33.                  sp.fuellen(4,4);
  34.               if ( (sp.wertholen(1, 2) == 3)
  35.                  && (sp.wertholen(2, 2) == 3))
  36.                  sp.fuellen(7,4);
  37.                  // Zeilen                
  38.                  
  39.             if ((sp.wertholen(0, 0) == 3)
  40.                  && (sp.wertholen(0, 2) == 3))
  41.                  sp.fuellen(4,4);
  42.              if ((sp.wertholen(1, 0) == 3)
  43.                  && (sp.wertholen(1, 2) == 3))
  44.                  sp.fuellen(5,4);
  45.              if ((sp.wertholen(2, 0) == 3)
  46.                  && (sp.wertholen(2, 2) == 3))
  47.                  sp.fuellen(6,4);
  48.              if ((sp.wertholen(0,0) == 3)
  49.                  && (sp.wertholen(0,1) == 3))
  50.                  sp.fuellen(7,4);
  51.              if ((sp.wertholen(1, 0) == 3)
  52.                  && (sp.wertholen(1,1) == 3))
  53.                  sp.fuellen(8,4);
  54.              if ((sp.wertholen(2, 0) == 3)
  55.                  && (sp.wertholen(2, 1) == 3))
  56.                  sp.fuellen(9,4);
  57.              if ((sp.wertholen(0,1) == 3)
  58.                  && (sp.wertholen(0,2) == 3))
  59.                  sp.fuellen(1,4);
  60.              if ((sp.wertholen(1,1) == 3)
  61.                  && (sp.wertholen(1,2) == 3))
  62.                  sp.fuellen(2,4);
  63.              if ((sp.wertholen(2,1) == 3)
  64.                  && (sp.wertholen(2, 2) == 3))
  65.                  sp.fuellen(3,4);
  66.                  //Spalten
  67.  
  68.              if ((sp.wertholen(0,0) == 3)
  69.                  && (sp.wertholen(1,1) == 3))
  70.                  sp.fuellen(9,4);
  71.              if ((sp.wertholen(0,0) == 3)
  72.                  && (sp.wertholen(2, 2) == 3))
  73.                  sp.fuellen(5,4);
  74.             if ((sp.wertholen(1,1) == 3)
  75.                  && (sp.wertholen(2, 2) == 3))
  76.                  sp.fuellen(1,4);
  77.             if ((sp.wertholen(2, 0) == 3)
  78.                  && (sp.wertholen(1,1) == 3))
  79.                  sp.fuellen(7,4);  
  80.             if ((sp.wertholen(2, 0) == 3)
  81.                  && (sp.wertholen(0, 2) == 3))
  82.                  sp.fuellen(5,4);
  83.              if ((sp.wertholen(0,2) == 3)
  84.                  && (sp.wertholen(1,1) == 3))
  85.                  sp.fuellen(3,4);
  86.                  // Diagonalen
  87.                  
  88.  
  89.                  
  90.                 //Gewinnsituation für Computergegner
  91.                
  92.             if ((sp.wertholen(0, 0) == 4)
  93.                  && (sp.wertholen(2, 0) == 4))
  94.                 sp.fuellen(2,4);
  95.             if ((sp.wertholen(0, 1) == 4)
  96.                  && (sp.wertholen(2, 1) == 4))
  97.                 sp.fuellen(5,4);
  98.             if ((sp.wertholen(0, 2) == 4)
  99.                  && (sp.wertholen(2, 2) == 4))
  100.                 sp.fuellen(8,4);
  101.              if ( (sp.wertholen(0, 0) == 4)
  102.                  && (sp.wertholen(1, 0) == 4))
  103.                  sp.fuellen(3,4);
  104.               if ( (sp.wertholen(0, 1) == 4)
  105.                  && (sp.wertholen(1, 1) == 4))
  106.                  sp.fuellen(6,4);
  107.               if ( (sp.wertholen(0, 2) == 4)
  108.                  && (sp.wertholen(1, 2) == 4))
  109.                  sp.fuellen(9,4);
  110.              if ( (sp.wertholen(1, 0) == 4)
  111.                  && (sp.wertholen(2, 0) == 4))
  112.                  sp.fuellen(1,4);
  113.              if ( (sp.wertholen(1, 1) == 4)
  114.                  && (sp.wertholen(2, 1) == 4))
  115.                  sp.fuellen(4,4);
  116.               if ( (sp.wertholen(1, 2) == 4)
  117.                  && (sp.wertholen(2, 2) == 4))
  118.                  sp.fuellen(7,4);
  119.                  // Zeilen
  120.                  
  121.             if ((sp.wertholen(0, 0) == 4)
  122.                  && (sp.wertholen(0, 2) == 4))
  123.                  sp.fuellen(4,4);
  124.              if ((sp.wertholen(1, 0) == 4)
  125.                  && (sp.wertholen(1, 2) == 4))
  126.                  sp.fuellen(5,4);
  127.              if ((sp.wertholen(2, 0) == 4)
  128.                  && (sp.wertholen(2, 2) == 4))
  129.                  sp.fuellen(6,4);
  130.              if ((sp.wertholen(0,0) == 4)
  131.                  && (sp.wertholen(0,1) == 4))
  132.                  sp.fuellen(7,4);
  133.              if ((sp.wertholen(1, 0) == 4)
  134.                  && (sp.wertholen(1,1) == 4))
  135.                  sp.fuellen(8,4);
  136.              if ((sp.wertholen(2, 0) == 4)
  137.                  && (sp.wertholen(2, 1) == 4))
  138.                  sp.fuellen(9,4);
  139.              if ((sp.wertholen(0,1) == 4)
  140.                  && (sp.wertholen(0,2) == 4))
  141.                  sp.fuellen(1,4);
  142.              if ((sp.wertholen(1,1) == 4)
  143.                  && (sp.wertholen(1,2) == 4))
  144.                  sp.fuellen(2,4);
  145.              if ((sp.wertholen(2,1) == 4)
  146.                  && (sp.wertholen(2, 2) == 4))
  147.                  sp.fuellen(3,4);                
  148.                  //Spalten
  149.                  
  150.              if ((sp.wertholen(0,0) == 4)
  151.                  && (sp.wertholen(1,1) == 4))
  152.                  sp.fuellen(9,4);
  153.              if ((sp.wertholen(0,0) == 4)
  154.                  && (sp.wertholen(2, 2) == 4))
  155.                  sp.fuellen(5,4);
  156.              if ((sp.wertholen(1,1) == 4)
  157.                  && (sp.wertholen(2, 2) == 4))
  158.                  sp.fuellen(1,4);
  159.              if ((sp.wertholen(2, 0) == 4)
  160.                  && (sp.wertholen(1,1) == 4))
  161.                  sp.fuellen(7,4);
  162.              if ((sp.wertholen(2, 0) == 4)
  163.                  && (sp.wertholen(0, 2) == 4))
  164.                  sp.fuellen(5,4);
  165.              if ((sp.wertholen(0,2) == 4)
  166.                  && (sp.wertholen(1,1) == 4))
  167.                  sp.fuellen(3,4);
  168.                  
  169.                  // Diagonalen
  170.  
  171.         }
  172.        
  173.     }
  174.  
  175.      
  176.  
  177.  
  178.  
  179. //Klasse Spielfeld
  180. public class SPIELFELD {
  181.         int laenge;
  182.         int[][] feld;
  183.  
  184.         public SPIELFELD(int laengeneu) {
  185.                 feld = new int[3][3];
  186.                 laenge = laengeneu;
  187.                 for (int i = 0; i < 3; i++)
  188.                         for (int k = 0; k < 3; k++)
  189.                                 feld[i][k] = 8;
  190.         }
  191.        
  192.         public void fuellen(int button, int farbe)// Füllen der Kästchen in
  193.                                                                                                 // Abhänigkeit der Buttons
  194.         {
  195.                 if (feld[(button % 3)][(button / 3)] == 8) {
  196.                         ZEICHENFENSTER.gibFenster().fuelleRechteck(
  197.                                         40 + (button % 3) * laenge, 40 + (button / 3) * laenge,
  198.                                         laenge, laenge, farbe);
  199.                         feld[(button % 3)][(button / 3)] = farbe;
  200.                 }
  201.         }
  202.         public int wertholen(int i, int k) {
  203.                 return feld[i][k];
  204.         }
  205. }
  206.  
  207.  
  208. //KLasse TICTACTOE
  209. import javax.swing.*;
  210. import java.awt.event.*;
  211.  
  212. public class TICTACTOE
  213. {
  214.     private SPIELFELD sp;
  215.     private JButton[] Schub;
  216.     private JButton Start;
  217.     private JButton Computerbutton;
  218.     int px, py, laenge, laengeneu, spielzeile, farbe, wert;
  219.     boolean zustand, gewonnen; // Welcher Spieler
  220.  
  221.     public TICTACTOE()
  222.     {
  223.         Schub = new JButton[9];
  224.         sp = new SPIELFELD(100);
  225.         Start = new JButton("START");
  226.         ZEICHENFENSTER.gibFenster().komponenteHinzufuegen(Start, "rechts");
  227.         Computerbutton = new JButton("Computergegner");
  228.         ZEICHENFENSTER.gibFenster().komponenteHinzufuegen(Computerbutton, "rechts");
  229.         zustand = true;
  230.         gewonnen = false;
  231.         laenge = 100;
  232.         px = 40;
  233.         py = 40;
  234.         Start.addActionListener(new ActionListener() // Start-Button wird definiert
  235.         {
  236.             public void actionPerformed(ActionEvent m)
  237.             {
  238.                 zuruecksetzen();// Felder werden gelöscht und neu gezeichnet
  239.                 wertaendern(0, 0);
  240.             }
  241.          } );
  242.         // Ein Allgemeiner ActionListener für die Schub-buttons
  243.         ActionListener schubListener= new ActionListener()
  244.         {
  245.             @Override // Methode aus der Oberklasse wird überschrieben
  246.             public void actionPerformed(ActionEvent ae)
  247.             {
  248.                
  249.                 int buttonNr= Integer.parseInt(ae.getActionCommand());// getActionCommand holt die ButtonNr (ButtonNr wurde als action-command gesetzt! (siehe unten))
  250.                 int k= buttonNr / 3;
  251.                 int i= buttonNr % 3;
  252.                 if (sp.wertholen(i, k) == 8)
  253.                 {
  254.                     if (zustand == true)
  255.                     {
  256.                         sp.fuellen(buttonNr, 4);
  257.                         zustand = false;
  258.                     }
  259.                     else
  260.                     {
  261.                         sp.fuellen(buttonNr, 3);
  262.                         zustand = true;
  263.                     }
  264.                     if (zustand == true)
  265.                         testen(3);
  266.                     else
  267.                         testen(4);
  268.                 }
  269.                 // Deaktivieren wir noch den gerade geklickten button
  270.                 Schub[buttonNr].setEnabled(false);// set Enabled akriviert oder deaktiviert den Menüeintrag (setEnabled(boolean))
  271.             }
  272.         };
  273.         //Schub-buttons in Schleife erzeugen, mit Listener versehen und hinzufügen
  274.         for(int i=0; i < 9; i++)
  275.         {
  276.             Schub[i]= new JButton(Integer.toString((i+1)));
  277.             // Die Button-Nr als action-command des Events von diesem Button setzen.
  278.             Schub[i].setActionCommand(Integer.toString(i)); // erst wenn das andere Ereignis () ausgeführt ist
  279.             Schub[i].addActionListener(schubListener);
  280.             ZEICHENFENSTER.gibFenster().komponenteHinzufuegen(Schub[i], "unten");
  281.              // Soll erst losgehen können wenn "Start" geklickt wird!
  282.             Schub[i].setEnabled(false); // set Enabled akriviert oder deaktiviert den Menüeintrag (setEnabled(boolean))
  283.         }
  284.     }  
  285.     public boolean testen(int testfarbe) // Es wird getestet, ob drei gleiche Farben in einer Reihe, Spalte oder Diagonale liegen
  286.     {
  287.         boolean gewonnen = false;
  288.         if (testfarbe == 4)
  289.         {
  290.             System.out.println("Spieler 2 hat gelegt. Als nächstes Spieler 1");
  291.         }
  292.         else
  293.             System.out.println("Spieler 1 hat gelegt. Als nächstes Spieler 2");
  294.  
  295.         for (int i = 0; i < 3; i++)
  296.             if ((sp.wertholen(0, i) == testfarbe)
  297.                  && (sp.wertholen(1, i) == testfarbe)
  298.                  && (sp.wertholen(2, i) == testfarbe))
  299.                 gewonnen = true; // Zeilen
  300.         for (int i = 0; i < 3; i++)
  301.             if ((sp.wertholen(i, 0) == testfarbe)
  302.                  && (sp.wertholen(i, 1) == testfarbe)
  303.                  && (sp.wertholen(i, 2) == testfarbe))
  304.                 gewonnen = true; // Spalten
  305.         if ((sp.wertholen(0, 0) == testfarbe)
  306.                 && (sp.wertholen(1, 1) == testfarbe)
  307.                 && (sp.wertholen(2, 2) == testfarbe))
  308.             gewonnen = true;// Diagonale
  309.         if ((sp.wertholen(2, 0) == testfarbe)
  310.                 && (sp.wertholen(1, 1) == testfarbe)
  311.                 && (sp.wertholen(0, 2) == testfarbe))
  312.             gewonnen = true; // Diagonale
  313.         if (gewonnen == true)
  314.         {
  315.             if (testfarbe == 4)
  316.             {
  317.                 System.out.println("Spieler 2 hat gewonnen. Für neues Spiel 'Start' drücken");
  318.             }
  319.             else
  320.                 System.out.println("Spieler 1 hat gewonnen. Für neues Spiel 'Start' drücken");
  321.                 einfrieren_nach_gewonnen(); // nach gewonnen wird alles "eingefroren                          
  322.         }
  323.         boolean spielZuende=true;
  324.                 for(int i=0;i<=2;i++)
  325.                 {
  326.                         for(int j=0;j<=2;j++)
  327.                         {
  328.                                 // falls alle felder belegt sind, bleibt spielZuende true
  329.                                 if(sp.wertholen(i, j)==8)
  330.                                 {
  331.                                         spielZuende=false;
  332.                                 }
  333.                         }
  334.                 }
  335.                 if(spielZuende==true&&gewonnen==false){
  336.                         // Dieser Block wird nur bei einem Unentschieden bearbeitet!
  337.                         System.out.println("unentschieden. Für neues Spiel 'Start' drücken");
  338.                 }
  339.         return gewonnen;
  340.     }
  341.     public void wertaendern(int wert, int farbe) // Werte der Felder werden auf null zurückgesetzt, Farben auf weiß
  342.     {
  343.         for (int i = 0; i < 3; i++)
  344.             for (int j = 0; j < 3; j++)
  345.                 sp.feld[i][j] = 8;
  346.         gewonnen = false;
  347.         zustand = false;
  348.     }
  349.     public void zuruecksetzen()// Felder werden gelöscht und neu gezeichnet
  350.     {
  351.         // Alles löschen
  352.         ZEICHENFENSTER.gibFenster().loescheAlles();
  353.         // Neu zeichnen
  354.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px, py, laenge, laenge); // 1
  355.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px + laenge, py, laenge,laenge); // 2
  356.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px + 2 * laenge, py,laenge, laenge); // 3
  357.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px, py + laenge, laenge, laenge); // 4
  358.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px + laenge, py + laenge, laenge, laenge); // 5
  359.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px + 2 * laenge, py + laenge, laenge, laenge); // 6
  360.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px, py + 2 * laenge, laenge, laenge); // 7
  361.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px + 2 * laenge, py + 2 * laenge, laenge, laenge); // 8
  362.         ZEICHENFENSTER.gibFenster().zeichneRechteck(px + laenge, py + 2 * laenge, laenge, laenge); // 9
  363.         // Alle Buttons wieder aktivieren
  364.         for(int i=0; i<9; i++)
  365.             Schub[i].setEnabled(true);// set Enabled akriviert  die Buttons Schub
  366.     }
  367.     public void einfrieren_nach_gewonnen() // nach gewonnen wird alles "eingefroren" und erst wieder nachdem Start geklickt wurde ein neues Spiel beginnen.
  368.     {
  369.             // Alle Schub-Buttons deaktivieren bis "Start" geklickt wurde
  370.             for(int i=0; i<9; i++)
  371.             {
  372.                 Schub[i].setEnabled(false);// set Enabled deaktiviert die Buttons Schub
  373.             }
  374.     }
  375. }
  376.  
  377. // Klasse ZEICHENFENSTER
  378. import javax.swing.*;
  379. import java.awt.*;
  380. import java.awt.geom.*;
  381.  
  382.  
  383.  
  384. public class ZEICHENFENSTER
  385. {
  386.     private JFrame frame;
  387.     private CanvasPane canvas;
  388.     private JPanel steuerungOst,steuerungSued;
  389.     private Graphics2D graphic;
  390.     private Color backgroundColor;
  391.     private Image canvasImage;
  392.    
  393.     private static ZEICHENFENSTER singleton;
  394.  
  395.    
  396.     public ZEICHENFENSTER(String titel)
  397.     {
  398.         this(titel, 600, 500, Color.white);        
  399.     }
  400.  
  401.    
  402.     public ZEICHENFENSTER(String titel, int breite, int hoehe)
  403.     {
  404.         this(titel, breite, hoehe, Color.white);
  405.     }
  406.  
  407.    
  408.     private ZEICHENFENSTER(String titel, int breite, int hoehe, Color hintergrundFarbe)
  409.     {
  410.         frame = new JFrame();
  411.         canvas = new CanvasPane();
  412.         canvas.setPreferredSize(new Dimension(breite, hoehe));
  413.         frame.getContentPane().add(canvas,BorderLayout.CENTER);
  414.         JPanel p1=new JPanel();
  415.         p1.setLayout(new BorderLayout());
  416.         steuerungOst = new JPanel();
  417.         steuerungSued = new JPanel();
  418.         steuerungOst.setLayout(new BoxLayout(steuerungOst,BoxLayout.Y_AXIS));
  419.         steuerungSued.setLayout(new BoxLayout(steuerungSued,BoxLayout.X_AXIS));
  420.         p1.add(steuerungOst,BorderLayout.NORTH);
  421.         frame.getContentPane().add(p1,BorderLayout.EAST);
  422.         frame.getContentPane().add(steuerungSued,BorderLayout.SOUTH);
  423.         frame.setTitle(titel);
  424.         backgroundColor = hintergrundFarbe;
  425.         frame.pack();
  426.         zeige();
  427.     }
  428.  
  429.     public static ZEICHENFENSTER gibFenster()
  430.     {
  431.         if (singleton==null){singleton=new ZEICHENFENSTER("Das Zeichenfenster");}
  432.         singleton.zeige();
  433.         return singleton;
  434.     }
  435.  
  436.    
  437.     public void zeige()
  438.     {
  439.         if(graphic == null) {
  440.            
  441.             Dimension size = canvas.getSize();
  442.             canvasImage = canvas.createImage(size.width, size.height);
  443.             graphic = (Graphics2D)canvasImage.getGraphics();
  444.             graphic.setColor(backgroundColor);
  445.             graphic.fillRect(0, 0, size.width, size.height);
  446.             graphic.setColor(Color.black);
  447.         }
  448.         frame.setVisible(true);
  449.     }
  450.  
  451.    
  452.     public boolean istSichtbar()
  453.     {
  454.         return frame.isVisible();
  455.     }
  456.    
  457.     /**
  458.      * Zeichnet einen Elipsenbogen (Siehe Graphics.drawArc)
  459.      * @param x x-Koordinate des Elipsenmittelpunkts
  460.      * @param y y-Koordinate des Elipsenmittelpunkts
  461.      * @param halbachseX Halbachse der Elipse in x-Richtung
  462.      * @param halbachseY Halbachse der Elipse in y-Richtung
  463.      * @param startWinkel Polarwinkel, an dem der Bogen anfängt
  464.      * @param winkel Polarwinkel, welchen der Bogen durchläuft
  465.      */
  466.     public void zeichneBogen(int x, int y, int halbachseX, int halbachseY, int startWinkel, int winkel)
  467.     {
  468.         graphic.drawArc(x-halbachseX,y-halbachseY,2*halbachseX,2*halbachseY,startWinkel,winkel);
  469.         canvas.repaint();
  470.     }
  471.  
  472.     /**
  473.      * Zeichnet einen Kreis (Siehe Graphics.drawOval)
  474.      * @param x x-Koordinate des Mittelpunkts
  475.      * @param y y-Koordinate des Mittelpunkts
  476.      * @param radius Kreisradius
  477.      */
  478.     public void zeichneKreis(int x, int y, int radius)
  479.     {
  480.         graphic.drawOval(x-radius,y-radius,2*radius,2*radius);
  481.         canvas.repaint();
  482.     }
  483.  
  484.     /**
  485.      * Füllt das Innere eines Kreises mit der angegebenen Farbe.
  486.      * @param x x-Koordinate des Mittelpunkts
  487.      * @param y y-Koordinate des Mittelpunkts
  488.      * @param radius Kreisradius
  489.      * @param  farbe  Füllfarbe für den Kreis, erlaubt sind "weiss" "schwarz" "rot"
  490.      * "gruen" "blau" "gelb" "magenta" "cyan" "grau"
  491.      */
  492.     public void fuelleKreis(int x, int y, int radius, String farbe)
  493.     {
  494.         Color original=graphic.getColor();
  495.         graphic.setColor(farbeZuColor(farbe));
  496.         graphic.fillOval(x-radius,y-radius,2*radius,2*radius);
  497.         canvas.repaint();
  498.         graphic.setColor(original);
  499.     }
  500.    
  501.     /**
  502.      * Füllt das Innere eines Kreises mit der angegebenen Farbe.
  503.      * @param x x-Koordinate des Mittelpunkts
  504.      * @param y y-Koordinate des Mittelpunkts
  505.      * @param radius Kreisradius
  506.      * @param  farbnr  Füllfarbnummer für den Kreis (0 bis 8)
  507.      */
  508.     public void fuelleKreis(int x, int y, int radius, int farbnr)
  509.     {
  510.         Color original=graphic.getColor();
  511.         graphic.setColor(farbeZuColor(farbnr));
  512.         graphic.fillOval(x-radius,y-radius,2*radius,2*radius);
  513.         canvas.repaint();
  514.         graphic.setColor(original);
  515.     }
  516.    
  517.     /**
  518.      * Löscht das Innere eines Kreises
  519.      * @param x x-Koordinate des Mittelpunkts
  520.      * @param y y-Koordinate des Mittelpunkts
  521.      * @param radius Kreisradius
  522.      */
  523.     public void loescheKreis(int x, int y, int radius)
  524.     {
  525.         Ellipse2D.Double circle = new Ellipse2D.Double(x-radius, y-radius, 2*radius, 2*radius);
  526.         loesche(circle);
  527.     }
  528.  
  529.     /**
  530.      * Zeichnet den Umriss eines Shape-Objekts.
  531.      * @param  shape  das Shape-Object, welches gezeichnet werden soll
  532.      */
  533.     public void zeichne(Shape shape)
  534.     {
  535.         graphic.draw(shape);
  536.         canvas.repaint();
  537.     }
  538.  
  539.     /**
  540.      * Füllt das Innere eines Shape-Objekts mit der angegebenen Farbe.
  541.      * @param  shape  das Shape-Objekt, welches gefüllt werden soll
  542.      * @param  farbe  Füllfarbe für das Shape-Objekt, erlaubt sind "weiss" "schwarz" "rot"
  543.      * "gruen" "blau" "gelb" "magenta" "cyan" "grau"
  544.      */
  545.     public void fuelle(Shape shape, String farbe)
  546.     {
  547.         Color original=graphic.getColor();
  548.         graphic.setColor(farbeZuColor(farbe));
  549.         graphic.fill(shape);
  550.         canvas.repaint();
  551.         graphic.setColor(original);
  552.     }
  553.  
  554.     /**
  555.      * Füllt das Innere eines Shape-Objekts mit der angegebenen Farbe.
  556.      * @param  shape  das Shape-Objekt, welches gefüllt werden soll
  557.      * @param  farbnr  Füllfarbnummer für das Shape-Objekt (0 bis 8)
  558.      */
  559.     public void fuelle(Shape shape, int farbnr)
  560.     {
  561.         Color original=graphic.getColor();
  562.         graphic.setColor(farbeZuColor(farbnr));
  563.         graphic.fill(shape);
  564.         canvas.repaint();
  565.         graphic.setColor(original);
  566.     }
  567.  
  568.     /**
  569.      * Löscht das Innere eines Shape-Objekts.
  570.      * @param  shape  das Shape-Object, welches gelöscht werden soll
  571.      */
  572.     public void loesche(Shape shape)
  573.     {
  574.         Color original = graphic.getColor();
  575.         graphic.setColor(backgroundColor);
  576.         graphic.fill(shape);              // erase by filling background color
  577.         graphic.setColor(original);
  578.         canvas.repaint();
  579.     }
  580.  
  581.     /**
  582.      * Zeichnet den Rand des Rechtecks mit der aktuellen Farbe.
  583.      * @param xPos,yPos Koordinaten der linken oberen Ecke
  584.      * @param breite, hoehe Breite und Höhe des Rechtecks
  585.      */
  586.     public void zeichneRechteck(int xPos, int yPos, int breite, int hoehe)
  587.     {
  588.         graphic.drawRect(xPos, yPos, breite, hoehe);
  589.         canvas.repaint();
  590.        // fill(new Rectangle(xPos, yPos, breite, hoehe));
  591.     }
  592.  
  593.     /**
  594.      * Füllt das Innere des Rechtecks mit der angegebenen Farbe.
  595.      * @param xPos,yPos Koordinaten der linken oberen Ecke
  596.      * @param breite, hoehe Breite und Höhe des Rechtecks
  597.      * @param  farbe  Füllfarbe für das Rechteck, erlaubt sind "weiss" "schwarz" "rot"
  598.      * "gruen" "blau" "gelb" "magenta" "cyan" "grau"
  599.      */
  600.     public void fuelleRechteck(int xPos, int yPos, int breite, int hoehe, String farbe)
  601.     {
  602.         Color original=graphic.getColor();
  603.         graphic.setColor(farbeZuColor(farbe));
  604.         graphic.fillRect(xPos, yPos, breite, hoehe);
  605.         canvas.repaint();
  606.         graphic.setColor(original);
  607.     }
  608.  
  609.     /**
  610.      * Füllt das Innere des Rechtecks mit der angegebenen Farbe.
  611.      * @param xPos,yPos Koordinaten der linken oberen Ecke
  612.      * @param breite, hoehe Breite und Höhe des Rechtecks
  613.      * @param  farbnr  Füllfarbnummer für das Rechteck (0 bis 8)
  614.      */
  615.     public void fuelleRechteck(int xPos, int yPos, int breite, int hoehe, int farbnr)
  616.     {
  617.         Color original=graphic.getColor();
  618.         graphic.setColor(farbeZuColor(farbnr));
  619.         graphic.fillRect(xPos, yPos, breite, hoehe);
  620.         canvas.repaint();
  621.         graphic.setColor(original);
  622.     }
  623.  
  624.     /**
  625.      * Löscht das Innere eines Rechtecks.
  626.      * @param xPos,yPos Koordinaten der linken oberen Ecke
  627.      * @param breite, hoehe Breite und Höhe des Rechtecks
  628.      */
  629.     public void loescheRechteck(int xPos, int yPos, int breite, int hoehe)
  630.     {
  631.         loesche(new Rectangle(xPos, yPos, breite, hoehe));
  632.     }
  633.    
  634.     private Polygon gibDreieck(int x1, int y1, int x2, int y2, int x3, int y3)
  635.     {
  636.         Polygon p=new Polygon();
  637.         p.addPoint(x1,y1);
  638.         p.addPoint(x2,y3);
  639.         p.addPoint(x3,y3);
  640.         return p;
  641.     }
  642.    
  643.     /**
  644.      * Zeichnet den Rand eines Dreiecks mit der aktuellen Farbe.
  645.      * @param x1,y1 Koordinaten des ersten Eckpunkts
  646.      * @param x2,y2 Koordinaten des zweiten Eckpunkts
  647.      * @param x3,y3 Koordinaten des dritten Eckpunkts
  648.      */
  649.     public void zeichneDreieck(int x1, int y1, int x2, int y2, int x3, int y3)
  650.     {
  651.         graphic.drawPolygon(gibDreieck(x1, y1, x2, y2, x3, y3));
  652.         canvas.repaint();
  653.     }
  654.  
  655.     /**
  656.      * Füllt das Innere eines Dreiecks mit der angegebenen Farbe.
  657.      * @param x1,y1 Koordinaten des ersten Eckpunkts
  658.      * @param x2,y2 Koordinaten des zweiten Eckpunkts
  659.      * @param x3,y3 Koordinaten des dritten Eckpunkts
  660.      * @param  farbe  Füllfarbe für das Dreieck, erlaubt sind "weiss" "schwarz" "rot"
  661.      * "gruen" "blau" "gelb" "magenta" "cyan" "grau"
  662.      */
  663.     public void fuelleDreieck(int x1, int y1, int x2, int y2, int x3, int y3, String farbe)
  664.     {
  665.         Color original=graphic.getColor();
  666.         graphic.setColor(farbeZuColor(farbe));
  667.         graphic.fillPolygon(gibDreieck(x1, y1, x2, y2, x3, y3));
  668.         canvas.repaint();
  669.         graphic.setColor(original);
  670.     }
  671.  
  672.     /**
  673.      * Füllt das Innere eines Dreiecks mit der angegebenen Farbe.
  674.      * @param x1,y1 Koordinaten des ersten Eckpunkts
  675.      * @param x2,y2 Koordinaten des zweiten Eckpunkts
  676.      * @param x3,y3 Koordinaten des dritten Eckpunkts
  677.      * @param  farbnr  Füllfarbnummer für das Dreieck (0 bis 8)
  678.      */
  679.     public void fuelleDreieck(int x1, int y1, int x2, int y2, int x3, int y3, int farbnr)
  680.     {
  681.         Color original=graphic.getColor();
  682.         graphic.setColor(farbeZuColor(farbnr));
  683.         graphic.fillPolygon(gibDreieck(x1, y1, x2, y2, x3, y3));
  684.         canvas.repaint();
  685.         graphic.setColor(original);
  686.     }
  687.  
  688.     /**
  689.      * Löscht das Innere eines Dreicks
  690.      * @param x1,y1 Koordinaten des ersten Eckpunkts
  691.      * @param x2,y2 Koordinaten des zweiten Eckpunkts
  692.      * @param x3,y3 Koordinaten des dritten Eckpunkts
  693.      */
  694.     public void loescheDreieck(int x1, int y1, int x2, int y2, int x3, int y3)
  695.     {
  696.         loesche(gibDreieck(x1, y1, x2, y2, x3, y3));
  697.     }
  698.  
  699.     /**
  700.      * Löscht den Inhalt des Zeichenfensters.
  701.      */
  702.     public void loescheAlles()
  703.     {
  704.         Color original = graphic.getColor();
  705.         graphic.setColor(backgroundColor);
  706.         Dimension size = canvas.getSize();
  707.         graphic.fill(new Rectangle(0, 0, size.width, size.height));
  708.         graphic.setColor(original);
  709.         canvas.repaint();
  710.     }
  711.  
  712.     /**
  713.      * Löscht den Umriss eines Shape-Objekts.
  714.      * @param  shape  das Shape-Object, dessen Umriss gelöscht werden soll
  715.      */
  716.     public void loescheRand(Shape shape)
  717.     {
  718.         Color original = graphic.getColor();
  719.         graphic.setColor(backgroundColor);
  720.         graphic.draw(shape);  // Löschen durch übermalen mit Hintergrundfarbe
  721.         graphic.setColor(original);
  722.         canvas.repaint();
  723.     }
  724.  
  725.     /**
  726.      * Zeichnet ein Bild in das Zeichnenfenster .
  727.      * @param  bild    das anzuzeigende Bild
  728.      * @param  x       x-Koordinate des linken Bildrands
  729.      * @param  y       y-Koordinate des oberen Bildrands
  730.      * @return  gibt eines booleschen Wert zurück, der angibt, ob das Bild vollständig geladen
  731.      *          werden konnte
  732.      */
  733.     public boolean zeichneBild(Image bild, int x, int y)
  734.     {
  735.         boolean result = graphic.drawImage(bild, x, y, null);
  736.         canvas.repaint();
  737.         return result;
  738.     }
  739.  
  740.     /**
  741.      * Zeichnet einen Text.
  742.      * @param  text    die anzuzeigende Zeichenkette
  743.      * @param  x       x-Koordinate des linken Rands
  744.      * @param  y       y-Koordinate des oberen Rands
  745.      */
  746.     public void zeichneText(String text, int x, int y)
  747.     {
  748.         graphic.drawString(text, x, y);  
  749.         canvas.repaint();
  750.     }
  751.  
  752.     /**
  753.      * Löscht einen Text vom Zeichenfenster.
  754.      * @param  text    die zu löschende Zeichenkette
  755.      * @param  x       x-Koordinate des linken Rands
  756.      * @param  y       y-Koordinate des oberen Rands
  757.      */
  758.     public void loescheText(String text, int x, int y)
  759.     {
  760.         Color original = graphic.getColor();
  761.         graphic.setColor(backgroundColor);
  762.         graphic.drawString(text, x, y);  
  763.         graphic.setColor(original);
  764.         canvas.repaint();
  765.     }
  766.  
  767.     /**
  768.      * Zeichnet eine Strecke ins Zeichenfenster.
  769.      * @param  x1   x-Koordinate des Anfangspunkts der Strecke
  770.      * @param  y1   y-Koordinate des Anfangspunkts der Strecke
  771.      * @param  x2   x-Koordinate des Endpunkts der Strecke
  772.      * @param  y2   y-Koordinate des Endpunkts der Strecke  
  773.      */
  774.     public void zeichneStrecke(int x1, int y1, int x2, int y2)
  775.     {
  776.         graphic.drawLine(x1, y1, x2, y2);  
  777.         canvas.repaint();
  778.     }
  779.  
  780.     /**
  781.      * Setzt die Vordergrundfarbe des Zeichenfensters.
  782.      * @param  neueFarbe   neue Vordergrundfarbe
  783.      */
  784.     public void setzeVordergrundFarbe(String neueFarbe)
  785.     {
  786.         graphic.setColor(farbeZuColor(neueFarbe));
  787.     }
  788.     private void setzeVordergrundFarbe(Color neueFarbe)
  789.     {
  790.         graphic.setColor(neueFarbe);
  791.     }
  792.    
  793.     private Color farbeZuColor(int farbnr)
  794.     {
  795.         switch (farbnr)
  796.         {
  797.             case 0: return Color.black;
  798.             case 1: return Color.blue;
  799.             case 2: return Color.green;
  800.             case 3: return Color.cyan;
  801.             case 4: return Color.red;
  802.             case 5: return Color.magenta;
  803.             case 6: return Color.yellow;
  804.             case 7: return Color.gray;
  805.             case 8: return Color.white;
  806.             default: return graphic.getColor();
  807.         }
  808.        
  809.     }
  810.    
  811.     private Color farbeZuColor(String farbe)
  812.     {
  813.         if (farbe=="weiss") return Color.white;
  814.         if (farbe=="schwarz") return Color.black;
  815.         if (farbe=="rot") return Color.red;
  816.         if (farbe=="gruen") return Color.green;
  817.         if (farbe=="blau") return Color.blue;
  818.         if (farbe=="gelb") return Color.yellow;
  819.         if (farbe=="magenta") return Color.magenta;
  820.         if (farbe=="cyan") return Color.cyan;
  821.         if (farbe=="grau") return Color.gray;
  822.         return graphic.getColor();
  823.     }
  824.    
  825.     private String colorZuFarbe(Color color)
  826.     {
  827.         if (color==Color.white) return "weiss";
  828.         if (color==Color.black) return "schwarz";
  829.         if (color==Color.red) return "rot";
  830.         if (color==Color.green) return "gruen";
  831.         if (color==Color.blue) return "blau";
  832.         if (color==Color.yellow) return "gelb";
  833.         if (color==Color.magenta) return "magenta";
  834.         if (color==Color.cyan) return "cyan";
  835.         if (color==Color.gray) return "gruen";
  836.         return "";
  837.     }
  838.  
  839.     /**
  840.      * Gibt die aktuelle Vordergrundfarbe des Zeichenfensters zurück.
  841.      * @return   die aktuelle Vordergrundfarbe
  842.      */
  843.     public String gibVordergrundFarbe()
  844.     {
  845.         return colorZuFarbe(graphic.getColor());
  846.     }
  847.     //public Color gibVordergrundFarbe()
  848.     //{
  849.     //    return graphic.getColor();
  850.     //}
  851.  
  852.     /**
  853.      * Setzt die Hintergrundfarbe des Zeichenfensters.
  854.      * @param  neueFarbe   neue Hintergrundfarbe
  855.      */
  856.     public void setzeHintergrundFarbe(String neueFarbe)
  857.     {
  858.         backgroundColor = farbeZuColor(neueFarbe);  
  859.         graphic.setBackground(backgroundColor);
  860.     }
  861.     private void setzeHintergrundFarbe(Color neueFarbe)
  862.     {
  863.         backgroundColor = neueFarbe;  
  864.         graphic.setBackground(neueFarbe);
  865.     }
  866.  
  867.     /**
  868.      * Gibt die aktuelle Hintergrundfarbe des Zeichenfensters zurück.
  869.      * @return   die aktuelle Hintergrundfarbe
  870.      */
  871.     public String gibHintergrundFarbe()
  872.     {
  873.         return colorZuFarbe(backgroundColor);
  874.     }
  875.     //public Color gibHintergrundFarbe()
  876.     //{
  877.     //    return backgroundColor;
  878.     //}
  879.  
  880.     /**
  881.      * Ändert den aktuellen Zeichensatz des Zeichenfensters.
  882.      * @param  neuerZeichensatz   Zeichensatz, der künftig für Zeichenkettenausgaben verwendet wird
  883.      */
  884.     public void setzeZeichensatz(Font neuerZeichensatz)
  885.     {
  886.         graphic.setFont(neuerZeichensatz);
  887.     }
  888.  
  889.     /**
  890.      * Gibt den aktuellen Zeichensatz des Zeichenfensters zurück.
  891.      * @return     den aktuellen Zeichensatz
  892.      **/
  893.     public Font gibZeichensatz()
  894.     {
  895.         return graphic.getFont();
  896.     }
  897.  
  898.     /**
  899.      * Ändert die Abmessungen des Zeichenfensters.
  900.      * @param  breite    neue Breite
  901.      * @param  hoehe     neue Höhe
  902.      */
  903.     public void setzeMasse(int breite, int hoehe)
  904.     {
  905.         canvas.setPreferredSize(new Dimension(breite, hoehe));
  906.         Image oldImage = canvasImage;
  907.         canvasImage = canvas.createImage(breite, hoehe);
  908.         graphic = (Graphics2D)canvasImage.getGraphics();
  909.         graphic.drawImage(oldImage, 0, 0, null);
  910.         frame.pack();
  911.     }
  912.  
  913.     /**
  914.      * Gibt die Abmessungen des Zeichenfensters zurück.
  915.      * @return     die aktuellen Abmessungen des Zeichenfensters
  916.      */
  917.     public Dimension gibMasse()
  918.     {
  919.         return canvas.getSize();
  920.     }
  921.  
  922.     /**
  923.      * Wartet eine bestimmte Zeit.
  924.      * Eine kurze Verzögerung kann z. B. für Animationen verwendet werden.
  925.      * @param  zeit  Wartezeit in Millisekunden
  926.      */
  927.     public void warte(int zeit)
  928.     {
  929.         try
  930.         {
  931.             Thread.sleep(zeit);
  932.         }
  933.         catch (InterruptedException e)
  934.         {
  935.             // ignoring exception at the moment
  936.         }
  937.     }
  938.  
  939.     /**
  940.      * Fügt ein weiteres Steuerungselement in die rechte Steuerungsleiste ein.
  941.      * @param  element  Das einzufügende Steuerungselement muss aus JComponent abgeleitet
  942.      * sein. z. B. JButton, JComboBox.
  943.      */
  944.     public void komponenteHinzufuegen(JComponent element, String position)
  945.     {
  946.         if (position=="rechts") steuerungOst.add(element);
  947.         else if (position=="unten") steuerungSued.add(element);
  948.         frame.pack();
  949.     }
  950.    
  951.     /**
  952.      * Beschriftet den Titel des Zeichenfensters neu.
  953.      * @param  titelNeu  Text der neuen Fensterüberschrift
  954.      */
  955.     public void setzeTitel(String titelNeu)
  956.     {
  957.         frame.setTitle(titelNeu);
  958.     }
  959.  
  960.     /************************************************************************
  961.      * Nested class CanvasPane - the actual canvas component contained in the
  962.      * Canvas frame. This is essentially a JPanel with added capability to
  963.      * refresh the image drawn on it.
  964.      */
  965.     private class CanvasPane extends JPanel
  966.     {
  967.         private static final long serialVersionUID = 20060330L;
  968.        
  969.         public void paint(Graphics g)
  970.         {
  971.             g.drawImage(canvasImage, 0, 0, null);
  972.         }
  973.     }
  974. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand