Dies ist das letzte Kursdesign für Java -Kurse. Da Java ein Anfänger ist, habe ich dabei auf einige Blogs technischer Experten verwiesen. Ich möchte hier meine Dankbarkeit ausdrücken.
Hier posten, um zu kommunizieren und zu lernen.
Wenn Sie vollständige Projektdateien, Dokumentationen und Runnable -JAR -Dateien benötigen, laden Sie die Adresse herunter: Klicken Sie auf, um den Link zu öffnen
RussianBlocksgame.java
Paket RusssiaBlocksgame; import Java.awt.*; import Java.awt.event.*; import javax.swing.border.border; import Javax.swing.border.AdchedBorder; /*** Die Hauptspielklasse, die aus der JFRAME -Klasse geerbt wurde, ist für die globale Kontrolle des Spiels verantwortlich. Beinhaltet: 1. Ein Instanzobjekt der Gamecanvas -Leinwandklasse, * 2. Ein Objekt, das den aktuellen aktiven Block (RusssiaBlock) Instanz hält; 3. Ein Objekt, das das aktuelle Instanz des Steuerungspanels (Controlpanel) enthält; */ public class RusssiaBlocksgame erweitert JFrame {private statische endgültige lange Serialversionuid = -7332245439279674749L; / *** Wie viele Punkte werden für jede Zeile gefüllt*/ öffentliches endgültiges statisches int per_line_score = 100; / *** Wie viele Punkte können nach der Akkumulation aktualisiert werden*/ Public Final static int per_level_score = per_line_score* 20; / *** Die maximale Serie ist Stufe 10*/ Public Final static int max_level = 10; / ** * Die Standardserie ist 2 */ öffentliches endgültiges statisches int default_level = 2; private Gamecanvas -Leinwand; Privatererblock; privates Boolescher Spiel = Falsch; private controlpanel ctrlpanel; // Menüleiste initialisieren. private jmenu mgame = new Jmenu ("game"), mcontrol = new JMenu ("Kontrolle"), minfo = new JMenu ("Hilfe"); private JMenuItem miNewGame = new JMenuItem("New Game"), miSetBlockColor = new JMenuItem("Set Block Color..."), miSetBackColor = new JMenuItem("Set Background Color..."), miTurnHarder = new JMenuItem("Elevate Game Difficulty"), miTurnEasier = new JMenuItem("Reduce Game Difficulty"), miExit = New JMenuitem ("Exit"), Miplay = New JMenuitem ("Start"), Mipause = New JMenuitem ("Pause"), Miresume = New JMenuitem ("Resume"), Mistop = new JMenuitem ("Beendigung des Spiels"), Mirule = New Jmenuitem ("Game -Regeln"). / *** das Fenstermenü erstellen und festlegen*/ private void CreateMenu () {bar.add (mgame); bar.add (mcontrol); bar.add (minfo); mgame.add (minewgame); mgame.addSesparator (); // horizontale Split -Linie mgame.add (MisetblockColor) hinzufügen; mgame.add (misetblockcolor); mgame.addSesparator (); // horizontale Split -Linie mgame.add (Miturnharder) hinzufügen; mgame.add (Miturneasier); mgame.addSesparator (); // horizontale Split -Linie mgame.add (miexit) hinzufügen; mcontrol.add (miplay); miplay.setenabled (true); mcontrol.add (Mipause); mipause.setenabled (false); mcontrol.add (Miresume); miresume.setEnabled (false); mcontrol.add (Mistop); Mistop.SetEnabled (falsch); Minfo.Add (Mirule); minfo.add (miautor); setjMenubar (bar); minewgame.addactionListener (new ActionListener () {@Override public void actionPerformed (actionEvent e) {stopegame (); reset (); setlevel (default_level);}}); // Setzen Sie die Blockfarbe MisetblockColor.AddactionListener (new actionListener () {@Override public void -actionPerformed (actionEvent e) {color newfrontcolor = jcolorchooser {canvas.setBlockColor (NewFrontColor); // Setzen Sie die Hintergrundfarbe MisetbackColor.AddactionListener (new actionListener () {@Override public void ActionPerformed (actionEvent e) {color newbackcolor = jcolorchooser.showdialog (RusssiableSgame.This, "Set die Background Color). canvas.setbackgroundColor (newbackColor); // Definieren Sie die Funktion der Menüleiste "About" und ein Bestätigungsbox auftaucht auf. miautor.addactionListener (new actionListener () {@Override public void actionPerformed (actionEvent e) {joptionpane }); // Spielregeln Beschreibung Mirule.addactionListener (new ActionListener () {@Override public void ActionPerformed (actionEvent e) {joptionpane.showmessagedialog (Null ", Platten mit verschiedenen Formen, die aus kleinen Quadräten bestehen, fallen von der Oberseite des Siebs nach dem Schieber. Die PLEISE -SCRETOR -DER SCREDS -SCREDS -SCREDS -SCRETEN ANGETTEN. Komplette horizontale Balken werden sofort für die neuen /n gefallenen Teller entstehen. // Erhöhen Sie die Schwierigkeit MITURNHARDER.AddActionListener (new ActionListener () {@Override public void ActionPerformed (actionEvent e) {int curlevel = getlevel (); if (! Spiele && curlevel <max_level) {setlevel (curlevel + 1);}}}}); // Die Schwierigkeit miturneasier.AddactionListener (new ActionListener () {@Override public void ActionPerformed (actionEvent e) {int curlevel = getlevel (); if (! Spiele && curlevel> 1) {setlevel (curlevel - 1);}}}); // Button Action -Antwort miexit.addactionListener (new ActionListener () {@Override public void actionPerformed (actionEvent e) {System.exit (0);}}); } / *** Konstruktorenmethode der Hauptspielklasse** @param title String, Fenstertitel* / public Russsiabllocksgame (String -Titel) {Super (title); // Setzen Sie den Titel SetSize (500, 600); // Setzen Sie die Fenstergröße SetLocationRelativeto (NULL); // Setzen Sie das Fensterzentrum CreateMenu (); Container Container = getContentPane (); // Menüleiste erstellen Container. // Setzen Sie den Layout -Manager des Fensters canvas = new gamecanvas (20, 15); // Erstellen Sie ein neues Spiel Canvas Strlpanel = New ControlPanel (this); // Erstellen Sie einen neuen Control Panel Container.Add (Canvas, BorderLayout.Center); // Canvas Container.add (Strlpanel, BorderLayout.East) hinzufügen; // Das Bedienfeld rechts hinzufügen // Fenster für die Fenster registrieren. Wenn die Schaltfläche Schließen klickt, endet das Spiel und das System beendet. addWindowlistener (neuer Fensteradapter () {@Override public void windowsClosieren (windowEvent WE) {stopegame (); System.Exit (0);}}); // Die Größe des Quadrats automatisch entsprechend der Fenstergröße addComponentListener (neuer componentAdapter () {@Override public void componentressized (componentEvent ce) {canvas.adjust ();}}) anpassen; setvisible (wahr); canvas.adjust (); } /*** das Spiel zurücksetzen* /public void reset () {// Die Leinwand zurücksetzen und das Bedienfeld ctrlpanel.setPlayButtonenable (true) zurücksetzen; Strlpanel.SetPauseButtonNable (Falsch); ctrlpanel.setPauseButtonLabel (true); Strlpanel.SetStopbuttonenable (falsch); ctrlpanel ctrlpanel miplay.setenabled (true); mipause.setenabled (false); miresume.setEnabled (false); Mistop.SetEnabled (falsch); Strlpanel.reset (); canvas.reset (); } / *** Bestimmen Sie, ob das Spiel noch im Gange ist } / *** den aktuell aktiven Block erhalten** @return ersblock, die Referenz des aktuell aktiven Blocks* / public ersblock getCurBlock () {return block; } / *** Holen Sie sich die aktuelle Leinwand** @return gamecanvas, die Referenz der aktuellen Leinwand* / public gamecanvas getCanvas () {return canvas; } / *** starten Sie das Spiel* / public void Playgame () {Play (); ctrlpanel.setPlayButtonenable (falsch); Strlpanel.setPauseButtonenable (true); ctrlpanel.setPauseButtonLabel (true); ctrlpanel.setStopbuttonenable (true); ctrlpanel Strlpanel.SetturnLevelUpButtonenable (falsch); Mistop.SetEnabled (true); Miturnharder.SetEnabled (falsch); Miturnasiser.SetEnabled (false); Strlpanel.RequestFocus (); // Fokus auf das Bedienfeld}/*** Game Pause*/public void pauseGame () {if (block! = Null) {block.pausemove (); } ctrlpanel.setPlayButtonEnable (false); ctrlpanel.setPauseButtonLabel (false); ctrlpanel.setStopbuttonenable (true); miplay.setenabled (false); mipause.setenabled (false); miresume.setEnabled (true); Mistop.SetEnabled (true); } / *** Lassen Sie das pausierte Spiel fortsetzen* / public void resumegame () {if (block! } ctrlpanel.setPlayButtonEnable (false); Strlpanel.setPauseButtonenable (true); ctrlpanel.setPauseButtonLabel (true); mipause.setenabled (true); miresume.setEnabled (false); Strlpanel.RequestFocus (); } / *** Der Benutzer stoppt das Spiel* / public void stopgame () {spiele = false; if (block! = null) {block.stopMove (); } ctrlpanel.setPlayButtonEnable (true); Strlpanel.SetPauseButtonNable (Falsch); ctrlpanel.setPauseButtonLabel (true); Strlpanel.SetStopbuttonenable (falsch); ctrlpanel ctrlpanel miplay.setenabled (true); mipause.setenabled (false); miresume.setEnabled (false); Mistop.SetEnabled (falsch); Miturnharder.SetEnabled (true); Miturnasiser.SetEnabled (true); reset (); // Set Canvas und Control Panel}/** * den durch den Spieler festgelegten Schwierigkeitsgrad erhalten * * @return int, Spielschwierigkeit 1-max_level */public int getlevel () {return Strlpanel.getlevel (); } / ** * Benutzer setzt Spielschwierigkeitsgrad * * @param Level int, Game-Schwierigkeitsgrad 1-max_level }} / *** Game Points** @return int, Punkte* / public int getCore () {if (canvas! = Null) {return canvas.getScore (); } return 0; } /*** Holen Sie sich Spielpunkte seit dem letzten Upgrade. Nach dem Upgrade wird dieser Punkt gelöscht. } return 0; } / ** * Wenn sich das Integral zu einem bestimmten Wert ansammelt, upgraden Sie einmal auf * * @return boolean, true-update successe, false-update fail * / public boolean Levelupdate () {int Curlevel = getlevel (); if (Curlevel <max_level) {setlevel (Curlevel + 1); canvas.resetsCoreforlevelUpDate (); zurückkehren; } return false; } / *** Game Start* / private void Play () {reset (); spiele = wahr; Thread Thread = neuer Thread (new Game ()); // Starten Sie den Spiel Thread.start (); } / *** Bericht Das Spiel ist über* / private void reportGameOver () {new GameOverDialog (this, "tetris", "Das Spiel endet, Ihre Punktzahl ist" + canvas.getScore ()); } /*** Eine Runde des Spielprozesses, in dem die Runnable -Schnittstelle implementiert wird. Eine Spielrunde ist eine große Schleife. Überprüfen Sie in dieser Schleife alle 100 Millisekunden, ob der aktuelle Block im Spiel das Ende erreicht hat. Wenn nicht, wird * weiter warten. Wenn es am Ende geht, hängt es davon ab, ob es eine voll gefüllte Linie gibt. Wenn es vorhanden ist, löschen Sie es und fügen Sie dem Player Punkte hinzu, generieren Sie zufällig einen neuen aktuellen Block und lassen Sie ihn automatisch fallen. * Wenn ein neuer Block erzeugt wird, überprüfen Sie zunächst, ob die Linie oben auf der Leinwand besetzt ist. Wenn ja, können Sie das Spiel beurteilen. */ Private Class -Spiel implementiert runnable {@Override public void run () {int col = (int) (math.random () * (canvas.getCols () - 3); // erzeugt zufällig die Position des Blocks int style = ersblock einer Form, während (spielt) {if (block! Thread.Sleep (500); } catch (InterruptedException dh) {ie.printstacktrace (); } weitermachen; }} CheckFoFUrline (); // Überprüfen Sie, ob es vollständig ausgefüllte Zeilen gibt, wenn (isGameOver ()) {ReportGameOver (); miplay.setenabled (true); mipause.setenabled (false); miresume.setEnabled (false); Mistop.SetEnabled (falsch); ctrlpanel.setPlayButtonenable (true); ctrlpanel.setPauseButtonLabel (false); Strlpanel.SetStopbuttonenable (falsch); zurückkehren; } block = new ersblock (style, -1, col, getlevel (), canvas); block.start (); col = (int) (math.random () * (canvas.getCols () - 3)); style = ersblock.styles [(int) (math.random () * 7)] [(int) (math.random () * 4)]; Strlpanel.Settipstyle (Stil); }} // Überprüfen Sie, ob in der Leinwand vollständig ausgefüllte Zeilen vorhanden sind. Wenn es einen gibt, löschen Sie es public void Checkfofulline () {für (int i = 0; i <canvas.getRows (); i ++) {int row = -1; boolean fulllinecolorbox = true; für (int j = 0; j <canvas.getCols (); j ++) {if (! canvas.getBox (i, j) .iscolorbox ()) {fullLinEcolorbox = false; brechen; }} if (fulllineColorbox) {row = i--; canvas.removeline (row); }}} // beurteilen, ob das Spiel beendet ist, basierend darauf, ob die obere Zeile besetzt ist //@return boolean, das Spiel ist vorbei, das Spiel ist nicht über private boolean isgameover () {für (int i = 0; i <canvas.getCols (); if (box.iscolorbox ()) {return true; }} return false; }} /*** Definieren Sie das Dialogfeld "Gameover". */ @Suppresswarnings ("Serial") privatklasse GameOverDialog erweitert JDialog implementiert ActionListener {private Jbutton Nuthbutton, ExitButton; private Grenzgrenze = neuer geätzter Border (geätztborder. Erhöht, Farbe.White, neue Farbe (148, 145, 140)); public GameOverDialog (JFrame Elternteil, String -Titel, String -Nachricht) {super (übergeordnet, Titel, True); if (parent! = null) {setSize (240, 120); this.setLocationRelativeto (Eltern); Jpanel messagePanel = new Jpanel (); messagePanel.add (New JLabel (Nachricht)); MessagePanel.SetBorder (Grenze); Container container = this.getContentPane (); Container.SetLayout (neuer GridLayout (2, 0, 0, 10)); Container.Add (MessagePanel); Jpanel choosepanel = new Jpanel (); choosepanel.setLayout (neuer GridLayout (0, 2, 4, 0)); Container.Add (Choosepanel); wiederbutton = new Jbutton ("ein anderes Spiel spielen"); ExitButton = New Jbutton ("Exit Game"); choosepanel.add (new jpanel (). add (wiederbutton)); choosepanel.add (new jpanel (). add (exitbutton)); Choosepanel.SetBorder (Grenze); } NOTERBUTTON.ADDACTIONIERTIERTEER (this); exitbutton.addactionListener (this); this.setvisible (true); } @Override public void actionPerformed (actionEvent e) {if (e.getSource () == NOTERBUTTON) {this.setVisible (false); zurücksetzen(); } else if (e.getSource () == exitbutton) {stopegame (); System.exit (0); }}}}Gamecanvas.java
Paket RusssiaBlocksgame; Import Java.awt.Color; importieren java.awt.graphics; import Javax.swing.jpanel; import Javax.swing.border.AdchedBorder; /*** Canvas -Klasse mit <Anzahl der Zeilen>* <Anzahl der Spalten> Quadratklasseninstanzen. Von der JPanel -Klasse geerbt. Die Ersblock -Thread -Klasse verändert die Gitterfarbe der Leinwandklasse dynamisch. Die Canvas -Klasse verwendet *, um die Gitterfarbe zu überprüfen, um die Bewegung des Ersblockblocks widerzuspiegeln. */ Public Class Gamecanvas erweitert JPanel {private statische endgültige lange Serialversionuid = 6732901391026089276L; private farb backcolor = color.darkgray, FrontColor = color.white; Private int Zeilen, Cols, Score = 0, ScoreForLevelUpDate = 0; private ersbox [] [] Boxen; private int boxwidth, BoxHeight; / *** Konstruktor der Canvas -Klasse** @param Zeilen int, die Anzahl der Zeilen der Leinwand* @param cols int, die Anzahl der Spalten und Spalten der Leinwand bestimmt die Anzahl der Quadrate, die die Leinwand*/ public gamecanvas (int rows, in cols) {this.rows = row; this.cols = cols; Boxen = new ersbox [Zeilen] [Cols]; für (int i = 0; i <Boxen.length; i ++) {für (int j = 0; j <Boxen [i] .Length; j ++) {Boxen [i] [j] = new ersbox (false); }} setBorder (neu geätzte Border (geätzte Border.Ard, Color.White, New Color (148, 145, 140)); Dies (Zeilen, cols); GetbackCroundColor () {Rückkehrer; * Die Anzahl der Zeilen des Quadrats in der Leinwand* @return*/ public int getrows () {return rows; } / *** Holen Sie sich die Punkte seit dem letzten Upgrade** @return int, die Punkte nach dem letzten Upgrade* / public int getCoreForLevelupdate () {return ScoreForLevelupdate; } / *** Holen Sie sich die quadratische Referenz einer bestimmten Zeile und einer bestimmten Spalte** @return row int, auf die Zeile, in der das Quadrat verwiesen werden soll Boxen [0] .Length - 1) {return null; 0; Passen Sie automatisch die Größe des Quadrats nach der Fenstergröße an* / public void ordnungsgemäß () {boxwidth = getSIZE (). Breite / cols; row) {für (int i = row; i> 0; i--) {für (int j = 0; j <cols; j ++) {Boxen [i] [j] = (ersbox) Boxen [i-1] [j] .Clone (); ScoreForLevelUpdate+= RusssiablySgame.Per_Level_Score; {Boxen [i] [j] .setColor (false);}} Repaint ();Controlpanel.java
Paket RusssiaBlocksgame; Import Java.awt.BorderLayout; Import Java.awt.Color; importieren java.awt.graphics; importieren java.awt.gridlayout; import Java.awt.event.ActionEvent; import Java.awt.event.ActionListener; importieren java.awt.event.comPonentAdapter; importieren java.awt.event.comPonenteEvent; Import Java.awt.event.KeyAdapter; Import Java.awt.event.KeyEvent; Java.Text.DateFormat importieren; Java.Text.SimpledateFormat importieren; import Java.util.date; import Javax.swing.jbutton; import Javax.swing.jlabel; import Javax.swing.jpanel; importieren javax.swing.jtextfield; import Javax.swing.timer; import javax.swing.border.border; import Javax.swing.border.AdchedBorder; /*** Control Panel -Klasse, von JPanel geerbt. Das Vorschau -Fenster-, Level-, Punkt- und Steuertasten wird darauf platziert. */ class ControlPanel erweitert jpanel {private statische endgültige lange Serialversionuid = 3900659640646175724L; private jTextfield tflevel = new JTextField ("" + RusssiablingSgame.Default_Level), tfscore = new JTextfield ("0"), tftime = new Jtextfield (""); Private Jbutton Btplay = New Jbutton ("Start"), btpause = neuer Jbutton ("pause"), btstop = neuer Jbutton ("Ende des Spiels"), btturnlevelup = new Jbutton ("Erhöhen Sie die Schwierigkeit"), btturnleveldown = new jbutton ("reduzieren den Schwierigkeitsgrad"); Private Jpanel PLTIP = new Jpanel (new BorderLayout ()); private tippanel pltipblock = neuer tippanel (); Private JPanel plinfo = new jpanel (neuer Gridlayout (4, 1)); Private Jpanel Plbutton = New JPanel (New GridLayout (6, 1)); privates Timer -Timer; private Grenzgrenze = neuer geätzter Border (geätztborder. Erhöht, Farbe.White, neue Farbe (148, 145, 140)); /*** Konstruktor der Kontrollpanelklasse** @Param Game Ersblocksgame, eine Instanzreferenz der Ersblocksgame -Klasse ist bequem, um das Verhalten der Ersblocksgame -Klasse direkt zu kontrollieren. */ public Controlpanel (endgültiges RusssiaBlocksgame -Spiel) {setLayout (neuer GridLayout (3, 1, 0, 2)); pltip.add (New Jlabel ("nächster Platz"), BorderLayout.North); // Komponente pltip.add (pltipBlock) hinzufügen; PLTIP.SetBorder (Grenze); plinfo.add (New JLabel ("Schwierigkeitsgradkoeffizient"); plinfo.add (tflevel); plinfo.add (New Jlabel ("Score")); plinfo.add (tfScore); plinfo.setBorder (Grenze); plbutton.add (btplay); btPlay.setEnabled (true); plbutton.add (btpause); btpause.setenabled (false); plbutton.add (btstop); btstop.setenabled (false); Plbutton.add (BtTurnlevelup); Plbutton.add (BtTurnlevelveldown); plbutton.add (tftime); Plbutton.setBorder (Grenze); tflevel.SeTedEtable (falsch); tfScore.Seteditable (false); tftime.setedable (falsch); add (pltip); add (plinfo); add (plbutton); addKeyListener (neuer KeyAdapter () {@Override public void keypression (keyEvent ke) {if (! game.iSpleing ()) {return;} ersblock block = game.getCurblock (); Switch (ke.getKeyCode ()) {case keyEvent.vk_down: block. Block.Moveleft () break; btplay.addactionListener (new ActionListener () {// starten Sie das Game @Override public void actionPerformed (actionEvent ae) {game.playGame ();}}); btpause.addactionListener (new actionLurtener () {// pause das game @Override public void -ActionPerformed (actionEvent ae) {if (btpause.getteText (). Equals ("pause") {game.pauseGame ();} else {game.resumegame (); {}}}});; btstop.addactionListener (new ActionListener () {// Stop das Spiel @Override public void ActionPerformed (actionEvent ae) {game.stopgame ();}}); BtTurnLevelUp.AddactionListener (new ActionListener () {// Schwierigkeitsgrad @Override public void ActionPerformed (actionEvent ae) {try {int Level = Integer.ParseInt (tflevel.getText ()); catch (numberFormatexception e) {} requestFocus (); btTurnLevelDown.addActionListener(new ActionListener() { //Reduce game difficulty @Override public void actionPerformed(ActionEvent ae) { try { int level = Integer.parseInt(tfLevel.getText()); if (level > 1) { tfLevel.setText("" + (level - 1)); } } catch (NumberFormatException e) { } requestFocus (); addComponentListener (new componentAdapter () {@Override public void componentressized (componentEvent ce) {pltipBLOCK.Adjust ();}}); Timer = New Timer (1000, New ActionListener () {@Override public void actionPerformed (actionEvent ae) {DateFormat Format = new SimpleDateFormat ("Zeit: hh: mm: ss"); // Das System erhält Zeitdatum = new Date (); Game.getScore ()); Timer.Start (); } / *** Setzen Sie den Stil des Vor-Display-Fensters** @param style int, entsprechend den 28 Werten in Stilen der Ersblock-Klasse* / public void setipstyle (int style) {pltipblock.setStyle (style); } /*** Holen Sie sich das vom Benutzer festgelegte Spielebene. * * @return int, Schwierigkeitsgrad, 1-eSblocksgame.max_level */ public int getlevel () {int Level = 0; try {Level = integer.parseInt (tFlevel.GeteText ()); } catch (numberFormatexception e) {} Rückgabestufe; } /*** Lassen Sie Benutzer das Spielschwierigkeitsgrad ändern. * * @param Level modifizierte Spielschwierigkeitsgrad */ public void setlevel (int Level) {if (Level> 0 && Level <11) {tflevel.setText ("" + Ebene); }} /*** Stellen Sie den Status der Schaltfläche "Start" fest. */ public void setPlayButtonEnable (boolean enable) {btPlay.setEnabled (enable); } public void setPauseButtonenable (boolean enable) {btpause.setenabled (enable); } public void setPauseButtonLabel (boolesche Pause) {btpause.setText (Pause? "Pause": "Fortsetzung"); } public void setStopbuttonenable (boolean enable) {btstop.setEnabled (enable); } public void setturnlevelUpButtonenable (boolean enable) {BtTurnlevelUp.setenabled (enable); } public void setturnlevelveldownbuttonenable (boolean enable) {BtTurnleveldown.setEnabled (enable); } / *** das Bedienfeld zurücksetzen* / public void reset () {tfScore.setText ("0"); Pltipblock.setStyle (0); } / *** Die Größe der kleinen Box in Kisten [] [] in Tippanel* / public void orpor () {pltipBlock.adjust () neu berechnen; } /*** Implementierungsdetails Klasse des Vor-Display-Fensters* /öffentliche Klasse Tippanel erweitert JPanel {// Tippanel wird verwendet, um die Form des nächsten Blocks anzuzeigen, um private statische endgültige long serialversionuid = 51605553671436997616l zu erscheinen. private farb backcolor = color.darkgray, FrontColor = color.white; private ersbox [] [] Boxen = new ersbox [esblock.boxes_rows] [esblock.boxes_cols]; Privat int -Stil, Boxwidth, BoxHeight; privat boolean ist ideiled = false; / *** Pre-Display-Fensterklasse Konstruktor*/ public tippanel () {für (int i = 0; i <Boxes.length; i ++) {für (int j = 0; j <i] .Length; j ++) {Boxen [i] [j] = new ersbox (false); }}} / *** Setzen Sie den Blockstil des Vor-Display-Fensters** @param style int, entsprechend 28 Werten in Stilen der Ersblock-Klasse* / public void setStyle (int style) {this.style = style; Repaint (); } /*** Überschreiben Sie die Funktionen der JComponent -Klasse und zeichnen Sie Komponenten. * * @param g Graphics Device Umgebung */ @Override public void PaintComponent (Grafik g) {Super.PaintComponent (g); if (! iStiled) {ordnen (); } int key = 0x8000; für (int i = 0; i <Boxes.length; i ++) {für (int j = 0; j <Boxen [i] .Length; j ++) {color color = ((Schlüssel & Stil)! = 0? FrontColor: BackColor); G.SetColor (Farbe); g.fill3Drect (j * boxwidth, i * boxHeight, boxwidth, boxHeight, true); Schlüssel >> = 1; }}} / *** g die Größe des Quadrats automatisch entsprechend der Größe des Fensters* / public void ordnungsgemäß () {boxWidth = getSIZE (). Breite / ersblock.boxes_cols; BoxHeight = getSIZE (). Höhe / ersblock.boxes_rows; ist istiled = true; }}}Ersbox.java
Paket RusssiaBlocksgame; Import Java.awt.Dimension; / *** Die quadratische Klasse ist das grundlegende Element, das den Block ausmacht, und verwendet eine eigene Farbe, um das Erscheinungsbild des Blocks zu repräsentieren. private Dimension Größe = neue Dimension (); / ** * Der Konstruktor der quadratischen Klasse, * * @param iscolor wird die Vordergrundfarbe verwendet, um diese quadratische Vordergrundfarbe zu färben, falsche Verwendung von Hintergrundfarbe */ public ersbox (boolean iscolor) {this.iscolor = iscolor; } / *** wird dieses Quadrat in der Vordergrundfarbe ausgedrückt** @return boolean, das in der Vordergrundfarbe ausgedrückt wird, falsch in der Hintergrundfarbe ausgedrückt* / public boolean iscolorbox () {return iscolor; } / ** * Setzen Sie die Farbe des Quadrats, * * @param iscolor boolean, das in der Vordergrundfarbe ausgedrückt wird, falsch in der Hintergrundfarbe ausgedrückt * / public void setColor (boolean iscolor) {this.iscolor = iscolor; } / *** Erhalten Sie die Größe dieses Quadrats** @return Dimension, die Größe des Quadrats* / öffentliche Dimension getSize () {Return -Größe; } / ** * Setzen Sie die Größe des Quadrats, * * @param Größe Dimension, die Größe des Quadrats * / public void setSize (Dimensiongröße) {this.size = Größe; } / *** Überschreiben Sie den Objekt des Objekts Clone (), klone implementieren** @return Object, Clone -Ergebnis* / @Override öffentliches Objekt Clone () {Object Clone = null; try {clone = super.clone (); } catch (Ausnahme ex) {ex.printstacktrace (); } return clone; }}Ersblock.java
Paket RusssiaBlocksgame; / *** Blockklasse, aus der Thread -Klasse (Thread) geerbt aus 4 × 4 Blöcken (ERSBOX), steuert die Bewegung, Herbst, Verformung des Blocks usw.*/ Klasse Ersblock erweitert Thread {/ *** Die Anzahl der durch einen Block besetzten Zeilen*/ öffentliche endgültige statische intboxes_rows = 4; / *** Die Anzahl der Spalten, die von einem Block besetzt sind, beträgt 4 Spalten*/ Public Final Static Int Boxes_Cols = 4; / *** Der Faktor, der die Upgrade ändert, um die Geschwindigkeitsunterschiede zwischen den letzten Stufen nahezu zu vermeiden*/ öffentliches endgültiges statisches int Level_flatness_gene = 3; / ** * Was ist der Unterschied zwischen den beiden ähnlichen Ebenen des Blocks für jede Zeile (Millisekunden) */ öffentliches endgültiges statisches int zwischen_levels_Degress_time = 50; / ** * Die Anzahl der Blöckenstile beträgt 7 */ öffentliches endgültiges statisches int block_kind_number = 7; / ** * Der Inversion -Status -Typ der Blöcke jedes Stils beträgt 4 */ öffentliches endgültiges statisches int block_status_number = 4; /** * 28 states corresponding to 7 models respectively*/ public final static int[][] STYLES = { //Total 28 states {0x0f00, 0x4444, 0x0f00, 0x4444}, //Four states of long stripes {0x04e0, 0x0464, 0x00e4, 0x04c4}, //Four states of T type {0x4620, 0x6c00, 0x4620, 0x6c00}, //Four states of reverse Z type {0x2640, 0xc600, 0x2640, 0xc600}, //Four states of Z type {0x6220, 0x1700, 0x2230, 0x0740}, //Four states of 7 type {0x6440, 0x0e20, 0x44c0, 0x8e00}, // vier Zustände von Inverse 7 Typ {0x0660, 0x0660, 0x0660, 0x0660}, // vier Zustände von Block}; private Gamecanvas -Leinwand; private ersbox [] [] Boxen = new ersbox [Boxes_Rows] [Boxes_Cols]; Privat int -Stil, Y, X, Level; private boolean pausieren = falsch, bewegend = true; / *** Konstruktor erzeugt einen bestimmten Block** @param stil Der Stil des Blocks, der einem der 28 Werte von Stilen entspricht* @param y Startposition, Koordinatenlinie in der oberen linken Ecke in Canvas* @param x Startposition, Koordinate der Spalte in der oberen linken Ecke in Canvas* @param Level, steuern Sie die fallende Geschwindigkeit, inth Block, Int @Param canvas artboard*/ public iNtrock, intro Block, Int. Level, Gamecanvas canvas) {this.style = style; this.y = y; this.x = x; this.level = Level; this.canvas = canvas; int key = 0x8000; für (int i = 0; i <Boxes.length; i ++) {für (int j = 0; j <Boxen [i] .Length; j ++) {boolean iscolor = ((style & key)! = 0); Boxen [i] [j] = new ersbox (iscolor); Schlüssel >> = 1; } } Anzeige(); } / *** Die Funktion run () der Thread -Klasse deckt den Block ab und lässt den Block fallen, bis der Block nicht wieder fallen kann } catch (InterruptedException dh) {ie.printstacktrace (); } // Die nachfolgende Bewegung bedeutet, dass die Bewegung während der 100 Millisekunden des Wartens nicht geändert wurde, wenn (! Pausieren) {moving = (moveTo (y + 1, x) && bewegt); }}}} / ** * Der Block bewegt ein Raster nach links * / public void moveleft () {moveto (y, x - 1); } / ** * Der Block bewegt ein Raster nach rechts * / public void moveright () {moveTo (y, x + 1); } / ** * Der Block bewegt ein Raster nach rechts * / public void Moveown () {moveTo (y + 1, x); } / *** blockvariante* / public void TurnNext () {für (int i = 0; i <block_kind_number; i ++) {für (int j = 0; j <block_status_number; Turnto (NewStyle); zurückkehren; }}}} public void startMove () {pasieren = false; bewegt = wahr; } / *** Pause den Aufenthaltsort des Blocks, entsprechend der Spielpause* / public void pausemove () {pausing = true; // bewegt = false; } /** * Continue the whereabouts of the block, corresponding to the game continue*/ public void resumeMove() { pausing = false; moving = true; } /** * Stop the whereabouts of the block, corresponding to the game pause*/ public void stopMove() { pausing = false; moving = false; } /** * Remove the current block from the corresponding position of the canvas and will not be reflected until the next time you repaint the canvas*/ private void erase() { for (int i = 0; i < boxes.length; i++) { for (int j = 0; j < boxes[i].length; j++) { if (boxes[i][j].isColorBox()) { ErsBox box = canvas.getBox(i + y, j + x); if (box == null) { continue; } box.setColor(false); } } } } } /** * Let the current block be placed in the corresponding position of the canvas, and you have to wait until the next time you repaint the canvas*/ private void display() { for (int i = 0; i < boxes.length; i++) { for (int j = 0; j < boxes[i].length; j++) { if (boxes[i][j].isColorBox()) { ErsBox box = canvas.getBox(i + y, j + x); if (box == null) { continue; } box.setColor(true); } } } } } /** * Can the current block be moved to the location specified by newRow/newCol* * @param newRow int, the destination line* @param newCol int, destination column * @return boolean, true-can move, false-cannot move*/ public boolean isMoveAble(int newRow, int newCol) { erase(); for (int i = 0; i < boxes.length; i++) { for (int j = 0; j < boxes[i].length; j++) { if (boxes[i][j].isColorBox()) { ErsBox box = canvas.getBox(i + newRow, j + newCol); if (box == null || (box.isColorBox())) { display(); false zurückgeben; } } } } Anzeige(); return true; } /** * Move the current block to the location specified by newRow/newCol* * @param newRow int, destination row* @param newCol int, destination column* @return boolean, true-move successfully, false-move failed*/ private synchronized boolean moveTo(int newRow, int newCol) { if (!isMoveAble(newRow, newCol) || !moving) { return false; } erase(); y = newRow; x = newCol; Anzeige(); canvas.repaint(); return true; } /** * Can the current block become the block style specified by newStyle, mainly considering the boundary and being blocked by other blocks and cannot be moved* * @param newSytle int, the block style you want to change corresponds to one of the 28 values of STYLES* @return boolean, true-can change, false-cannot change*/ private boolean isTurnAble(int newStyle) { int key = 0x8000; löschen(); for (int i = 0; i < boxes.length; i++) { for (int j = 0; j < boxes[i].length; j++) { if ((newStyle & key) != 0) { ErsBox box = canvas.getBox(i + y, j + x); if (box == null || (box.isColorBox())) { display(); false zurückgeben; } } key >>= 1; } } Anzeige(); return true; } /** * Turn the current block into the block style specified by newStyle* * @param newStyle int, the block style you want to change, corresponding to one of the 28 values of STYLES* @return true-change succeeds, false-change fails*/ private boolean turnTo(int newStyle) { if (!isTurnAble(newStyle) || !moving) { return false; } erase(); int key = 0x8000; for (int i = 0; i < boxes.length; i++) { for (int j = 0; j < boxes[i].length; j++) { boolean isColor = ((newStyle & key) != 0); boxes[i][j].setColor(isColor); key >>= 1; } } style = newStyle; Anzeige(); canvas.repaint(); return true; }}Main.java
package RussiaBlocksGame; /** * Program entry function* * @param args String[], accompanied by command line parameters*/ public class Main { public static void main(String[] args) { new RussiaBlocksGame("Tetris: Yang Yujie"); }} Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.