Design und Implementierung des Tetris-Spiels auf Java-Basis
Tetris ist ein weltweit beliebtes Spiel und war von Anfang an auf Computern, Mobiltelefonen und Handheld-Spielekonsolen beliebt. Es ist ein einfaches klassisches Spiel mit einfachen Spielregeln, aber es mangelt ihm nicht an Spaß. Das ist es leicht zu erlernen und anwendbar. Der Anwendungsbereich ist breit und bekannt. Die einfachen Grundregeln des Tetris-Spiels bestehen darin, dass 7 verschiedene regelmäßige Grafiken, die aus kleinen Quadraten bestehen, nacheinander vom Bildschirm fallen. Der Spieler bewegt sich so, dass ein vollständiger horizontaler Balken entsteht, wenn dieser fällt, und verschwindet dann. Der Spieler erhält Punkte und das Spiel Das Level steigt. Das Spiel endet, wenn sich die verbleibenden Grafiken bis zum oberen Bildschirmrand ansammeln.
Tetris war ursprünglich ein Gelegenheitsspiel, das 1984 vom Russen Alexei Pajitnov entwickelt wurde. Es schuf einst einen beispiellosen kommerziellen Wert und beeinflusste die Entwicklung und Industriekette einer Generation von Gelegenheitsspielen. Mit der kontinuierlichen Entwicklung und den Veränderungen des Informationszeitalters sowie von Wissenschaft und Technologie sind Computer im Leben eines jeden populär geworden. Im geschäftigen Arbeitsleben bringt diese Art von Gelegenheitsspielen etwas Entspannung für die Menschen.
Dieser Artikel beschreibt und analysiert detailliert die Grundideen und einige grundlegende Spielregeln der klassischen traditionellen Tetris-Implementierung. Auf dieser Grundlage wird das innovative und kreative Modell von Tetris weiterentwickelt und ein Begleitspiel basierend auf dem klassischen Spiel entwickelt. Als Partitur Mit zunehmendem Level steigt auch der Schwierigkeitsgrad. Module, die den Farbwechsel von Blöcken steuern können, wurden kreativ entwickelt und Spielsound- und Musikmodule hinzugefügt. Dieses Dokument enthält einen spezifischen Implementierungsprozess, eine detaillierte Beschreibung und einige Quellcodes für die oben genannten Funktionen.
In diesem Artikel werden die Entwicklung und Entwicklungsgeschichte des Tetris-Spiels, die Bedeutung der Entwicklung dieses Spiels, die Entwicklungsumgebung und die relevanten Kenntnisse der Softwareentwicklung und Java-Programmierung basierend auf Software-Engineering sowie die Anforderungsanalyse und das Entwurfsdesign des Programms erläutert. Detailliertes Design und Implementierung sowie Debugging. Für den Betrieb wird eine Reihe von Beschreibungen gegeben.
Dieses Programmdesign basiert auf dem Microsoft Windows 7-System, wobei Java als Entwicklungssprache verwendet wird, und das Spieldesign und die Implementierung auf der Eclipse-Entwicklungsplattform.
Schlüsselwörter: Spieledesign; Tetris; Softwareentwicklung; Java; Eclipse.
Inhaltsverzeichnis
Design und Implementierung des Tetris-Spiels auf Basis von Java ........................ I
Zusammenfassung................................................. ..................... ICH
Basierend auf dem Design und der Implementierung des Java-Spiels Tetris ........ II
Abstrakt ................................................. ................. II
1. Einleitung................................................ .................... 1
1.1 Hintergrund und Bedeutung der Programmentwicklung................................. ..... 1
1.3 Aktueller Forschungsstand des Tetris-Spiels................................. 2
1.3.2 Literaturrecherche................................................ ... ........ 3
2Verwandte Technologien................................................ .............4
2.1 Einführung in JAVA................................................ .. ............ 4
2.2 Einführung in Swing-Komponenten................................................ ... ....... 4
2.4 Systemplattformumgebung : ............................................ ..... ........ 6
2.4.1 Hardwareplattform:................................................ .... ...... 6
2.4.2 Softwareplattform:................................................ .... ...... 6
3 Systemanalyse................................................. . ........................ 7
3.1 Machbarkeitsanalyse................................................ . ........... 7
3.1.1 Wirtschaftliche Machbarkeitsanalyse .................... .... 8
3.1.2 Technische Machbarkeitsanalyse............................................ .... .... 8
3.1.3 Soziale Machbarkeitsanalyse............................................ .... .... 8
3.2 Anforderungsanalyse................................................ . ............ 8
3.2.1 Funktionale Anforderungen........................................ ..... .. 9
3.2.2 Nichtfunktionale Anforderungen........................................ ... ... 9
3.2.3 Schnittstellensteuerung................................................ ... ....... 9
4 Prinzipieller Aufbau des Systems...................................... ...... ...... 11
4.1.1 Grundablauf der manuellen Geschäftsabwicklung................................. 11
4.1.2 Funktionsmodule des Basisprozesses................................ 12
5 Detaillierter Entwurf und Implementierung des Systems................................. .. ..... 15
5.1 Hauptschnittstellen-Anzeigemodul des Spiels ................................... ... 15
5.2 Canvas- und Box-Anzeigemodul................................. ... 16
5.2.1 Design des Hintergrund-Canvas-Moduls............................................. ..... 16
5.2.2 Vorschau des Blockmoduldesigns............................................. ..... 19
5.2.3 Aufbau des Blockbewegungs- und Rotationsmoduls................................. 21
5.3 Bedienfeldmodul................................................ .. ........ 25
5.3.1 Design des Menüleistenmoduls............................................ ..... .. 25
5.3.2 Design der Bedienfeldtasten............................................. ..... 26
6 Systemtestbetrieb................................................ ...... ......29
6.1 Testübersicht................................................. . ........ 29
6.1.1 Prüfgrundsätze................................................ ... ...... 29
6.1.2 Testmethode................................................ ... ...... 30
6.1.3 Testbedeutung und Vorsichtsmaßnahmen........................ 31
6.2 Testen von Spielcodes und Algorithmen................................. ... 31
6.3 Funktionstest der Menüoptionen in der Spieloberfläche......................... 32
6.4 Funktionstest der Schlüsselereignisse................................ .... 34
6.5 Block-Stacking- und Eliminierungsfunktionstest................................. 35
6.6 Testergebnisse................................................ . ........... 35
abschließend................................................ . ............. 36
Verweise................................................ . ................. 38
Danksagungen................................................ ...... ......................... 39
Anhang A Fremdsprachiger Originaltext........................................ ..... ........40
Die Psychologie von Tetris................................................ 40
Anhang B Fremdsprachenübersetzung................................................ ..... ........43
Die psychologischen Auswirkungen von Tetris........................................ ..... 43
1. Einleitung
Die Einleitung beschreibt kurz den Hintergrund der Programmentwicklung, die Entwicklungsbedeutung, die erforderliche Entwicklungstechnologie und den aktuellen Forschungsstand des Tetris-Spiels im In- und Ausland.
1.1 Hintergrund und Bedeutung der Programmentwicklung
Das Tetris-Spiel ist auf der ganzen Welt ein beliebtes und dauerhaftes Spiel. Es ist ein Gelegenheitsspiel, das auf einer Reihe von Produkten wie Computern, Mobiltelefonen, TV-Spielekonsolen, Handheld-Spielekonsolen usw. gespielt werden kann. Es hat fast alles geschaffen ist eine beispiellose Sensation und ein unzähliger kommerzieller Wert für jedes Spiel. Es ist ein wichtiges Ereignis in der Geschichte der Spiele- und Softwareentwicklung.
Eines Tages im Juni 1984 wurde Alex Pajitnov, ein Mathematiker in Moskau, Russland, plötzlich dazu inspiriert, dieses Spiel zu entwerfen, nachdem er im Moskauer Wissenschaftlichen Computerzentrum, wo er arbeitete, ein Puzzle gespielt hatte. Zunächst entwickelte er es nur auf Electronica 60 ( ein Computer), und später wurde es über Vadim Gerasimov auf den PC portiert und in der Moskauer Computer-Community weit verbreitet. Tetris begann populär zu werden und wurde zum meistverkauften klassischen Gelegenheitsspiel der Geschichte, es behält immer noch seinen Charme als stets. Die einfachen Grundspielregeln von Tetris basieren auf einem standardmäßigen virtuellen Spielfeld zum Platzieren kleiner Quadrate. Die Grundeinheit ist ein kleines Quadrat; es besteht aus vier kleinen Quadraten und 7 verschiedenen regelmäßigen Grafiken (Feldform, Z-Form, umgekehrte Z-Form, 7-förmig, umgekehrt (7-förmig, T-förmig, langer Balken) Es gibt insgesamt 28 grafische Schemata, um den Block um 90 Grad, 180 Grad, 270 Grad, 360 Grad zu drehen, indem der Spieler die obere Taste, links und rechts betätigt Rechts- und Abwärtstaste. Um die Position durch Beschleunigen des Fallens anzupassen, werden die Blöcke am unteren Bildschirmrand zu einem oder mehreren vollständigen Blöcken geformt und dann entfernt, um Platz für die neu fallenden Blöcke zu schaffen. Jedes Mal ein vollständiger Wird der horizontale Balken eliminiert, erhöht sich das Level des Spielers um ein Level. Wenn das Level ein bestimmtes Level erreicht, beschleunigt sich mit der Zeit die Fallgeschwindigkeit. Sobald die Blöcke, die nicht eliminiert wurden, den oberen Bildschirmrand erreichen, endet das Spiel.
Mit der kontinuierlichen Aktualisierung und Weiterentwicklung der Computertechnologie werden bei Tetris-Spielen ständig verschiedene Modi eingeführt, und es gibt viele verschiedene Versionen, die jeder spielen kann, da das Spiel selbst einfach oder komplex sein kann und die Spieler gut trainieren kann. Seine mentale Reaktionsfähigkeit Und die Fähigkeit zum logischen Denken kann den Spielern auch endlosen Spielspaß bescheren, weshalb es bei der Mehrheit der Spieler sehr beliebt ist. Wenn es um die Entwicklung von Spielesoftware geht, empfinden die meisten Menschen dies als unerreichbar und magisch. Mit der kontinuierlichen Innovation von Entwicklungsmethoden und -tools ist es nicht unerreichbar, einige kleine Spiele selbst zu entwickeln. Das Tetris-Spiel hat einen beispiellosen Status in der Geschichte der Spiele. Die Spieloberfläche ist einfach und der Code ist nicht sehr kompliziert. Es gibt auch viele Algorithmen und Designs für die Implementierung des Tetris-Spiels im Internet, und die Schwierigkeit ist nicht besonders hoch.
Tetris ist ein einfaches Puzzlespiel. Mit seiner einzigartigen und prägnanten Benutzeroberfläche und dem äußerst unterhaltsamen Spielmodus sind viele Spielebegeisterte tief in das Spiel vertieft und können sich nicht davon befreien. Es ist für alle Altersgruppen geeignet. Im heutigen schnelllebigen Leben steigt auch der Druck des Lernens und Arbeitens auf Studierende und Arbeitsgruppen. Die Aufgaben aller werden immer schwerer und es gibt immer weniger freie Zeit zum Ausruhen, wodurch die Menschen immer dringender etwas Einfaches brauchen. A Zeitsparendes Gelegenheitsspiel, das jeder genießen kann. Es besteht kein Zweifel, dass Tetris ein einfaches Puzzle und ein interessantes Gelegenheitsspiel ist und auf eine Reihe tragbarer Geräte wie Computer, Mobiltelefone, Tablets, TV-Spielekonsolen, Handheld-Spielekonsolen, elektronische Wörterbücher, MP4 und andere tragbare Geräte übertragen werden kann Geräte. Dieses Forschungsprojekt ist sowohl hinsichtlich der technischen Entwicklung als auch der gesellschaftlichen Bedeutung sehr wertvoll. Es ist ein mutiger Versuch meinerseits, Spiele zu entwickeln.
1.2 Überblick über die Entwicklungstechnologie
Software Engineering ist eine Disziplin, die den Einsatz technischer Methoden zur Erstellung und Wartung effektiver, praktischer und qualitativ hochwertiger Software untersucht; Design umfasst Programmiersprachen, Datenbanken, Algorithmen, Softwareentwicklungstools, Systemplattformen, Designmuster und viele andere Aspekte; in In In der modernen Gesellschaft wird Software in vielen typischen Bereichen wie E-Mail, eingebetteten Systemen, Mensch-Computer-Interaktionsschnittstellen, Office-Suiten, Betriebssystemen, Editoren, Datenbanken, Spielen usw. verwendet; gleichzeitig in verschiedenen Branchen der heutigen Gesellschaft sind Computersoftwareanwendungen, einschließlich Industrie, Landwirtschaft, Bankwesen, Luftfahrt, Regierungsbehörden usw., die die wirtschaftliche und soziale Entwicklung wirksam fördern und die Arbeits- und Lebenseffizienz der Menschen verbessern können.
Der Entwicklungscode für Tetris-Spiele ist relativ nicht besonders komplex. Dieser Artikel basiert auf der Programmiersprache Java und verwendet Swing-Komponenten, die häufig in der Java-Sprache verwendet werden. Swing ist ein Toolkit für die grafische Benutzeroberfläche (GUI) in Java. Es ist Teil der Java-Basisklasse. Es umfasst Textfelder, getrennte Bereiche, Schaltflächen, Tabellen und andere GUI-Geräte. Es ist in reinem Java geschrieben. Entwickler können eine kleine Version verwenden Dank der großen Menge an Code können die verschiedenen flexiblen und umfangreichen Funktionen und modularen Komponenten von Swing geschrieben werden, um schöne und elegante Benutzeroberflächen zu erstellen. Die Java Swing-Komponente umfasst die folgenden häufig verwendeten Klassen: JFrame ist ein grafisches Objekt auf dem Bildschirm, das grundlegende Vorgänge wie Maximieren, Minimieren und Schließen ausführen kann. Dies ist die Grundidee der Java-GUI-Programmierung; JPanel kann verwendet werden zum Verschachteln. Komponenten mit denselben logischen Funktionen im Formular können kombiniert und zum JFrame-Formular hinzugefügt werden. Es handelt sich um eine Panel-Container-Klasse in Swing. Das JLabel-Objekt wird zum Anzeigen von Text, Bildern oder beidem verwendet und kann einige seiner Eigenschaften festlegen; JTextField ist eine laufende Komponente, die zum Bearbeiten einer einzelnen Textzeile verwendet wird; JButton ist eine Klasse, die zum Erstellen von Schaltflächen verwendet wird. Darüber hinaus enthält die Swing-Komponente in Java auch viele Funktionsklassen, mit denen sich auf einfache Weise einige schöne grafische Oberflächen erstellen lassen.
1.3 Forschungsstand des Tetris-Spiels
1.3.1 Forschungsstatus im In- und Ausland
Seit Beginn des 21. Jahrhunderts haben sich Computer weiterentwickelt, und auch die E-Sport-Branche befindet sich weiterhin in einem aufstrebenden Stadium. Die Entwicklung von Spielesoftware erfreut sich immer größerer Beliebtheit. Spielesoftware, wie Dramen und Filme, ist es auch eine neue Art von Technologie, die immer beliebter wird. Umfassendes Kunstprodukt. Anders als bei der allgemeinen Webentwicklung und Softwareentwicklung erfordert die Entwicklung von Computerspielsoftware nicht nur die Beherrschung professioneller Programmierkenntnisse und Softwareentwicklungsmethoden durch Designer und Entwickler, sondern erfordert auch professionelle Kenntnisse im Spielebereich und professionelle Kenntnisse in der Spieleentwicklung, um effektiv zu sein . Entwickeln und implementieren Sie die lebendige Benutzeroberfläche des Spiels, die Verarbeitung von Soundeffekten und erreichen Sie eine perfekte Interaktion mit Spielern usw.
Das Spiel „Tetris“ wurde ursprünglich vom ehemaligen sowjetischen Wissenschaftler Alex Pajitnov als Lernsoftware entwickelt und dann an verschiedene Spielefirmen lizenziert. Seitdem ist es auf allen wichtigen Plattformen verfügbar. Es erschienen verschiedene Versionen des Spiels.
Die Game Boy- Version von Tetris wurde in Japan 4,24 Millionen Mal verkauft und ist damit das beliebteste Spiel in der Geschichte der Game Boy-Spiele. Während des Golfkrieges wurde das Spiel Tetris zu einem der am besten geeigneten Zeitkillerspiele für amerikanische Truppen an der Front.
Die Grundprinzipien von Tetris sind für die meisten Programmierer relativ einfach und Tetris ist mathematisch, dynamisch und bekannt. Es wird auch oft als Übungsfach für die Spieleprogrammierung verwendet.
1.3.2 Literaturübersicht
Die Dokumente [1] und [2] zielen auf eine nullbasierte Erklärung ab und verwenden Beispiele, um den Leser zum vertieften Lernen zu führen. Dabei wird der Erklärungsmodus von Grundwissen → Kerntechnologie → fortgeschrittene Anwendung → tatsächliche Projektpraxis verwendet, um verschiedene Java-Technologien und -Praktiken zu erläutern einfache und leicht verständliche Begriffe. Geschicklichkeit. Aus der Perspektive von Anfängern werden durch eine leicht verständliche Sprache und farbenfrohe Beispiele detailliert alle Aspekte der Technologie vorgestellt, die bei der Programmentwicklung mithilfe der Java-Sprache beherrscht werden sollten. Einschließlich: Vertrautheit mit Eclipse-Entwicklungstools, Java-Sprachgrundlagen, Klassen und Objekten, Paketierungsklassen, Zahlenverarbeitungsklassen, Schnittstellen, Vererbung und Polymorphismus, erweiterten Funktionen von Klassen, Ausnahmebehandlung, Swing-Programmierung, Sammlungsklassen, E/A-Eingabe und -Ausgabe, Reflexion, Aufzählungstypen und Generika, Multithreading, Netzwerkkommunikation, Datenbankoperationen, Swing-Tabellenkomponenten, Swing-Baumkomponenten, andere erweiterte Swing-Komponenten, erweiterte Layout-Manager, erweiterte Ereignisbehandlung, AWT-Zeichnung und Audiowiedergabe usw. Diese beiden Dokumente decken „ausreichende“ Java-Sprachen und -Technologien mit umfangreichen Beispielen und detaillierten Inhalten ab. Für Anfänger und Studenten mit einer bestimmten Java-Grundlage können sie die Entwicklungstechnologie und -fähigkeiten der Studenten schnell verbessern. Bei der Gestaltung dieses Projekts wurden die Inhalte in Bezug auf grafisches Schnittstellendesign, Benutzeroberflächenkomponenten und -design, Ereignisverarbeitung und Fensterkonstruktionskomponenten sowie die Grundkenntnisse von Swing und seiner Komponentenreihe auf diese beiden Dokumente verwiesen Hat mir viel Inspiration gegeben. Hilfe.
Dokument [3] erläutert hauptsächlich 2D-Zeichnung, Spielanimationsproduktion, Netzwerkprogrammgrundlage, verbesserte Spielschnittstelle, künstliche Intelligenz und 2,5D-Spiele, Minensuchboot, Labyrinth, Tetris und andere Spielbeispiele, Kollision, Partikelsystem, dreidimensionale 5D-Koordinaten und andere Zeichenalgorithmen; Produktion von Multiplayer-Onlinespielen. Es wird eine Reihe von Algorithmusformeln gesammelt, damit die Leser sie bequemer verwenden können. In einem Schritt-für-Schritt-Ansatz wird der Spieldesignprozess schrittweise analysiert, um den Leser zur Lösung von Problemen zu führen, die in der Spieleentwicklungsphase auftreten können, und um praktische Erfahrungen in der Java-Spieleproduktion zusammenzufassen. Die Prinzipien von Spielen, Animationsimplementierung, Verarbeitung von Soundeffekten, Verarbeitung von Maus- und Tastaturereignissen, künstliche Intelligenz und andere Kenntnisse bei der Gestaltung dieses Kurses beziehen sich alle auf dieses Dokument.
Die Literatur [4] diskutiert das Programmprinzip und die Implementierungstechnologie des klassischen Computerspiels Tetris und beschreibt die funktionalen Anforderungen, die Datenstruktur, die Grafikrotation, die Koordinatentransformation und andere Schlüsseltechnologien des Programms aus Sicht der Softwareentwicklung. Durch dieses Dokument habe ich mehr über das Berufsfeld der Tetris-Spieleentwicklung erfahren.
Dokument [5] ist ein Buch für Fortgeschrittene, das sich mehr auf die Erläuterung der Verwendung von Java zum Denken und Lösen von Problemen konzentriert. Dieses Dokument hat mir während der Kursgestaltung sehr geholfen, Ideen und Techniken für die Java-Programmierung zu entwickeln.
2Verwandte Technologien
2.1 Einführung in JAVA
Java ist der allgemeine Name für die objektorientierte Programmiersprache Java und die von Sun Microsystems eingeführte Java-Plattform. Es handelt sich um eine objektorientierte Programmiersprache , die plattformübergreifende Anwendungssoftware schreiben kann . Die Java-Technologie zeichnet sich durch gute Vielseitigkeit, Effizienz, Plattformübergreifendheit und Sicherheit aus. Sie wird häufig in PCs, Rechenzentren, Spielekonsolen, wissenschaftlichen Supercomputern, Mobiltelefonen und im Internet eingesetzt. Außerdem verfügt sie über die weltweit größte professionelle Entwicklergemeinschaft.
In den letzten zwanzig Jahren hat sich die Java- Sprache zu einer der einflussreichsten Programmiersprachen in der Geschichte menschlicher Computer entwickelt. Teilweise hat sie sogar den Rahmen einer Programmiersprache überschritten und ist zu einer Entwicklungsplattform und einem geworden Entwicklungsplattform. Kanonischer Modus. Mehr noch: Java ist zu einer Art Glauben geworden. Open Source, Freiheit und andere von der Java-Sprache propagierte Geister haben unzählige herausragende Programmierer auf der ganzen Welt angezogen. Tatsächlich gab es seit der Aufzeichnung der Menschheitsgeschichte noch nie eine Programmiersprache, die so viele herausragende Programmierer anlocken konnte, und keine Programmiersprache kann so viele Open-Source-Frameworks ableiten.
Die Java-Sprache ist eine sehr reine objektorientierte Programmiersprache. Sie nutzt die verschiedenen Vorteile der C-Sprache und der C++-Sprache und verzichtet auf schwer verständliche Konzepte wie Mehrfachvererbung und Zeiger in der C++-Sprache. Daher ist die Die Java-Sprache ist leistungsstark und Einfachheit und Benutzerfreundlichkeit sind zwei sehr gute Eigenschaften. Als Vertreter der statischen objektorientierten Programmiersprachen verkörpert die Java-Sprache hervorragend die objektorientierte Theorie und ermöglicht es Programmierern, komplexere Programmierentwicklungen in einer eleganteren Denkweise durchzuführen.
Darüber hinaus enthalten die relevanten Java-EE-Spezifikationen in der Java-Sprache die heute gängigsten Software-Engineering-Konzepte, und verschiedene fortschrittliche Designideen können in den Java-EE-Spezifikationen, -Plattformen und zugehörigen Frameworks implementiert werden. Prinzip. Bis zu einem gewissen Grad ist das Erlernen der Beherrschung verschiedener Aspekte der Java-Sprachkenntnisse gleichbedeutend mit dem systematischen Erlernen relevanter Kenntnisse der Softwareentwicklung und nicht nur dem Erlernen einer Programmiersprache.
Heutzutage wurden die meisten Bank-, Telekommunikations-, Wertpapier-, E-Commerce-, E-Government- und anderen Systeme entweder auf der Java EE-Plattform erstellt oder werden schrittweise auf die Java EE-Plattform umgestellt. Die Java EE-Spezifikation ist derzeit die ausgereifteste ist auch die am weitesten verbreitete Spezifikation für die Anwendungsentwicklung auf Unternehmensebene.
2.2Einführung in Swing-Komponenten
Swing API ist ein erweiterbarer Satz von GUI-Komponenten zum Erstellen von JAVA-basierten Front-End-/GUI-Anwendungen. Es baut auf der AWT-API auf und dient als Ersatz für die AWT-API, da fast jedes darin enthaltene Steuerelement einem AWT-Steuerelement entspricht. Swing-Komponenten folgen der Model-View-Controller-Architektur, um die folgenden Richtlinien zu erfüllen. Eine einzige API reicht aus, um mehrere Erscheinungsbilder und Stile zu unterstützen. Die API ist modellgesteuert, sodass die API auf der höchsten Ebene keine Daten haben muss. Die API verwendet das Java-Bean-Muster, sodass Builder-Tools und IDEs bessere Ergebnisse liefern können Dienstleistungen für Entwickler, um es zu nutzen.
Die Swing-API- Architektur folgt auf folgende Weise einer lose basierten MVC-Architektur. Das Modell repräsentiert die Daten der Komponente. Eine Ansicht stellt eine visuelle Darstellung der Daten einer Komponente dar. Der Controller akzeptiert Benutzereingaben in der Ansicht und spiegelt die Änderungen in den Daten der Komponente wider. Swing-Komponenten behandeln das Modell als separates Element und kombinieren Ansichts- und Controller-Teile zu Benutzeroberflächenelementen. Mit diesem Ansatz verfügt Swing über eine steckbare Look-and-Feel-Architektur. Die Hauptmerkmale von Swing sind:
Leichtgewichtig – Swing-Komponenten sind unabhängig von der nativen Betriebssystem-API, da Swing-API-Steuerelemente normalerweise mit reinem JAVA-Code gerendert werden und nicht mit zugrunde liegenden Betriebssystemaufrufen.
Umfangreiche Steuerelemente – Swing bietet einen umfangreichen Satz erweiterter Steuerelemente, z. B. Bäume, Registerkartenformulare, Schieberegler, Farbwähler und Tabellensteuerelemente.
Erweiterte Anpassung – Swing-Steuerelemente können auf sehr einfache Weise angepasst werden, da das visuelle Erscheinungsbild unabhängig von der internen Darstellung ist.
Pluggable Look and Feel – Das Look and Feel einer Swing-basierten GUI-Anwendung kann zur Laufzeit basierend auf gültigen Werten geändert werden.
2.3 Einführung in die Eclipse-Entwicklungsplattform
Eclipse ist eine erweiterbare Open-Source-Entwicklungsplattform auf Java-Basis, deren Schwerpunkt auf der Bereitstellung einer Industrieplattform mit vollem Funktionsumfang und kommerzieller Qualität für die hochintegrierte Werkzeugentwicklung liegt. Eclipse ist lediglich ein Framework und eine Reihe von Diensten zum Erstellen von Entwicklungsumgebungen durch Plug-in-Komponenten. Eclipse wird mit einem Standardsatz an Plug-Ins geliefert, einschließlich Java Development Tools (JDT).
Eclipse startete im April 1999. Es wurde ursprünglich von IBM als IDE-Entwicklungsumgebung der nächsten Generation entwickelt, um die kommerzielle Software Visual Age für Java zu ersetzen. IBM stellte im November 2001 die erste Eclipse-Codebasis, einschließlich Plattform, JDT und PDE, bereit. Beitrag Laut der Open-Source-Community, die derzeit von IBM geleitet wird, hat sich das Eclipse-Projekt zu einer riesigen Eclipse-Allianz entwickelt, an der mehr als 150 Softwareunternehmen beteiligt sind, darunter Borland, Rational Software, Red Hat und Sybase usw. und ist Jetzt wird es von der Eclipse Foundation geleitet, einer gemeinnützigen Allianz von Softwareanbietern. Im Jahr 2003 wählte Eclipse 3.0 die OSGi-Serviceplattformspezifikation als Laufzeitarchitektur. Im Juni 2007 wurde die stabile Version 3.3 veröffentlicht. Version 3.4 mit dem Codenamen Ganymed wurde im Juni 2008 veröffentlicht.
Eclipse ist eine bekannte plattformübergreifende kostenlose integrierte Entwicklungsumgebung (IDE), die ursprünglich hauptsächlich für die Java-Sprachentwicklung verwendet wurde, aber derzeit verwenden einige Leute Plug-Ins, um sie als Entwicklungstool für andere Computersprachen zu verwenden, z C++ und Python. Eclipse war ursprünglich nur eine Framework-Plattform, die eine Plug-in-Entwicklungsumgebung (Plug-in Development Environment, PDE) bereitstellte. Diese Komponente richtet sich hauptsächlich an Softwareentwickler, die Eclipse erweitern möchten, um die Erstellung von Tools zu ermöglichen, die nahtlos in die integriert sind Eclipse-Umgebung. Die Unterstützung vieler Plug-Ins macht Eclipse zu einer Flexibilität, die andere IDE-Software mit relativ festen Funktionen nur schwer erreichen kann. Da alles in Eclipse ein Plug-In ist, bietet die Bereitstellung von Plug-Ins für Eclipse den Benutzern eine konsistente und einheitliche integrierte Entwicklungsumgebung, sodass alle Tool-Entwickler den gleichen Spielraum haben.
Vorteile von Eclipse:
Derzeit nutzen Millionen von Menschen auf der ganzen Welt Eclipse für die Entwicklung. Warum hat Eclipse so viele Fans? Dies hat viel damit zu tun, dass Eclipse viele Funktionen in einem integriert.
Eclipse ist Open-Source-Software. Das bedeutet, dass die Nutzung von Eclipse nicht nur kostenlos ist, Sie können durch das Studium des Quellcodes auch die Programmiertechniken der weltbesten Entwickler erlernen und öffentliche Open-Source-Codebibliotheken teilen, die von Entwicklern auf der ganzen Welt bereitgestellt wurden.
Eclipse ist wirklich erweiterbar und konfigurierbar. Eclipse nutzt einen Steckmechanismus, der einer Vase ähnelt. Sie können jederzeit Blumen in die Vase hinzufügen, aber auch Blumen, die Sie nicht mehr benötigen, einfach herausnehmen. Derzeit blühen kostenlose und kostenpflichtige Plug-Ins im gesamten Internet, und auch im In- und Ausland ist die Plug-In-Entwicklungsarbeit in vollem Gange.
Eclipse unterstützt viele Entwicklungssprachen, nicht nur Java. Eclipse stellt Entwicklern nur einen minimalen Kern zur Verfügung, der Systemfunktionen erweitern kann. Die auf Erweiterungspunkten basierende Plug-in-Architektur ermöglicht es Eclipse, mehrere Sprachen zu unterstützen. Solange das Plug-in für die entsprechende Sprache installiert ist, kann Eclipse die Entwicklung dieser Sprache unterstützen. Derzeit unterstützt Eclipse C/C++, COBOL, PHP, Perl, Python und andere Sprachen. (Obwohl Eclipse in erster Linie eine Java-Entwicklungsumgebung ist, gewährleistet seine Architektur die Unterstützung anderer Programmiersprachen.)
Eclipse bietet Unterstützung für mehrere Plattformfunktionen. Entwickler können die Plattform verwenden, mit der sie sich am wohlsten fühlen und mit der sie am besten vertraut sind, z. B. Windows, Linux, MacOS usw. Eclipse verfügt für jede Plattform über ein eigenes separates Grafik-Toolkit, das Anwendungen ein nahezu natives Betriebssystem-Erscheinungsbild und eine bessere Leistung verleiht.
Basierend auf der branchenführenden OSGi-Spezifikation. Die OSGi-Spezifikation wurde erstmals 1999 von Sun Microsystems, IBM, Ericsson usw. eingeführt. Zu ihren Serviceplattformen gehören: Service-Gateways, Automobile, Mobiltelefone, Industrieautomation, Gebäudeautomation, PDA-Grid-Computing, Unterhaltung (wie iPronto) und IDE , usw. OSGi-basierte Systeme laufen in Form von Mikrokerneln, sodass sie problemlos Hot-Swap-fähige, sich dynamisch ändernde Verhaltens-, stabile und effiziente Systeme realisieren können, von denen die Softwareindustrie träumt. Ab 3.1 hat Eclipse sein ursprüngliches, von der Industrie anerkanntes Framework entschieden aufgegeben und OSGi als Architektur übernommen. Ab Eclipse3.2 bietet Eclipse Unterstützung für die OSGi-basierte Entwicklung und Entwickler können damit OSGi-basierte Systeme entwickeln.
Die schöne Mensch-Maschine-Schnittstelle von Eclipse wurde weithin gelobt. Eclipse bietet eine neue SWT/JFace-API (anstelle von AWT/Swing), die den eintönigen und langweiligen Schnittstellenstil von SWT/Swing ändert und es ermöglicht, lokal basierte Anwendungen mit umfangreichen grafischen Schnittstellen zu entwickeln, genau wie eine Frühlingsbrise, die hereinweht Der Bereich der Java-Desktop-Entwicklung vermittelt den Menschen ein erfrischendes Gefühl.
Eclipse wird von Branchenführern eingeführt und verfügt über eine starke Branchenmacht. Die Eclipse Foundation hat eine große Anzahl akademischer Forschungseinrichtungen und kommerzieller Organisationen integriert, um die langfristige Planung und Entwicklung von Eclipse zu leiten und sicherzustellen, dass Eclipse eine führende Position in der Software-Tool-Branche einnimmt.
2.4 Systemplattformumgebung :
2.4.1 Hardwareplattform:
Die von diesem Programm entwickelte Computerhardware ist wie folgt:
Festplatte: 500G
CPU: Intel (R) Core (TM) i5 – 3230M CPU bei 2,60 GHz
Interaktive Tools: Tastatur, Maus
Anzeige: LCD-Anzeige
2.4.2 Softwareplattform:
Die Entwicklungsumgebung dieses Systems ist wie folgt
Betriebssystem: Microsoft Windows 7 Ultumate
JDK-Version: jdk-8u121-windows-x64
Eclipse-Version: Neon.2 Release (4.6.2), Eclipse-inst-win64
3 Systemanalyse
Die Systemanalyse ist der erste Schritt, den wir im Softwareentwicklungsprozess unternehmen, einschließlich der Analyse der Systemanforderungen und der Machbarkeitsanalyse. Die Analyse der Systemanforderungen wird hauptsächlich verwendet, um zu erklären, was das System ist und wofür es verwendet werden muss, und um einen Konsens zwischen Entwicklern und Hauptbenutzern zu diesem Thema zu erzielen. Die Machbarkeitsanalyse des Systems besteht hauptsächlich darin, die Implementierung aller Ressourcen des Systems zu analysieren, die Rationalität, Durchführbarkeit und Unvermeidlichkeit der Entwicklung und Investition des Systems zu erklären und unvorhergesehene Probleme zu rationalisieren, die auftreten können. Analyse. Das anspruchsvollste Glied in der Softwareentwicklung ist die Systembedarfsanalyse. Die für die Bedarfsanalyse aufgewendete Zeit ist zweifellos sehr wertvoll. Wenn sich die Nachfrage häufig ändert, führt dies zu Problemen bei der Durchführung der Softwareentwicklungsaufgaben innerhalb des geplanten Plans. Sehr schwerwiegende nachteilige Auswirkungen. Eine gute Analyse der Systemanforderungen und Machbarkeitsanalyse trägt dazu bei, den Softwareentwicklungsprozess komfortabler zu gestalten, eine Echtzeitüberwachung und -verwaltung des Softwareentwicklungsprozesses zu ermöglichen und es einfacher zu machen, wie geplant fortzufahren und so das Ziel der Verbesserung zu erreichen die Qualität der Software. Bieten Sie eine tragbarere Kommunikation und Zusammenarbeit für Programmentwickler, Benutzer usw. Als ursprüngliche Grundlage für Arbeitsergebnisse können die Systembedarfsanalyse und die Machbarkeitsanalyse potenziellen Benutzern auch indirekt die Funktionen des Systems zum Ausdruck bringen, sodass Benutzer beurteilen können, ob die Funktionen des Systems den zu erreichenden Anforderungen entsprechen.
3.1 Machbarkeitsanalyse
Die Machbarkeitsanalyse basiert auf den Hauptinhalten und unterstützenden Bedingungen des Projekts in Bezug auf Technologie, Wirtschaft, Technik, Technologie usw., wie z. B. Marktnachfrage, Ressourcenangebot, Baumaßstab, Prozessroute, Ausrüstungsauswahl, Umweltauswirkungen, Mittelbeschaffung , Rentabilität usw. Forschung, Analyse und Vergleich anderer Aspekte, Vorhersage der finanziellen, wirtschaftlichen und sozialen Umweltauswirkungen, die nach Abschluss des Projekts erzielt werden können, ob es sich lohnt, in das Projekt zu investieren, und wie Projektentscheidungen zu beraten und zu treffen sind, bilden die Grundlage dafür eine umfassende Systemanalysemethode. Eine Machbarkeitsanalyse sollte weitsichtig, fair, zuverlässig und wissenschaftlich sein.
Um die Wissenschaftlichkeit, Objektivität und Unparteilichkeit der Arbeit der Machbarkeitsstudie sicherzustellen und Fehler und Auslassungen wirksam zu verhindern, müssen wir in der Machbarkeitsstudie zunächst Untersuchungen und Untersuchungen von einem objektiven und unparteiischen Standpunkt aus durchführen und bei der Erhebung grundlegender Daten gute Arbeit leisten. Die erhobenen Basisdaten müssen anhand objektiver Ist-Bedingungen nachgewiesen und ausgewertet werden, objektive Wirtschaftsgesetze wahrheitsgemäß widerspiegeln und ausgehend von objektiven Daten und durch wissenschaftliche Analyse eine Schlussfolgerung über die Machbarkeit des Vorhabens gezogen werden.
Die inhaltliche Tiefe des Machbarkeitsstudienberichts muss den vom Staat vorgegebenen Standards entsprechen, der Grundinhalt muss vollständig sein und es sollten möglichst viele Daten verwendet werden, um minderwertige Arbeit und Formalismus zu vermeiden.
Die folgenden Schlüsselpunkte müssen in der Praxis gemeistert werden: Zuerst demonstrieren, dann Entscheidungen treffen; die Beziehung zwischen den drei Phasen Projektvorschlag, Machbarkeitsstudie und Bewertung richtig handhaben. Forschung sollte in jedem Stadium gestoppt werden, wenn sie sich als nicht durchführbar erweist; Untersuchungen und Untersuchungen müssen durchgeführt werden. Es ist notwendig, praktische und zuverlässige Informationen zu beherrschen, um die Vollständigkeit, Wichtigkeit, Objektivität und Kontinuität der Datenauswahl sicherzustellen; vergleichen Sie mehrere Optionen und wählen Sie die beste aus. Bei Projekten mit Auslandsbezug oder Projekten, die unter dem Druck externer Faktoren wie dem WTO-Beitritt ausländischen Standards entsprechen müssen, sollten Inhalt und Tiefe der Machbarkeitsstudie so weit wie möglich mit internationalen Standards übereinstimmen.
Um die Qualität der Machbarkeitsstudie sicherzustellen, sollte ein ausreichender Arbeitszyklus der beratenden Designeinheit sichergestellt werden, um unverantwortliches und übereiltes Verhalten aus verschiedenen Gründen zu verhindern.
Der Zweck der Machbarkeitsanalyse besteht darin, festzustellen, ob das Problem in kürzester Zeit und mit den geringsten Kosten gelöst werden kann. Der Hauptzweck der Machbarkeitsanalyse besteht nicht darin, Probleme zu lösen, sondern zu untersuchen, ob es sich lohnt, für die Untersuchung und Lösung dieser Probleme personelle und finanzielle Ressourcen aufzuwenden. Wenn es einen einfachen Weg gibt, dann ja.
3.1.1 Wirtschaftliche Machbarkeitsanalyse
Der Zweck der wirtschaftlichen Machbarkeitsanalyse des Systems besteht darin, die von der Entwicklung und dem Bau bis zum Systembetrieb erforderlichen Kapitalinvestitionen sowie die Marktnachfrage und den wirtschaftlichen Nutzen des neuen Systems zu berechnen, das Investitionsbudget mit den erwarteten Vorteilen zu vergleichen und zu berechnen die wirtschaftlichen Kosten. Machbarkeit.
Dieses Spielsystem wird hauptsächlich für die Gestaltung von Software-Engineering-Abschlusskursen für Studenten verwendet, und es besteht keine Notwendigkeit, die wirtschaftlichen Vorteile, die es generieren kann, und den zukünftigen Entwicklungsstatus des Spiels zu berücksichtigen. Die wirtschaftlichen Anforderungen an das Spielsystem selbst sind nicht hoch, jedoch werden durch die Entwicklung dieses Spielsystems die eigenen Kenntnisse und Fähigkeiten der Studierenden verbessert. Sie benötigen lediglich einen Computer, der mit der JDK-Betriebsumgebung und der Java-Entwicklungstool-Eclipse-Software ausgestattet ist, sodass Sie keine Rücksicht auf wirtschaftliche Aspekte nehmen müssen.
3.1.2 Technische Machbarkeitsanalyse
Es gibt viele Programmiersprachen, die zum Schreiben von Tetris-Spielen verwendet werden können. Dieses Thema dient hauptsächlich der Entwicklung des Spielsystems in einer Java-basierten Umgebung. Daher verwendet dieses System hauptsächlich Swing-Komponenten in Java für die Entwicklung und erfordert Variablendefinitionen und Initialisierung. , Schnittstellendesign, Spielinitialisierung, Betreten des Spiels, Verlassen des Spiels, Handhabung verschiedener Vorgänge während des Spiels und Ausführen von Codeanforderungen für entsprechende Funktionen. Die technischen Anforderungen sind nicht besonders schwierig und technisch machbar.
3.1.3 Soziale Machbarkeitsanalyse
Die Entwicklung dieses Spielsystems wird hauptsächlich für die Gestaltung von Abschlusskursen und Abschlussarbeiten verwendet, um das Wissen aus vier Jahren Universitätsstudium zu festigen. Es richtet sich hauptsächlich an Einzelpersonen und Schulen. Es dient nur der persönlichen Unterhaltung und der Prüfung von Schulkursen und Abschlussarbeiten Dateien. Dies ist nicht der Fall. Es wird keine Auswirkungen auf die Gesellschaft haben, daher besteht keine Notwendigkeit, rechtliche, urheberrechtliche oder andere soziale Faktoren zu berücksichtigen. Diesbezüglich ist es durchaus machbar.
3.2 Anforderungsanalyse
Die sogenannte „Bedarfsanalyse“ bezieht sich auf eine detaillierte Analyse des zu lösenden Problems, wobei die Anforderungen des Problems geklärt werden, einschließlich der Daten, die eingegeben werden müssen, der erzielten Ergebnisse und der Ausgabe, die am Ende ausgegeben werden soll. Man kann sagen, dass die „Bedarfsanalyse“ in der Softwareentwicklung darin besteht, festzustellen, was der Computer „macht“ und welche Wirkung er erzielt. Man kann sagen, dass die Anforderungsanalyse abgeschlossen ist, bevor das System fertiggestellt ist.
In der Softwareentwicklung bezieht sich die Anforderungsanalyse auf alle Arbeiten, die zur Beschreibung des Zwecks, Umfangs, der Definition und der Funktionalität des neuen Systems erforderlich sind, wenn ein neues Computersystem erstellt oder ein bestehendes Computersystem geändert wird. Die Anforderungsanalyse ist ein Schlüsselprozess im Software-Engineering. Dabei ermitteln Systemanalytiker und Softwareentwickler die Bedürfnisse des Kunden. Erst wenn diese Bedürfnisse identifiziert sind, können Lösungen für das neue System analysiert und weiterverfolgt werden. Die Aufgabe der Anforderungsanalysephase besteht darin, die Funktionalität des Softwaresystems zu ermitteln.
In der Geschichte des Software-Engineerings hat man immer geglaubt, dass die Anforderungsanalyse der einfachste Schritt im Software-Engineering sei. Doch im Laufe des letzten Jahrzehnts hat sich immer mehr die Erkenntnis durchgesetzt, dass die Bedarfsanalyse der wichtigste Prozess ist. Wenn der Analyst die Bedürfnisse des Kunden bei der Bedarfsanalyse nicht richtig verstehen kann, wird die endgültige Software die Bedürfnisse des Kunden nicht wirklich erfüllen oder das Softwareprojekt wird nicht innerhalb der vorgegebenen Zeit abgeschlossen.
3.2.1 Funktionale Anforderungen
Das gesamte Spielsystem generiert zufällig 7 verschiedene Blockformen, die aus vier kleinen Blöcken bestehen. Nach der Rotation werden 28 Zustände erhalten. Wenn der Spielschwierigkeitsgrad erhöht wird, werden sechs verschiedene Blockformen hinzugefügt. Nach der Rotation werden 24 Typen erzeugt hinzugefügt. Zustand. Die Blöcke fallen mit einer bestimmten Geschwindigkeit frei. Der Spieler steuert die Links- und Rechtsbewegung und Drehung der Blöcke über die Auf-, Ab-, Links- und Rechtstasten auf der Tastatur und platziert die Blöcke nach dem Fallen an der entsprechenden Position. Wenn der Block fällt und eine ganze Reihe mit Blöcken gefüllt ist, nachdem der Block gefallen ist, wird die gesamte Reihe eliminiert. Wenn eine Reihe eliminiert wird, erhöht sich die Punktzahl des Spielers um 10 Punkte. Wenn die Punktzahl 100 Punkte erreicht, erhöht sich die Stufe des Spielers um eine Stufe, die Geschwindigkeit erhöht sich um eine Stufe und der Schwierigkeitsgrad. Wenn nach dem Fallen des Blocks die gesamte Spieloberfläche belegt ist, fällt der Block nicht mehr und das Spiel schlägt fehl. Die spezifischen funktionalen Anforderungen des Spiels sind wie folgt:
▪ Anforderungen an die Spieloberfläche: Eine gute Benutzeroberfläche des Spiels lässt die Augen der Spieler strahlen und sie können die Unterhaltung und Entspannung, die das Spiel mit sich bringt, voll und ganz spüren. Die Standardhintergrundfarbe dieses Spiels ist Dunkelgrün. Der Hauptbildschirm des Spiels kann an Ihr Lieblingsbild angepasst und geändert werden. Die Standardfarbe der Quadrate der Hauptschnittstelle ist Orange und die Standardfarbe der Quadrate vor der Anzeige ist Orange Lavendel. Die Hintergrundfarbe und die Vordergrundfarbe stehen in scharfem Kontrast, um die Augen des Spielers heller zu machen. Wenn das Spiel ein hohes Level erreicht und die Fallgeschwindigkeit der Blöcke zunimmt, können die Spieler die Form der fallenden Blöcke deutlich erkennen, was die Atmosphäre erhöht das Spiel. Irritierend.
▪ Spielformanforderungen: Verwenden Sie ein Array als Datenstruktur, um 52 Zustände des Blocks zu speichern, nämlich insgesamt 7 Formen, einschließlich langer Balken der Primärebene, Z-Form, umgekehrte Z-Form, Feldform, 7-Form , umgekehrte 7-Form und T-Form. Rotationsverformung in 4 Richtungen, drei Blöcke im mittleren Level und 12 verschiedenen Zuständen und drei Blöcke im fortgeschrittenen Level mit 12 verschiedenen Zuständen. Jeder Block kann sich gegen den Uhrzeigersinn drehen, und ob sich der Block drehen kann, muss anhand der Bedingungen beurteilt werden. Wenn der Block nach der Drehung die Grenze überschreitet, kann er sich nicht drehen, und die Position muss angepasst werden, um sicherzustellen, dass er sich drehen kann.
▪ Anforderungen für Tastaturverarbeitungsereignisse: Wenn der Block fällt, kann der Spieler die Richtungstasten auf der Tastatur verwenden: die Aufwärtstaste zum Drehen, die Abwärtstaste zum Beschleunigen des Sturzes, die linke Taste zum Bewegen nach links, die rechte Taste zum Bewegen nach rechts, und die Leertaste, um das Fallen mit einem Klick zu realisieren. Die Taste mit dem Buchstaben P implementiert eine Pause, und die Taste mit dem Buchstaben C implementiert eine Reihe von Vorgängen wie Fortfahren.
▪ Anforderungen für Mausverarbeitungsereignisse: Mit der Maus können Sie auf die Menüschaltfläche und die Hilfeschaltfläche im Bedienfeld klicken, Menüelemente in der Menüleiste auswählen, das Spiel starten, die Spielstufe auswählen und die Farbanzeige der Blöcke im ändern Spiel und Hintergrund der Hauptspieloberfläche. Anzeigefarbe und Vordergrundfarbe, Ändern des Hintergrundbilds des Spiels, Blockieren der Fallgeschwindigkeit, ob In-Game-Sounds abgespielt werden sollen und eine Reihe von Funktionen.
▪ Anzeigeanforderungen: Die Anzeigeanforderungen dieses Spielprogramms bestehen darin, dass, wenn die Blöcke fallen und eine ganze Reihe füllen, die Reihe entfernt wird und die verbleibenden nicht gefüllten Reihen automatisch eine nach der anderen nach unten verschoben werden. Durch das Entfernen einer Reihe erhöht sich die Punktzahl die rechte Schnittstelle um zehn Punkte. Wenn die Punktzahl auf 100 Punkte steigt, erhöht sich die Stufe um eine Stufe. Wenn der Block herunterfällt und alle Zeilen der Hauptschnittstelle überlagert, fällt der Block nicht mehr, das Spiel endet und die Hauptschnittstelle zeigt das Wort „Game Over“ an.
3.2.2 Nichtfunktionale Anforderungen
Nichtfunktionale Anforderungen: Zu den nichtfunktionalen Anforderungen des Tetris-Spielsystems gehören die Symbolanzeige in der oberen linken Ecke der Hauptschnittstelle des Spiels, die Anpassung der Fenstergröße zum Maximieren und Minimieren (jedoch nicht einschließlich der Größe der Hauptschnittstelle), und die Position des Popup-Fensters, wenn das Spiel läuft. Eine Reihe nichtfunktionaler Anforderungen.
3.2.3 Schnittstellensteuerung
Unter dem Windows-Betriebssystem bedient dieses russische Spielsystem das Spiel hauptsächlich über die Tastatur.
Mit der Maus können Sie eine Reihe von Vorgängen wie Starten, Beenden und Einstellungen ausführen. Erstens verwendet das Spiel Tastaturtasten, um das Spiel zu bedienen, daher müssen Tastaturschnittstellenereignisse verwendet werden. Zweitens müssen Sie während des gesamten Spiels die Maus verwenden, um das Spiel zu steuern, einschließlich Starten, Auswählen von Levels, Ändern von Einstellungen, Ändern von Farben, Anzeigen von Versionsinformationen, Beenden usw., daher müssen Sie eine Schnittstelle hinzufügen Überwachen Sie Ereignisse für Mausklicks und Tasten. Schreiben Sie den entsprechenden Code, um die entsprechenden Funktionen von Maus und Tastatur zu implementieren.
4 Systemumrissentwurf
4.1 Funktioneller Aufbau des Systems
4.1.1 Grundprozess der manuellen Geschäftsabwicklung
Dieses Spiel wurde mit Unterhaltung als ursprünglicher Absicht und Rätsel als Zweck entwickelt. Es basiert auf einer umfassenden Untersuchung der Funktionen früherer klassischer Tetris-Spiele und führt neue ein, indem es neue Funktionen hinzufügt, um ihm neue Vitalität und Vitalität zu verleihen. Der grundlegende Ablauf des Spiels wird im Folgenden ausführlich erläutert.
Bedienungsanleitung:
1>Führen Sie das Programm aus und klicken Sie in der Systemsteuerung rechts auf „Start“ oder im Menü „Steuerung“ auf die Schaltfläche „Start“, um das Spiel zu starten.
2>Verwenden Sie die Aufwärts-, Abwärts-, Links- und Rechtstasten sowie die Leertaste, die P-Taste und die C-Taste, um die Verformung, den Fall, die Links- und Rechtsbewegung des Blocks und den schnellen Fall zu steuern, zu pausieren und mit einem Klick fortzufahren.
3> Eliminieren Sie eine vollständige Reihe von Blöcken. Die Punktzahl erhöht sich automatisch und das Level erhöht sich automatisch um ein Level.
4>Wenn das Level steigt und die Fallgeschwindigkeit der Blöcke zunimmt, drücken Sie die Tasten „Einfach“, „Mittel“ und „Erweitert“ auf dem rechten Bedienfeld oder im Menü „Spiel“, um den Schwierigkeitsgrad des Spiels manuell zu ändern. Sie können auch auf die Optionen im Menü „Blockfarbe“ klicken, um die Farbe der Blöcke usw. zu ändern. Sie können auch einige Attribute des Spiels über die Optionen im Menü „Anpassen“ ändern.
5> Drücken Sie die P-Taste auf der Tastatur, um das Spiel anzuhalten, und drücken Sie dann die C-Taste, um das Spiel fortzusetzen. Durch Drücken der Schaltfläche „Spiel beenden“ wird das laufende Spiel vollständig gestoppt, durch Drücken von „Start“ oder „Neustart“ im Menü „Steuerung“ wird ein neues Spiel gestartet.
6>Wenn die Blöcke das gesamte Fenster einnehmen und keine neuen Blöcke fallen können, erscheint im Spiel ein „Game Over“-Dialogfeld, das Sie auffordert, das Spiel zu beenden.
Das grundlegende Flussdiagramm des Spiels ist in Abbildung 4-1 dargestellt:
Abbildung 4-1 Grundlegendes Flussdiagramm des Spiels
4.1.2 Funktionsmodule des Basisprozesses
Dieses System entwirft jedes Funktionsmodul des Spiels basierend auf den verschiedenen Funktionen des Spiels. Abbildung 4-2 ist ein schematisches Diagramm der Systemfunktionsmodule dieses Spiels. Wie in der Abbildung gezeigt, besteht dieses Spiel hauptsächlich aus zwei Modulen: dem Spielschnittstellenbereich und dem Spielsteuerungsbereich. Die Spieloberfläche ist in zwei Teile unterteilt: Anzeige der optionalen Operationen des Spielers und Anzeige der Ergebnisse der Operationen des Spielers. Die Spielsteuerung ist in einige Funktionsmodule unterteilt, z. B. Farbwechsel, Starten, Ändern des Spielniveaus auf „Einfach“, Ändern des Spielniveaus auf „Mittel“, Ändern des Spielniveaus auf „Fortgeschritten“, Anpassen der Fallgeschwindigkeit, Ändern des Hintergrunds, Beenden und andere.
Abbildung 4-2 Schematische Darstellung der Systemfunktionsmodule
Abbildung 4-3 ist ein schematisches Diagramm des Designs des Spielschnittstellenbereichsmoduls. Wie in der Abbildung gezeigt, kann das Spielschnittstellenbereichsmodul in drei Funktionsmodule unterteilt werden: Eingabe der neuen Spielschnittstelle, Verarbeitung von Spieleroperationen und Anzeige von Spieleroperationsergebnissen .
Abbildung 4-3 Schematische Darstellung des Schnittstellenmoduls
Abbildung 3-4 ist ein schematisches Diagramm des Spielkontrollbereichsdesigns. Wie in der Abbildung gezeigt, ist das Spielkontrollbereichsmodul in Funktionsmodule wie Start, benutzerdefinierte Betriebseinstellungen, anfängliche Spielstufeneinstellungen, anfängliche Farbeinstellungen und Beenden unterteilt .
Abbildung 4-4 Schematische Darstellung des Steuerbereichsmoduls
5Detaillierter Entwurf und Implementierung des Systems
Java ist eine rein objektorientierte (objektorientierte) Programmiersprache, auf deren viele Vorteile hier nicht näher eingegangen werden soll. Ausgehend vom objektorientierten Konzept lässt sich dieses Programm im Wesentlichen in folgende Module gliedern:
●Anzeigemodul der Hauptschnittstelle des Spiels
●Block- und Datenanzeigemodul
●Modul zur Blockbewegungssteuerung
●Spielschnittstellen-Farbsteuerungsmodul
●Spielfortschritts- und Levelkontrollmodul
Die Fähigkeit zur Analyse eines Objekts liegt in seiner funktionalen Skalierbarkeit und Wartungseffizienz. Stellen Sie sich vor, wenn die Funktion des Programms aufgrund von Änderungen in der externen Umgebung oder Benutzeranforderungen erweitert oder beibehalten werden muss, muss der Code erheblich geändert oder sogar neu geschrieben werden. Auf diese Weise geht der objektorientierte Vorteil verloren Daher wird bei der Analyse dieses Programms ein hochgradig unabhängiges Modul als Objekt verwendet, um die Skalierbarkeit und Wartbarkeit des Programms zu verbessern. Das Folgende ist das Design der Klassen im Spiel:
MyFrame-Klasse: Von der JFrame-Klasse als Hauptklasse des Spiels geerbt, ist sie für die Steuerung des Hauptteils des Spiels sowie für die Verbindung und Steuerung des Hubs jeder Klasse verantwortlich.
PreView-Klasse: Von der JPanel-Klasse geerbt, ist sie als Bedienfeldklasse für die Platzierung des Hauptspielfensters, der Anzeigetafel, der Level-Steuerungsschaltflächen und anderer Fenster zur Steuerung des Spielprozesses verantwortlich.
GameCanvas-Klasse: Die von der JPanel-Klasse geerbte Thread-Klasse ChangeBlockColor ändert dynamisch die Quadratfarbe der Canvas-Klasse. Die Canvas-Klasse spiegelt die Bewegung und Eliminierung des ChangeBlockColor-Quadrats wider, indem sie die Quadratfarbe überprüft.
Box-Klasse: Quadratische Klasse, die Grundelemente, aus denen die Box besteht. Der Hauptausdruck ist Farbe.
Blockklasse: Als Klasse zur Manipulation von Blöcken steuert sie die Bewegung, den Fall und die Verformung von Blöcken.
5.1 Anzeigemodul der Hauptschnittstelle des Spiels
Ein hervorragendes Softwaresystem spiegelt sich nicht nur in der Vielfalt und Leistungsfähigkeit der Kernfunktionen wider. Wenn der Benutzer mit einer langweiligen und alten Benutzeroberfläche konfrontiert wird, wird das Softwaresystem keinen Erfolg haben. Daher wird ein gutes und exquisites Softwaresystem nicht erfolgreich sein . Interface-Design ist ein äußerst wichtiges Bindeglied. Es liegt auf der Hand, wie wichtig es ist, eine Benutzeroberfläche mit angemessenem Layout und guten visuellen Effekten für die Spieler zu entwerfen und zu produzieren.
Die Hauptschnittstelle des Spiels wird mithilfe von Swing-Komponenten entwickelt, und Listener werden bei ihr registriert, um verschiedene Steuerfunktionen zu implementieren. Basierend auf dem Design des Spielformulars müssen mindestens drei Listener darauf registriert werden, nämlich Aktionslistener (ActionListener). und Tastatur-Listener. Listener (KeyListener), Options-Listener (ItemListener).
Gemäß dem vorläufigen Entwurf kann festgestellt werden, dass die auf dem Client zu verwendenden Swing-Komponentenobjekte JFrame-Objekte, JPanel-Objekte, JLabel-Objekte, JButton-Objekte, JMenuBar-Objekte, JMenu-Objekte, JMenuItem-Objekte, JTextField-Objekte, JTextArea-Objekte und JDialog umfassen Objekte usw., mindestens zehn Swing-Komponentenobjekte. Abbildung 5-1 unten ist ein Screenshot der Hauptoberfläche des Spiels.
Abbildung 5-1 Screenshot der Hauptoberfläche des Spiels
Die anfängliche Farbanpassung des Hauptschnittstellendesigns dieses Spiels basiert auf dem Prinzip des scharfen Kontrasts. Die Standardhintergrundfarbe ist dunkelgrün. Das Tetris-Symbol befindet sich in der oberen linken Ecke. Der Anfangswert der Punktzahl ist 0 Der Anfangswert der Ebene ist 1 und der Anfangswert des Datensatzes mit der höchsten Punktzahl ist 0. Die Größe der Hauptspielform ist auf (520, 580) eingestellt, der Blockbewegungsbereichsbereich wird durch ein zweidimensionales Array mit 20 Zeilen und 12 Spalten gesteuert und das Symbol in der oberen linken Ecke ist auf ein Blockmuster eingestellt zu Identifikationszwecken.
5.2 Leinwand- und Box-Anzeigemodul
In diesem Spiel ist die Leinwand als individuelles Bild gestaltet. Sie können das Hintergrundbild selbst nach Ihren eigenen Bedürfnissen ändern. Während des Fallvorgangs der Blöcke werden die fallenden Blöcke anhand der Farbänderungen identifiziert.
5.2.1 Design des Hintergrund-Canvas-Moduls
Die Haupthintergrundfläche des Spiels ist ein zweidimensionales Array mit 20 Zeilen und 12 Spalten. Die quadratische Anzeige wird durch entsprechende Farbänderungen identifiziert. Die Hauptform wird mit Farbe gefüllt, um den Hintergrundstil und die Quadrate zu bilden. Dieses Spiel verwendet die von JPanel geerbte GameCanvas-Klasse, um die Anzeige der Hintergrundleinwand zu steuern. Zeilen stellen die Anzahl der Zeilen der Leinwand dar, und Spalten stellen die Anzahl der Spalten der Leinwand dar. Die Anzahl der Zeilen und Spalten bestimmt die Anzahl der Quadrate die Leinwand hat. Der Hauptimplementierungscode der Hintergrundleinwand lautet wie folgt:
Verwenden Sie zunächst einen Konstruktor der Canvas-Klasse, um die Anzahl der Zeilen, Spalten und des Hauptrahmens der gesamten Hauptschnittstelle darzustellen.
Relative Position in:
/**
* Konstruktor der Canvas-Klasse
* @param rows int, die Anzahl der Zeilen im Canvas
* @param cols int, die Anzahl der Spalten der Leinwand
* Die Anzahl der Zeilen und Spalten bestimmt die Anzahl der Quadrate, die die Leinwand hat
*/
public GameCanvas(int rows, int cols) {
this.rows = Zeilen;
this.cols = cols;
this.setOpaque(false);
boxen = new Box[rows][cols];
for (int i = 0; i < boxen.length; i++) {
for (int j = 0; j < boxen[i].length; j++) {
boxen[i][j] = new Box(false);
}
}
setBounds(0, 0, 300, 500); // Relative Positionskoordinaten festlegen
setBorder(neuer EtchedBorder(
EtchedBorder.RAISED, Color.white, neue Farbe(148, 145, 140)));
}
/**
* Ermitteln Sie die Anzahl der Quadratreihen auf der Leinwand
* @return int, die Anzahl der Zeilen im Raster
*/
public int getRows() {
Zeilen zurückgeben;
}
/**
* Ermitteln Sie die Anzahl der Spalten im Canvas
* @return int, die Anzahl der Spalten im Raster
*/
public int getCols() {
Rückgabespalten;
}
Zweitens legen Sie einen Konstruktor der Canvas-Klasse fest, um die Vordergrund- und Hintergrundfarbe der gesamten Hauptschnittstelle darzustellen und deren Vordergrund- und Hintergrundfarben zu erhalten:
/**
* Konstruktor der Canvas-Klasse
* @param rows ist dasselbe wie public GameCanvas(int rows, int cols)
* @param cols ist dasselbe wie public GameCanvas(int rows, int cols)
* @param backColor Farbe, Hintergrundfarbe
* @param frontColor Farbe, Vordergrundfarbe
*/
public GameCanvas(int rows, int cols,
Farbe backColor, Farbe frontColor) {
this(rows, cols);
this.backColor = backColor;
this.frontColor = frontColor;
}
/**
* Stellen Sie die Hintergrundfarbe des Spiels ein
* @param backColor Farbe, Hintergrundfarbe
*/
public void setBackgroundColor(Color backColor) {
this.backColor = backColor;
}
/**
* Holen Sie sich die Hintergrundfarbe des Spiels
* @return Farbe, Hintergrundfarbe
*/
öffentliche Farbe getBackgroundColor() {
zurück backColor;
}
5.2.2 Vorschau des Blockmoduldesigns
Blöcke und Dateninformationen sind die grundlegendsten Funktionsmodule im Spiel. Box, eine gitterartige Klasse, ist das Grundelement, aus dem ein Block besteht. Sie verwendet ihre eigene Farbe, um das Erscheinungsbild des Blocks darzustellen. MyTask erbt die TimerTask-Klasse, um den Aufenthaltsort zu messen, und verwendet Zählmethoden, um Geschwindigkeitsänderungen zu erzielen. Die Die MyListener-Klasse erbt die KeyAdapter-Klasse, um die Schaltflächenüberwachung zu implementieren und den Block nach oben, unten, links und rechts zu steuern. Definieren Sie eine quadratische 4x4-Matrix mit insgesamt 16 Zellen. Verwenden Sie „0“ und „1“, um anzugeben, ob jedes Quadrat mit einer neuen Farbe bemalt wird oder die Hintergrundfarbe behält.
Jedes Mal, wenn ein neuer Block erhalten wird, wird eine der sieben Blockformen zufällig ausgewählt. Das Spiel definiert eine Variable, die das Modell des neuen Blocks darstellt. Definieren Sie beispielsweise ein int-Array STYLE zur Darstellung von 28 Blocktypen mit 7 Zeilen und 4 Spalten, wobei jedes Element einen der Blöcke darstellt. Das heißt, 0<=blockkindnum<=6, 0=<blockstatusnum<=3
Wenn dann der Block fällt und Sie einen neuen Block benötigen, müssen Sie nur zufällig ein Paar von Blockkindnum- und Blockstatusnum-Werten abrufen und dann den entsprechenden Block basierend auf dem Wert dieses STILs erstellen. Die verbleibende Frage ist, wie man zufällig ein Paar von STYLE-Zeilen- und -Spaltenwerten generiert.
Die Math-Klasse im Java-Sprachpaket stellt eine Methode random() zum Generieren von Zufallszahlen bereit. Durch den Aufruf dieser Methode wird eine Gleitkommazahl mit doppelter Genauigkeit zwischen 0 und 1 generiert. Jedes Mal, wenn Sie einen neuen Block erhalten möchten, müssen Sie diese Methode nur einmal aufrufen, um eine Gleitkommazahl mit doppelter Genauigkeit von 0 bis 1 zu erhalten, die Zahl dann mit 7 zu multiplizieren und sie dann in eine Ganzzahl umzuwandeln, um eine zu erhalten Ganzzahl von 1 bis 7. , wird zur Steuerung von Zeilen verwendet. Multiplizieren Sie diese Zahl mit 4 und wandeln Sie sie dann in eine Ganzzahl um, um eine Ganzzahl von 1 bis 4 zu erhalten, die zur Steuerung der Spalte verwendet wird.
Daraus können mehrere Grafikdefinitionen kombiniert und folgende Funktionen per Code implementiert werden:
1> Jede Ausführung generiert zunächst einen anderen Anfangswert für die Zufallszahl.
int col = (int) (Math.random() * (gc.getCols() - 3));//Spalten an zufälligen Positionen generieren
int style = Constant.STYLES[(int) (Math.random() * Block.get_addl())][(int) (Math.random() * 4)];
Abbildung 5-2 Flussdiagramm der zufällig generierten Blöcke
2> Wählen Sie zufällig eine Figur aus. Abbildung 5-2 generiert zufällig ein Blockdiagramm, um die generierte Zufalls-CNC spezifisch zu beschreiben
Die resultierenden Grafiken.
3>Die Positionsinformationen der aktuellen Grafik in ihrem 4*4-Raster.
Zeichnen Sie ein Voranzeigeraster aus 4 Zeilen und 4 Blockspalten und generieren Sie zufällig einen Voranzeigeblockstil. Dieses Spiel verwendet ein zweidimensionales Array zum Speichern von 28 Blockstilen.
Es ist erwähnenswert, dass dieses Spielsystem auf der Grundlage des traditionellen Tetris-Spiels drei weitere Blockstile auf der Mittelstufe und drei weitere Blockstile auf der Grundlage von hinzufügt, um innovatives Denken widerzuspiegeln und im Einklang mit dem Prinzip des Lernens Das traditionelle Spiel. Andere Blockstile. Insgesamt gibt es 52 Blockstile. Der Hauptimplementierungscode für die spezifische Speichermethode lautet wie folgt:
/**
* Entspricht 52 Staaten bzw. 13 Modellen
*/
public final static int[][] STYLES = {// Insgesamt 28 Zustände
{0xf000, 0x8888, 0xf000, 0x8888}, // Vier Zustände des langen Balkens
{0x4e00, 0x4640, 0xe400, 0x4c40}, // Vier Zustände vom Typ „T“.
{0x4620, 0x6c00, 0x4620, 0x6c00}, // Vier Zustände der umgekehrten Z-Form
{0x2640, 0xc600, 0x2640, 0xc600}, // Vier Zustände vom Typ „Z“.
{0x6220, 0x1700, 0x2230, 0x7400}, // Vier Zustände vom Typ „7“.
{0x6440, 0xe200, 0x44c0, 0x8e00}, // Vier Zustände vom umgekehrten Typ „7“.
{0x6600, 0x6600, 0x6600, 0x6600}, // Vier Zustände des Blocks
{0x8c88,0xf200,0x44c4,0x4f00},//3 Blöcke im Zwischenstil hinzugefügt
{0xea00,0xc4c0,0xae00,0xc8c0},
{0x8c00,0xc800,0xc400,0x4c00},
{0xac00,0xcc40,0x6e00,0x8cc0},//3 erweiterte Stilblöcke hinzugefügt
{0x4e40,0x4e40,0x4e40,0x4e40},
{0x8480,0xa400,0x4840,0x4a00},
};
Ich glaube, dass viele Leute die 7 Blockstile des traditionellen Tetris-Spiels kennen, daher werde ich keine Screenshots machen, um die gängigen Blockstile einzeln zu zeigen. Im Folgenden sind drei Blockmodelle mit mittlerem Schwierigkeitsgrad und drei fortgeschrittene Schwierigkeitsgrade aufgeführt, die dem traditionellen Spielmodus hinzugefügt wurden:
●Drei Blockmodelle mit mittlerem Schwierigkeitsgrad hinzugefügt (vier Rotationszustände können nach 90 Grad, 180 Grad, 270 Grad und 360 Grad erhalten werden)
Abbildung 5-10 Drei zusätzliche Blockmodelle mit mittlerem Schwierigkeitsgrad
●Drei erweiterte Schwierigkeitsblockmodelle hinzugefügt (vier Rotationszustände können nach 90 Grad, 180 Grad, 270 Grad und 360 Grad erreicht werden)
Abbildung 5-11 Drei zusätzliche Blockmodelle für fortgeschrittene Schwierigkeitsgrade
5.2.3 Blockbewegungs- und Rotationsmoduldesign
Das Spiegeln und Verschieben von Blöcken ist relativ einfach zu implementieren. Um einen Block zu verschieben, müssen Sie lediglich die Abszisse oder Ordinate des Blocks ändern und den Block dann neu zeichnen. Um den Block umzudrehen, müssen Sie nur den Wert des Hintergrundarrays ändern und den Block neu zeichnen.
Wenn die Blöcke in diesem Spiel fallen, wird ein dynamisches Zeichnen durchgeführt und die Cloneable-Schnittstelle implementiert, um anzuzeigen, dass die Methode Object.clone() die Instanz dieser Klasse legal nach Feldern kopieren kann. Die Blockoperationsklasse BlockOperation erbt die Thread-Klasse und überschreibt die run()-Methode, um den dynamischen und korrekten Aufenthaltsort des Blocks zu erkennen. Natürlich muss festgestellt werden, ob sich der Block im Thread im Bewegungszustand oder im Pausenzustand befindet.
publicvoid run()
{
//moving bestimmt, ob der Block dynamisch fällt
während (sich bewegen)
{
versuchen
{
//betweenleveltime gibt den Zeitunterschied zwischen benachbarten Levels an
schlafen(zwischenleveltime
* (ControlMainGame.maxlevel - Level + Flatgene));
} Catch (InterruptedException ie)
{
dh.printStackTrace();
}
//Pause bestimmt, ob das Spiel pausiert ist
if (!pause)
Moving = (moveTo(y + 1, x) && Moving);
//moving wartet 100 Millisekunden und die Bewegung wurde nicht geändert.
}}
Natürlich müssen wir im Spiel auch das Grenzproblem der Blockbewegung bestimmen. Beispielsweise hat ein Block auf seiner linken Seite genau ein Raumgitter, bevor er umgedreht werden kann, aber auf seiner rechten Seite gibt es genau ein Raumgitter Wenn der Block in diesem Fall nicht umgedreht werden kann, ist das Umdrehen für den Benutzer unpraktisch. Wenn er umgedreht werden kann, überschreitet er die Grenze und belegt die vorhandenen Blöcke. Wenn Sie den Block umdrehen möchten, ohne die Grenzen zu verlassen, sollten Sie den Block nach dem Umdrehen um ein Feld nach rechts verschieben und den Block dann erneut zeichnen. Auf diese Weise wird der Block andere feste Blöcke nicht verdrängen. Das Folgende löst das Out-of-bounds-Problem. .
1>Flip-Urteil blockieren
Grenzüberschreitung kann in zwei Situationen auftreten: zum einen, wenn der Block fällt und fixiert ist, und zum anderen, wenn der umgebende Raum ein Umdrehen nicht zulässt.
Im ersten Fall müssen Sie sich nur auf das Urteil berufen, dass sich der Block nach dem Fallen nicht mehr bewegen kann.
Im zweiten Fall muss vor dem Umdrehen jedes Blocks zunächst der Raum um den Block herum berechnet und umgedreht werden, sofern der Platz dies zulässt. Andernfalls kann es nicht umgedreht werden.
Da die sieben Arten von Quadraten unregelmäßig sind, ist der für jede Art von Quadrat erforderliche Umdrehungsraum unterschiedlich. Selbst in den unterschiedlichen Umdrehungszuständen ist auch der erforderliche Umdrehungsraum unterschiedlich. Das erste, was mir in den Sinn kommt, ist natürlich, jedes Quadrat mit zu versehen Verschiedene Flip-Leerzeichen. Art von Blöcken, und schreiben Sie eine Beurteilungsbedingung für jeden Zustand des Blocks, aber das wäre zu mühsam.
Laut Beobachtung ist es nicht schwer herauszufinden, dass unter den sieben Blockformen ein langer Block, wenn er in Form eines horizontalen Balkens fällt, so lange umgedreht werden kann, wie er fallen kann. Wenn er in Form eines fällt vertikaler Balken, dann befindet es sich nach dem Umdrehen in der Position. Die Position muss einen Rasterraum von 4x1 haben, bevor sie umgedreht werden kann. Solange das Tian-förmige Quadrat weiterhin fallen kann, kann es auf jeden Fall umgedreht werden. Solange das Tian-förmige Quadrat also nicht fällt, kann es immer umgedreht werden. Die anderen fünf Formen von Blöcken haben eines gemeinsam: Sie haben alle zwei umgedrehte Zustände, die horizontal drei Raumgitter und vertikal zwei Felder einnehmen. Die anderen beiden umgedrehten Zustände belegen horizontal zwei Raumgitter und belegen drei Gitterfelder in der vertikalen Richtung. Wenn sie in einen Zustand fallen, in dem sie drei Gitter in der horizontalen Richtung besetzen, können sie, solange sie fallen können, umdrehen. Wenn sie in den Zustand von zwei Gittern in der horizontalen Richtung fallen, dann Nach dem Umdrehen muss in der Umgebung ein 3x2-Rasterraum vorhanden sein.
Daher muss die Bestimmung des Umdrehens eines Blocks in drei Situationen unterteilt werden: Die erste Situation ist, dass der Block nach dem Fallen nicht umgedreht werden kann, die zweite Situation ist, dass der lange Block, der im vertikalen Zustand erscheint, umgedreht wird, und die dritte Situation Zusätzlich zu langen Streifen und feldförmigen Quadraten werden die anderen fünf Quadrate, die in einem Zustand erscheinen, in dem sie zwei Gitter in horizontaler Richtung belegen, auf Umdrehen beurteilt.
Nachdem nun das Problem gelöst ist, unter welchen Umständen der Block umgedreht werden kann, sollten wir als Nächstes das Problem der Position des Blocks nach dem Umdrehen lösen, denn nur, indem wir die Position des Blocks nach dem Umdrehen im Voraus kennen Können wir den räumlichen Bereich dieser Position bestimmen? Treffen Sie eine Bestimmung, um zu sehen, ob sie den Block aufnehmen kann.
Sicher ist, dass sich der Block, egal wie er umgedreht wird, immer noch in der Blockanordnung befindet, was bedeutet, dass sich der Block innerhalb eines bestimmten 4x4-Rasterbereichs auf der Spielkarte befinden muss.
Die Koordinaten des Blockarrays in der Hauptschnittstelle des Spiels werden bestimmt. Was ungewiss ist, ist, wo sich der Block nach dem Umdrehen im Blockarray befindet. Um dieses Problem zu lösen, können wir das Speicherprinzip des Blocks in einschränken Block-Array nach links oder links. Auf diese Weise befinden sich, egal wie Sie es umdrehen, immer Blöcke in der ersten Zeile und Spalte des Block-Arrays. Dies bestimmt auch die Position des Blocks im Block-Array und Sie können auch erfahren, wie der Block auf der Spielkarte angezeigt wird, nachdem er umgedreht wurde. Standort.
Angenommen, die horizontalen und vertikalen Koordinaten des Blockarrays sind x und y, dann ist die Zeile, in der der lange Block umgedreht wird, die y-te Zeile der Spielkarte, und die Spalten, die sie einnimmt, sind die x-te bis x + 3 Spalten, die Zeilen, die von den fünf Arten von Quadraten außer dem langen Streifen und der Feldform nach dem Umdrehen belegt werden, sind die y-te und y+1-te Zeile der Spielkarte, und die Spalten, die sie belegen, sind die x-te bis x+2-Spalte.
Wenn sich im obigen Bereich leere Zellen befinden, können die Blöcke daher umgedreht werden.
2>Flip-Out-of-bounds-Korrektur
Ein Block kann umgedreht werden, solange nach dem Umdrehen noch genügend Platz darauf ist. Was aber, wenn der Platz nach dem Umdrehen des Blocks nicht ausreicht, aber auf der anderen Seite noch genügend Platz ist?
Wenn sich der Block an der Grenze befindet, fällt er nach dem Umdrehen möglicherweise nicht nur aus der Karte, sondern das Array kann auch außerhalb der Grenzen liegen. Natürlich müssen Sie das Kartenarray nur größer definieren, um ein Array außerhalb der Grenzen zu vermeiden Fehler. Für den Block außerhalb der Grenzen, wenn er sich auf der anderen Seite davon befindet. Wenn genügend Platz vorhanden ist, sollte der Block von der entsprechenden Einheit in die andere Richtung verschoben werden, um den Fehler außerhalb der Grenzen des Blocks zu korrigieren. Wie im Flussdiagramm zum Umdrehen von Blöcken in Abbildung 5-12 dargestellt, erfordert das Umdrehen eines Blocks drei Feststellungen: ob er auf den Boden gefallen ist, ob nach dem Umdrehen genügend Platz vorhanden ist und ob er nach dem Umdrehen die Grenze überschritten hat.
Abbildung 5-12 Flussdiagramm der Block-Flip-Verarbeitung
Der Spieler bedient die Tastatur, um die Blöcke zu bewegen und zu drehen. Der Code führt die ControlKeyListener-Klasse ein und erbt die KeyAdapter-Klasse, um die Tastaturüberwachungsfunktion zu implementieren. Die KeyAdapter-Klasse erbt von der Object-Klasse und implementiert die KeyListener-Schnittstelle, eine abstrakte Adapterklasse, die zum Empfangen von Tastaturereignissen verwendet wird. Methoden in dieser Klasse sind leer. Diese Klasse dient dazu, die Erstellung von Listener-Objekten zu erleichtern. Erweitern Sie diese Klasse, um einen KeyEvent-Listener zu erstellen und die Methode des erforderlichen Ereignisses, die ControlKeyListener-Klasse, zu überschreiben. Erstellen Sie mit ControlKeyListener ein Listener-Objekt und registrieren Sie das Listener-Objekt dann mithilfe der addKeyListener-Methode der Komponente bei der Komponente. Wenn eine Taste gedrückt, losgelassen oder eingegeben wird, wird die entsprechende Methode im Listener-Objekt aufgerufen und das KeyEvent an die entsprechende Methode übergeben. Der Implementierungscode lautet wie folgt:
Privateclass ControlKeyListener erweitert KeyAdapter
{
publicvoid keyPressed(KeyEvent ke)
{
if (!game.isPlaying())
zurückkehren;
BlockOperation blockope = game.getCurBlock();
Schalter (ke.getKeyCode())
{
Fall KeyEvent.VK_DOWN:
blockope.moveDown();
brechen;
Fall KeyEvent.VK_LEFT:
blockope.moveLeft();
brechen;
Fall KeyEvent.VK_RIGHT:
blockope.moveRight();
brechen;
Fall KeyEvent.VK_UP:
blockope.turnNext();
brechen;
Standard:
brechen;}}}
5.3 Bedienfeldmodul
5.3.1 Design des Menüleistenmoduls
In der Menüleiste gibt es die vier Menüpunkte „Spiel“ und „Hilfe“. Die Option „Spiel“ ist in sieben Optionen unterteilt: „Start“, „Anfänger“, „Mittelstufe“, „Fortgeschritten“, „Anpassen“, „Blockfarbe“ und „Beenden“. In der Option „Hilfe“ gibt es die Option „Info“, mit der Informationen wie die Spielversion angezeigt werden.
1>Die Funktion der Schaltfläche „Start“ besteht darin, die Spielfläche neu zu zeichnen, ähnlich der Funktion „Zurücksetzen“. Der Überwachungsimplementierungscode dieser Schaltfläche lautet wie folgt:
/**
* Leinwand zurücksetzen
*/
public void reset() {
for (int i = 0; i < boxen.length; i++) {
for (int j = 0; j < boxen[i].length; j++)
boxen[i][j].setColor(false);
}
neu streichen();
}
2>Die Schaltflächen „Grundstufe“, „Mittelstufe“ und „Erweitert“ werden verwendet, um das Level des Spiels manuell anzupassen und so den Schwierigkeitsgrad des Spiels zu ändern. Mit der Schaltfläche „Beenden“ können Sie das Spiel jederzeit beenden und das Spiel beenden.
3>Klicken Sie auf die Schaltfläche „Info“ in der Schaltfläche „Hilfe“, um Informationen zur Spielsoftware selbst anzuzeigen. Die spezifischen Informationen sind wie in der Abbildung dargestellt:
Abbildung 4-19 Screenshot der Option „Info“.
5.3.2 Design der Bedienfeldtasten
Das Spielkontrollfeld enthält Felder wie Punktestatistiken und Levelstatistiken.
Die TextField-Steuerelemente werden von den Statistiken des Spiels selbst bereitgestellt und Spieler können sie nicht privat bearbeiten. Die Spielregeln dieses Spiels lauten 10 Punkte für jede eliminierte Linie und jede weitere 100 Punkte erhöht sich um eine Stufe. Die Anfangspunktzahl ist 0 und die Anfangsstufe ist 1.
Das Folgende ist der Hauptcode zum Implementieren von Funktionen wie Punkte- und Levelaktualisierung:
/**
* Bestimmen Sie, ob die Zeile voll ist. Wenn die Zeile voll ist, rufen Sie die Eliminierungsmethode auf.
*/
private void isFullLine() {
// TODO Automatisch generierter Methoden-Stub
for (int i = 0; i < 20; i++) {
int Zeile = 0;
boolesches Flag = true;
for (int j = 0; j < 12; j++) {
if (!gc.getBox(i, j).isColorBox()) {
flag = false;
brechen;
}
}
if (flag == true) {
Zeile = i;
gc.delete(row);//Zeile löschen
if(isMusic==true)
{mp.playEraseSound();}
addScor();//Punktzahl hinzufügen
if(scor%100==0)//Auf 100 Punkte setzen, um eine Stufe zu erhöhen
upspeed=true;//Erhöhen Sie das Geschwindigkeitsflag auf true
if(upspeed==true)
upLevel();
}
}
}
/**
* Wie Punkte berechnet werden
*/
private void addScor() {
scor=scor+10;
jt9.setText("Score: "+MyFrame.scor);
}
}
private void reset() {
scor=0;
Rang=0;
jt10.setText("Level:"+rank);
jt9.setText("Score: "+scor);
upspeed=false;
spielen=wahr;
runstop=false;
gc.setGameOver(false);
gc.repaint();
gc.reset();
}
Die Funktionen der Tasten im Bedienfeld wurden in 4.3.1 codiert und werden hier nicht noch einmal beschrieben.
6 Systemtestläufe
6.1 Testübersicht
Beim Systemtest geht es darum, die Software, Computerhardware, Peripheriegeräte, das Netzwerk und andere Elemente zusammen zu bestätigen, um Montagetests und Bestätigungstests verschiedener Informationssysteme durchzuführen. Beim Systemtest geht es darum, das gesamte Produktsystem zu testen, um zu überprüfen, ob das System die Anforderungen erfüllt Spezifikationen. Definieren und identifizieren Sie Inkonsistenzen oder Widersprüche mit den Anforderungsspezifikationen, um eine umfassendere Lösung vorzuschlagen. Nachdem beim Systemtest ein Problem festgestellt wurde, versuchen Sie, die Ursache und den Ort des Fehlers herauszufinden und ihn dann zu beheben. Dabei handelt es sich um die Gesamtsystemanforderung, die auf Black-Box-Tests basiert und alle Komponenten des Systems abdecken sollte. Zu den Objekten gehören nicht nur die zu testende Software, sondern auch die Hardware, von der die Software abhängt, Peripheriegeräte und sogar einige Daten, einige unterstützende Software und deren Schnittstellen.
Beim Systemtest handelt es sich um eine integrierte Testsoftware, die als Teil des Computersystems mit anderen Teilen des Systems kombiniert wird, um eine Reihe strenger und effektiver Tests in der tatsächlichen Betriebsumgebung des Computersystems durchzuführen, um potenzielle Probleme mit der Software zu identifizieren und sicherzustellen den normalen Betrieb des Systems.
Der Zweck des Systemtests besteht darin, zu überprüfen, ob das endgültige Softwaresystem den Benutzeranforderungen entspricht.
Zu den Hauptinhalten gehören:
(1) Funktionstest. Das heißt, die Funktion des Testsoftwaresystems entspricht den Anforderungen des Dokuments, beispielsweise der „ Produktanforderungsspezifikation“ . Da Korrektheit der wichtigste Qualitätsfaktor von Software ist, kommt der Funktionsprüfung eine entscheidende Bedeutung zu.
(2) Robustheitstest. Das heißt, die Fähigkeit, den normalen Betrieb eines Softwaresystems unter abnormalen Bedingungen zu testen. Robustheit hat zwei Bedeutungen: die eine ist Fehlertoleranz und die andere ist Resilienz.
6.1.1 Prüfgrundsätze
Zu den Grundprinzipien des Softwaretests gehört das umfassende Testen aus der Sicht der Produktbenutzer, das Entdecken möglichst vieler Probleme und Lücken im Systemnutzungsprozess, das Recherchieren und Analysieren sowie das Unterbreiten von Problemen und Verbesserungsvorschlägen zu fehlerhaften Aspekten des Produkts. Das detaillierte Testprinzip ist wie folgt:
(1) Der Softwaretestplan ist der Handlungsleitfaden für Softwaretests. Der eigentliche Test sollte sorgfältig und strikt umgesetzt werden, und der Testplan sollte strikt und mit hoher Durchführbarkeit umgesetzt werden, insbesondere um die Testmethode und den Testzweck festzulegen.
(2) Teststandards werden auf der Grundlage der Benutzeranforderungen festgelegt. Der Hauptzweck des Softwaretests besteht darin, die Produktkonsistenz sicherzustellen und zu überprüfen, ob das Produkt die Kundenanforderungen erfüllen kann. Daher sollten Sie während des Testprozesses immer das Problem aus Sicht des Benutzers betrachten Perspektive und entdecken Sie die Auswirkungen von Softwarefehlern und -mängeln, den schwerwiegendsten Fehlern im System, Programmen, die nicht den Benutzeranforderungen entsprechen, und Funktionsfehlern.
(3) Prüfungen dürfen nicht einfach so behandelt werden.
Insbesondere bei Systemtests und wiederholten Tests ist es sehr wahrscheinlich, dass aufgrund von Fahrlässigkeit neue Fehler entstehen, wenn der Testplan nicht strikt umgesetzt wird. Daher sollte auch der wiederholten Testphase volle Aufmerksamkeit gewidmet werden. Bei der Früherkennung gibt es viele Fehler, die meist aufgrund von Fahrlässigkeit nicht entdeckt werden.
Zweck:
(1) Stellen Sie sicher, dass Systemtestaktivitäten normal durchgeführt werden.
(2) Überprüfen Sie die Nichtübereinstimmung oder den Widerspruch zwischen Softwareprodukten und Systemanforderungen.
(3) Erstellen Sie eine vollständige Fehlerverfolgungsdatenbank für Systemtests.
(4) Stellen Sie sicher, dass relevante Gruppen und Einzelpersonen rechtzeitig über Aktivitäten und Ergebnisse von Softwaresystemtests informiert werden.
6.1.2 Testmethoden
Um das System umfassend zu testen und die Probleme und Fehler im System herauszufinden, können durch die Verwendung mehrerer Testmethoden zum gemeinsamen Testen die Vor- und Nachteile des Systemdesigns umfassender zusammengefasst werden. Folgende Testmethoden kommen zum Einsatz:
Funktionstest: Testen Sie, ob die Funktionspunkte unter jedem Funktionsmodul im System normal verwendet werden können.
Manuelles Testen: Testet hauptsächlich Eingabe, Klick und andere Funktionen;
Black-Box-Test: Überprüfen Sie nach der Eingabe, ob das Ergebnis korrekt ist.
Wiederherstellungstest: Als Systemtest konzentriert sich der Wiederherstellungstest hauptsächlich auf verschiedene Bedingungen, die zum Ausfall der Software führen, und überprüft, ob der Wiederherstellungsprozess normal implementiert werden kann. In manchen Fällen muss das System fehlertolerant sein. Darüber hinaus müssen Systemausfälle innerhalb der vorgegebenen Zeit behoben werden, da andernfalls erhebliche wirtschaftliche Verluste entstehen. Beim Wiederherstellungstest wird hauptsächlich die Fehlertoleranz des Systems überprüft. Wenn ein Systemfehler auftritt, kann der Fehler behoben und das System innerhalb eines bestimmten Zeitintervalls neu gestartet werden. Beim Wiederherstellungstest müssen zunächst verschiedene Methoden verwendet werden, um einen Systemausfall zu erzwingen, und dann wird überprüft, ob das System so schnell wie möglich wiederhergestellt werden kann. Für die automatische Wiederherstellung muss die Richtigkeit der Neuinitialisierung, der Checkpoint-Mechanismen, der Datenwiederherstellung und des Neustarts überprüft werden; für manuell eingreifende Wiederherstellungssysteme muss die durchschnittliche Reparaturzeit geschätzt und festgestellt werden, ob sie innerhalb des akzeptablen Bereichs liegt.
Sicherheitstests: Sicherheitstests werden verwendet, um den Schutzmechanismus innerhalb des Systems zu überprüfen, um illegale Eindringlinge zu verhindern. Bei Sicherheitstests versuchen Tester, in das System einzudringen und versuchen mit verschiedenen Methoden, die Verteidigungslinien zu durchbrechen. Der Standard für das Systemsicherheitsdesign besteht also darin, Wege zu finden, um den Einbruch in das System teurer zu machen. Sicherheitstests prüfen die Fähigkeit des Systems, illegale Eindringlinge zu verhindern. Während des Sicherheitstests gaben sich die Tester als illegale Eindringlinge aus und versuchten mit verschiedenen Methoden, die Verteidigungslinien zu durchbrechen. Zum Beispiel: ① versuchen Sie mit allen Mitteln, Passwörter abzufangen oder zu entschlüsseln; ② passen Sie die Software speziell an, um den Schutzmechanismus des Systems zu zerstören; ③ verursachen Sie absichtlich einen Systemausfall und versuchen Sie, während der Wiederherstellung illegal einzudringen; ④ versuchen Sie, die erforderlichen Informationen abzuleiten durch Durchsuchen nicht vertraulicher Daten usw. Theoretisch ist bei genügend Zeit und Ressourcen kein System unzugänglich. Daher besteht das Prinzip des Systemsicherheitsdesigns darin, die Kosten eines illegalen Eindringens den Wert der geschützten Informationen übersteigen zu lassen. Zu diesem Zeitpunkt gibt es für die illegalen Eindringlinge keinen Gewinn.
Stresstest: Stresstest bezieht sich auf die Implementierung eines Systems, das ungewöhnlichen Datenverkehr, ungewöhnliche Frequenzen oder Datenmengen bei normalen Ressourcen verwendet. Bei der Druckprüfung können folgende Prüfungen durchgeführt werden:
① Wenn die durchschnittliche Anzahl der Interrupts ein bis zwei pro Sekunde beträgt, ist der spezielle Testfall darauf ausgelegt, 10 Interrupts pro Sekunde zu generieren.
② Erhöhen Sie die Menge der Eingabedaten um eine Größenordnung, um zu bestimmen, wie die Eingabefunktion reagiert.
③ Im virtuellen Betriebssystem sind Testfälle erforderlich, die die maximale Menge an Speicher oder anderen Ressourcen erfordern, oder es werden übermäßig viele Festplattenspeicherdaten generiert.
Unter normalen Umständen muss das System wiederholt getestet werden. Aufgrund der begrenzten Systemzeit und -funktionen kann das System nicht perfekt sein. Daher ist es notwendig, verschiedene Testmethoden gemeinsam zu untersuchen.
Krafttest
Bei einem Festigkeitstest wird die Widerstandsfähigkeit eines Programms gegenüber abnormalen Bedingungen überprüft. Stresstests zwingen das System immer dazu, unter abnormalen Ressourcenkonfigurationen zu laufen. Beispiel: ① Wenn die normale Häufigkeit von Interrupts ein bis zwei pro Sekunde beträgt, führen Sie einen Testfall aus, der zehn Interrupts pro Sekunde generiert. ② Erhöhen Sie die Dateneingaberate quantitativ, um die Reaktionsfähigkeit der Eingabeunterfunktion zu überprüfen. ③ Das Maximum Für den Betrieb erforderlicher Speicherplatz (oder andere Ressourcen); ④ Führen Sie Testfälle aus, die zum Absturz des virtuellen Speichers des Betriebssystems oder zu starkem Jitter der Festplattendaten usw. führen können.
Leistungstest
Bei diesen Echtzeit- und eingebetteten Systemen ist der Softwareteil möglicherweise nicht in der Lage, die Leistungsanforderungen zu erfüllen, selbst wenn er die Funktionsanforderungen erfüllt. Obwohl ausgehend vom Unit-Test jeder Testschritt Leistungstests umfasst, glaubt der leitende Tester nur daran Nachdem das System wirklich integriert wurde, kann es die Leistungsanforderungen in der realen Umgebung nicht mehr erfüllen. Systemleistungstests dienen dazu, diese Aufgabe zu erfüllen und die Betriebsleistung umfassend und zuverlässig zu testen. Leistungstests werden manchmal mit Festigkeitstests kombiniert und erfordern oft die Unterstützung anderer Software und Hardware.
6.1.3 Testbedeutung und Vorsichtsmaßnahmen
Softwaretests sind ein äußerst wichtiges Glied im Softwaredesignprozess und eine wichtige Garantie für die Sicherstellung der Qualität von Software. Die Qualität der Testmethode wirkt sich direkt auf die Qualität der Software aus. Softwaretests können Fehler und Mängel erkennen und verbessern, wodurch ein effizientes und zuverlässiges System entsteht.
Software sollte aus mehreren Blickwinkeln getestet und analysiert werden, damit Fehler gefunden werden können. Es ist am besten, beim Testen Leute zu finden, die nichts mit dem Designsystem oder Analysten zu tun haben. Denn bei der Entwicklung von Software haben Entwickler ihre eigene Denkweise entwickelt und sind beim Testen immer an diese Denkweise gebunden. Es ist schwierig, Fehler zu finden, und es ist für Menschen und Analysten, die nichts mit dem Design zu tun haben, leicht, sie zu finden. Wo der Fehler liegt geschah.
Während des Programm-Debugging-Prozesses müssen Sie geduldig und vorsichtig sein. Ein kleiner Fehler führt dazu, dass die gesamte Funktion nicht realisiert werden kann und viel Zeit für die Änderung verschwendet wird. Auf folgende Aspekte sollte geachtet werden:
1> Grammatikfehler
Syntaxfehler sind Fehler, die häufig auftreten. Beispielsweise führt ein falsch geschriebener Befehl oder die Übergabe falscher Parameter an eine Funktion zu einem Fehler. Syntaxfehler können dazu führen, dass Sie nicht weiter Code schreiben können.
2> Logikfehler
Logische Fehler können oft latent und schwer zu erkennen sein. Wenn es Logikfehler gibt, die durch Tippfehler oder den Logikfluss des Programms verursacht werden, kann es zwar erfolgreich ausgeführt werden, aber die erzeugten Ergebnisse sind falsch. Wenn beispielsweise ein Größer-als-Zeichen verwendet wird, anstatt Werte zu vergleichen, obwohl ein Kleiner-als-Zeichen verwendet werden sollte, werden falsche Ergebnisse zurückgegeben.
3> Laufzeitfehler
Laufzeitfehler werden dadurch verursacht, dass Anweisungen versuchen, während der Ausführung unmögliche Aktionen auszuführen. Laufzeitfehler müssen korrigiert werden, um die Zuverlässigkeit des Softwarebetriebs sicherzustellen.
Während des Entwicklungsprozesses dieses Spiels wurden verschiedene wirksame Maßnahmen zum Testen eingesetzt, um die Softwarequalität sicherzustellen. Das Spiel wurde auf Grenzrotation, Blockumdrehen und grenzüberschreitende Tests getestet, was die Softwarequalität und Fehlerraten erheblich sicherstellte. Allerdings können noch andere Fehler und Defekte im System vorhanden sein. Daher muss das Spiel wiederholt laufende Tests durchlaufen, um Fehler so weit wie möglich zu minimieren.
6.2 Testen von Spielcodes und Algorithmen
1> Beim Schreiben der Methode get () ist ein Rückgabewert erforderlich, das Programm enthält jedoch keine Rückgabeanweisung, was beim Kompilieren des Programms zu einem Fehler führt. Die Lösung besteht darin, der Methode eine Return-Anweisung hinzuzufügen und den entsprechenden Inhalt zurückzugeben.
2> Wenn Sie eine Zufallsfunktion zum Generieren von Blöcken verwenden, werden keine Parameter an jeden Block übergeben und die Kompilierung kann nicht erfolgreich sein. Die Lösung besteht darin, die entsprechenden Parameter entsprechend der Konstruktion jedes Blocks zu übergeben.
3> Initialisieren Sie beim Schreiben der Standardposition jedes Quadrats des T-förmigen Quadrats die Variable i, die die Position des Quadrats steuert, auf 0. Das Ergebnis der Operation ist, dass das T-förmige Quadrat standardmäßig zu einem vertikalen Quadrat wird. Die Lösung besteht darin, den Initialisierungswert der Variablen i auf 1 zu ändern, um den beabsichtigten Effekt zu erzielen.
4> Beim Ausführen des Programms handelt es sich bei den statistischen Ergebnissen nur um die Ergebnisse, nachdem jede vollständige Zeile eliminiert wurde. Die vorherigen Ergebnisse werden überschrieben und es erfolgt keine Akkumulation. Die Lösung besteht darin, „score=" im Programm in „score+=" zu ändern, damit die Punkte akkumuliert werden können.
5> Die Fehler im Algorithmusprozess konzentrieren sich hauptsächlich darauf, wie Blockaden erkannt und beseitigt werden, wie die Anhäufung von Punktzahlen nach Abschluss des Levels verarbeitet wird und ob ein Upgrade durchgeführt werden soll. Diese Aspekte wurden schließlich nach Diskussionen mit Klassenkameraden und Referenzmaterialien behoben.
6.3 Funktionstest der Menüoptionen der Spieloberfläche
1> Menütest „Spiel“.
Tabelle 6.1 Testfall für das Spielmenü
| Testfallnummer |
Name des Testprojekts |
Testausführungsschritte |
Ausgabe |
Testergebnisse |
| 01 |
Test der Schaltfläche „Start“. |
Klicken Sie auf „Spiel“ → „Start“ |
Spiel zurückgesetzt |
Erfolg |
| 02 |
Tastentest „Spiel beenden“. |
Klicken Sie auf „Spiel“ → „Spiel beenden“ |
Spiel vorbei |
Erfolg |
| 03 |
„Grundlegende“ Tastenprüfung |
Klicken Sie auf „Spiel“ → „Grundlegend“. |
Als Spielstufe ist Anfänger gewählt |
Erfolg |
| 04 |
Tastentest „Mittelstufe“. |
Klicken Sie auf „Spiel“ → „Mittel“ |
Das Spielniveau ist als Mittelstufe ausgewählt |
Erfolg |
| 05 |
Tastentest „Erweitert“. |
Klicken Sie auf „Spiel“ → „Erweitert“ |
Als Spielstufe ist „Erweitert“ ausgewählt |
Erfolg |
| 06 |
Schaltflächentest „Benutzerdefiniert“. |
Schaltflächentest „Benutzerdefiniert“. |
Es erscheint ein Dialogfeld, in dem Sie benutzerdefinierte Informationen ändern können |
Erfolg |
| 07 |
Schiebereglertest „Fallgeschwindigkeit“. |
Klicken Sie auf „Spiel“ → „Anpassen“ → „Fallgeschwindigkeit“. |
Ziehen Sie den Schieberegler, um die Fallgeschwindigkeit des Blocks zu ändern |
Erfolg |
| 08 |
Test der Optionsschaltfläche „Blockform“. |
Klicken Sie auf „Spiel“ → „Anpassen“ → Optionsfeld „Blockform“. |
Sie können die Blockform zwischen „Einfach“, „Mittel“ und „Erweitert“ wählen, um die Form des Blocks zu ändern. |
Erfolg |
| 09 |
Auswahlbox-Test „Ob die Box automatisch hochfährt“. |
Klicken Sie auf „Spiel“ → „Anpassen“ → Auswahlfeld „Ob der Block automatisch angehoben wird“. |
Sie können die kleinen Quadrate ankreuzen. Wenn Sie sie ankreuzen, werden die Quadrate automatisch angehoben. Wenn Sie sie nicht ankreuzen, werden die Quadrate nicht automatisch angehoben. |
Erfolg |
| 10 |
Auswahlfeldtest „Ob während des Spiels Ton abgespielt werden soll“. |
Klicken Sie auf „Spiel“ → „Anpassen“ → Auswahlfeld „Ob während des Spiels Sounds abgespielt werden sollen“. |
Sie können das kleine Kontrollkästchen aktivieren. Wenn es aktiviert ist, wird der Ton während des Spiels abgespielt. Wenn es nicht aktiviert ist, wird der Ton während des Spiels nicht abgespielt. |
Erfolg |
| 11 |
Auswahlfeld „Hintergrund ändern“. |
Klicken Sie auf „Spiel“ → „Anpassen“ → Auswahlfeld „Ob während des Spiels Sounds abgespielt werden sollen“. |
Sie können das kleine Quadrat überprüfen. Wenn Sie es auswählen, wird das Hintergrundbild des Spiels geändert. Wenn Sie es deaktivieren, wird das Hintergrundbild des Spiels nicht geändert. |
Erfolg |
| 12 |
Testen der Schaltflächen „OK“ und „Abbrechen“. |
Klicken Sie auf die Schaltfläche „Spiel“ → „Anpassen“ → „OK“ oder „Abbrechen“. |
Klicken Sie auf „OK“, um die geänderten Einstellungen zu speichern und das Dialogfeld zu schließen. Klicken Sie auf „Abbrechen“, um das Dialogfeld zu verlassen, ohne die Einstellungen zu ändern. |
Erfolg |
| 13 |
Tastentest „Blockfarbe“. |
Klicken Sie auf „Spiel“ → „Blockfarbe“. |
Es öffnet sich ein Dialogfeld, in dem Sie die Blockfarbe, HSB, RGB und andere benutzerdefinierte Informationen ändern können. |
Erfolg |
| 14 |
Test der Schaltfläche „Beenden“. |
Klicken Sie auf „Spiel“ → „Beenden“ |
Beenden Sie das Spiel und schließen Sie das Hauptfenster der Benutzeroberfläche |
Erfolg |
2> Menütest „Hilfe“.
Tabelle 6.2 Testfall im Menü „Hilfe“.
| Testfallnummer |
Name des Testprojekts |
Testausführungsschritte |
Ausgabe |
Testergebnisse |
| 15 |
Test der Schaltfläche „Info“. |
Klicken Sie auf „Hilfe“ → „Info“. |
Es erscheint ein Dialogfeld, in dem Sie zur Spielversion und anderen Informationen aufgefordert werden. |
Erfolg |
6.4 Funktionstest wichtiger Ereignisse
Tabelle 6.3 Testfälle für wichtige Ereignisfunktionen
| Testfallnummer |
Name des Testprojekts |
Testausführungsschritte |
Ausgabe |
Testergebnisse |
| 16 |
Blockbewegungstest |
Klicken Sie während des Spiels auf „Links, rechts, unten“. |
Blöcke bewegen sich normal und bewegen sich nicht außerhalb der Grenzen |
Erfolg |
| 17 |
Blockrotationstest |
Klicken Sie während des Spiels auf die Richtungstaste „nach oben“. |
Blöcke können ohne Grenzen oder Hindernisse umgedreht werden. |
Erfolg |
6.5 Blockstapel- und Eliminierungsfunktionstest
Tabelle 6.4 Testfälle für Blockstapelung und Eliminierung von Funktionen
| Testfallnummer |
Name des Testprojekts |
Testausführungsschritte |
Ausgabe |
Testergebnisse |
| 18 |
Blockstapeltest |
Wenn der Block zu Boden fällt oder mit einem Hindernis in Kontakt kommt |
Die Blöcke werden unten erfolgreich gestapelt |
Erfolg |
| 19 |
Blockeliminationstest |
Wenn eine vollständige Reihe auftritt |
Alle vollen Reihen werden eliminiert und die Blöcke werden nacheinander nach unten verschoben. |
Erfolg |
| 20 |
Game Over-Test |
Wenn der Bildschirm voll ist |
Es öffnet sich ein Sitzungsfenster mit der Meldung „Game Over“ |
Erfolg |
6.6 Testergebnisse
Nach mehreren Testmethoden zum Testen verschiedener Aspekte und Funktionen des Systems zeigen die Testergebnisse, dass das System im Wesentlichen die gesamten Designanforderungen erfüllt und die erwarteten Funktionen im Wesentlichen erfüllt sind. Das System kann grundsätzlich die Anforderungen zu Beginn des Entwurfs und der Entwicklung erfüllen und der Test ist abgeschlossen.Die Gesamtfunktion ist jedoch nicht leistungsstark genug und die Innovation ist etwas minderwertig. Als erste Entwicklungsversion muss das Spiel in vielen Aspekten wie Funktionen und Interface-Design noch weiter verbessert werden.
abschließend
Bevor ich mein Abschlussprojekt machte, befand sich meine Java-bezogene Entwicklung nur auf der Ebene theoretischer Kenntnisse. Durch dieses Abschlussprojekt wurde mir das Prinzip klar: „Was man auf dem Papier lernt, ist letztendlich oberflächlich, aber man muss es üben, wenn man es weiß.“ " Der Mangel an tatsächlicher Erfahrung in der Softwareentwicklung ist die Schlussfolgerung, die ich für mich selbst gezogen habe. Durch dieses Abschlussprojekt habe ich alle Entwicklungsaufgaben des Tetris-Spiels abgeschlossen. Während des gesamten Entwicklungsprozesses bin ich auf viele Probleme gestoßen, z. B. beim Zeichnen und Verformen von Blöcken, bei der Thread-Erstellung, bei der Synchronisationssteuerung, bei der Beurteilung ganzer Zeilen, bei der Verarbeitung von Eliminierungszeilen und bei der Implementierung der Datensatzfunktion mit der höchsten Punktzahl, aber am Ende habe ich sie gelöst Sie können sie nacheinander bearbeiten. Einige der wichtigeren Punkte sind wie folgt zusammengefasst:
Um mich mit den zugehörigen Funktionen und dem Design von Tetris vertraut zu machen, lade ich zunächst oft die eigenständige Version des Tetris-Spiels von den großen Spiele-Download-Websites herunter und studiere die Implementierung von Funktionen und das Design der Benutzeroberfläche, denke darüber nach und konsultiere sie Die Daten werden analysiert und nach und nach entworfen. Nach wiederholten Änderungen und Diskussionen wurde die Entwicklung des gesamten Spiels abgeschlossen.
Zweitens übernehme ich im Spieldesignprozess das Designmuster vom Groben bis zum Feinen und das Testprinzip vom Kleinen zum Großen. Entwerfen Sie zunächst das Spiel-Framework und testen Sie es Schicht für Schicht. Fügen Sie dann spezifischen Implementierungscode hinzu und führen Sie nach und nach detailliertere Tests durch. Während des Entwurfsprozesses stoße ich häufig auf Probleme. Durch wiederholtes Nachdenken und Testen finde ich meine Fehler heraus und korrigiere sie. Anschließend gehe ich zum nächsten Schritt über, um sicherzustellen, dass nichts schief geht, und versuche mein Bestes, um den endgültigen Debugging-Arbeitsaufwand zu reduzieren.
Drittens kann die Abschlussdesignbranche als ein Prozess des ständigen Lernens neuer Dinge betrachtet werden. Vom Unverständnis des Designs am Anfang bis zum erfolgreichen Abschluss am Ende erkenne ich die Bedeutung kontinuierlichen Lernens in der Praxis, was für mich wichtig ist in Zukunft in den Job einsteigen. Bildungsbedeutung. Durch die Erstellung meiner Abschlussarbeit erlangte ich ein tieferes Verständnis des Java-Kurses, wodurch auch ein gewisser Grundstein für meine zukünftige Berufstätigkeit gelegt wurde.
Das Abschlussprojekt ist der letzte Schritt in unserer Lernphase als Studierende. Es ist eine umfassende Anwendung von Grundwissen und Berufswissen. Es ist ein umfassender Umlern- und anschließender Verbesserungsprozess. Der Prozess der Lernfähigkeit und der unabhängigen Denk- und Arbeitsfähigkeit der Studierenden ist auch eine Ausbildung und ein Abschluss. Das Designniveau spiegelt auch das umfassende Niveau der Universitätsausbildung wider, daher legt die Schule großen Wert auf die Abschlussgestaltung und stärkt die Anleitung der Abschlussgestaltungsarbeit und der Mobilisierungserziehung. Im Verlauf des Universitätsstudiums stellt die Abschlussarbeit einen wichtigen Teil unserer sozialen Teilhabe an der praktischen Arbeit dar. Sie dient auch unserer Lernfähigkeit und der Lösung von Lebensproblemen und stellt eine Transformation des Schullebens und des sozialen Lebens dar. Nach Abschluss meiner Abschlussarbeit habe ich versucht, Forschungsdesign und praktische Arbeit zu integrieren. Dies trägt eher dazu bei, dass wir unsere Fähigkeiten stärken.
Nach einer Zeit harter Arbeit und mit der Hilfe einiger Klassenkameraden und Lehrer habe ich endlich mein Abschlussprojekt abgeschlossen, was eine wichtige Aufgabe ist. Wenn wir auf unseren Designprozess zurückblicken, können wir sagen, dass Schwierigkeit und Leichtigkeit nebeneinander bestehen. Dabei ist es für mich tatsächlich eine große Herausforderung, das an der Universität erlernte Wissen zu integrieren, und es ist auch ein Test für universitäres Wissen.
Während des Abschlussprojekts sind wir auf viele Schwierigkeiten gestoßen, und viele davon waren Probleme, denen wir noch nie zuvor begegnet waren. Wenn wir es nicht selbst gemacht hätten, wäre es möglicherweise schwierig, das Wissen zu finden, das uns bis zu einem gewissen Grad fehlt. Für uns Das Problem finden. Um das Problem zu lösen, ist dies am praktischsten. Bei Problemen, die man selbst nur schwer lösen kann, können diese Probleme mit Hilfe von Lehrern und Schülern gelöst und gleichzeitig einige Informationen eingeholt werden, sodass das Abschlussprojekt erfolgreich abgeschlossen wird. Es versteht sich, dass das Wissen über dieses Projekt immer noch sehr tiefgreifend ist, daher müssen wir es nicht nur jetzt, sondern auch in Zukunft weiter erforschen.
Die Kombination von Theorie und Praxis umfasst nicht nur das Wissen über die Teilnahme am Unterricht, sondern auch die Kombination von Kompetenztraining und Anleitung, wie Schüler gesellschaftlich relevante Dinge verstehen und ansprechen können. Abschlussarbeiten von Studierenden können unter Anleitung berufstheoretischer Kenntnisse einige praktische Probleme auf vielfältige Weise lösen. Während des Designprozesses können Studierende theoretisches Wissen für die Praxis nutzen, nicht nur um ihr Verständnis für professionelles theoretisches Wissen zu vertiefen, sondern auch um das theoretische Wissen in diesem Buch zu bereichern und weiterzuentwickeln und es in Erfahrungen und Fähigkeiten auf höherem Niveau umzuwandeln. Aufgrund des bestehenden Lehrmodells besteht eine gravierende Trennung zwischen theoretischen Kenntnissen und Fertigkeiten und der Produktionspraxis. Studierende sind nicht in der Lage, Wissen außerhalb des Klassenzimmers zu erlernen. Praktische Produktionsprobleme sind oft irrelevant für das Lernen und können nicht effektiv angewendet werden. Durch eine sinnvolle Themenauswahl werden die Studierenden dazu angeleitet, Wissens- und Fähigkeitssysteme bewusst zum Analysieren und Denken zu nutzen und zur organischen Integration von theoretischem Wissen und Praxis beizutragen.
Die Gesellschaft verändert sich ständig. Gegenwärtig verändert und entwickelt sich die Gesellschaft, und die Anforderungen an Talente werden immer höher. Nutzen Sie die Perspektive, um Probleme zu betrachten, zu lernen, innovativ zu sein und sich an die Anforderungen der gesellschaftlichen Entwicklung anzupassen. Treten Sie außerhalb der Schule in die Gesellschaft ein, nutzen Sie die Chancen von heute und gestalten Sie die Zukunft. Der Einfluss des Lehrers und das Wissen des Professors ermöglichten es mir, viele Wahrheiten zu verstehen und zukünftigen Herausforderungen mit einem gewissen Innovationsgeist zu begegnen.
Kurz gesagt, ich habe das Gefühl, dass ich durch dieses Abschlussprojekt nicht nur einige berufliche Kenntnisse besser kennengelernt habe als zuvor, sondern auch meine praktischen Fähigkeiten unter Beweis gestellt habe, und ich habe das Gefühl, dass ich viel gewonnen habe. Gleichzeitig werden Sie auch ein kleines Erfolgserlebnis verspüren, weil Sie bei dieser Aufgabe hart gearbeitet haben. Auch in der zukünftigen tatsächlichen Arbeit sollten wir hart arbeiten und nicht das Beste, sondern nur das Bessere anstreben! Außerdem möchte ich meinen Lehrern und Klassenkameraden meinen aufrichtigen Dank für ihre Hilfe bei diesem Abschlussprojektprozess aussprechen!
Das Programm entspricht grundsätzlich sowohl technisch als auch funktional den Bedürfnissen der Nutzer. Aufgrund des ursprünglichen Designs sind die Funktionen jedoch nicht perfekt genug und die Designdetails noch unzureichend.
这次的毕业设计，我受益匪浅，让我的思维方式更加缜密，能多个角度的看待、处理问题；知道遇到问题该如何去分析问题、解决问题。相信这些都会让我在以后的工作中受益无穷的。
参考文献
[1] 李刚，疯狂Java讲义（第3版），北京：电子工业大学出版社，2014.7
[2] 明日科技，Java从入门到精通（第4版），北京：清华大学出版社，2016（2017.1重印）
[3] 荣钦科技 Java2游戏设计.清华大学出版社,2004.
[4] 高凌琴 陈青华.俄罗斯方块游戏关键技术探讨[J].信息技术与信息化讨,2008年第二期
[5] 艾克尔.Java编程思想[M].北京：机械工业出版社,2005.2
[6] (美) Paul Hyde.Java线程编程[M].北京：人们邮电出版社，2003
[7] Martin dejode.Symbian OS J2ME[M].北京：人民邮电出版社，2005.10
[8] 朱福喜. Java程序设计技巧与开发实例[M].北京:人民邮电出版社，2004.2
[9] 袁海燕 王文涛.Java实用程序设计100例[M].北京：人民邮电出版社，2005.2：51～96
[10] 黄复贤.俄罗斯方块游戏的敏捷设计与开发[J]. 电脑编程技巧与维护，2005.4
[11] (美)Bill Venners.深入Java虚拟机[M].北京：机械工业出版社，2003.9.63～98
[12] 闻怡洋.J2ME MIDP 1.0/2.0无线设备编程指南[M].北京:北京大学出版社,2004.5：393～420
[13]赵东跃.俄罗斯方块编程[J].电脑编程技巧与维护,1998年第六期
[14]殷兆麟.Java网络编程基础[M].北京：北方交通大学出版社，2004
[15] (美)John Zukowski.Java 2 从入门到精通[M].北京：电子工业出版社，1999
[16] 宋波.Java应用开发教程[M].北京：电子工业出版社，2002
[17] 托普雷.J2ME技术手册[M].北京：中国电力出版社,2004.6：259～312
附录A 外文原文
The psychology of Tetris
Shapes fall from the sky, all you have to do is to control how they fall and fit within each other. A simple premise, but add an annoyingly addictive electronica soundtrack (based on a Russian folk tune called Korobeiniki, apparently) and you have a revolution in entertainment.
Since Tetris was launched on the world in the 1980s, millions of hours have been lost through playing this simple game. Since then, we’ve seen games consoles grow in power, and with it the appearance of everything from Call of Duty to World of Warcraft. Yet block and puzzle games like Tetris still have a special place in our hearts. Why are they are so compelling?
The writer Jeffrey Goldsmith was so obsessed with Tetris that he wrote a famous article asking if the game’s creator Alexey Pajitnov had invented “a pharmatronic?” – a video game with the potency of an addictive drug. Some people say that after playing the game for hours they see falling blocks in their dreams or buildings move together in the street – a phenomenon known as the Tetris Effect. Such is its mental pull, there’s even been the suggestion that the game might be able to prevent flashbacks in people with PTSD.
I had my own Tetris phase, when I was a teenager, and spent more hours than I should have trying to align the falling blocks in rows. Recently, I started thinking about why games like Tetris are so compelling. My conclusion? It’s to do with a deep-seated psychological drive to tidy up.
Many human games are basically ritualised tidying up. Snooker, or pool if you are non-British, is a good example. The first person makes a mess (the break) and then the players take turns in potting the balls into the pockets, in a vary particular order. Tetris adds a computer-powered engine to this basic scenario – not only must the player tidy up, but the computer keeps throwing extra blocks from the sky to add to the mess. It looks like a perfect example of a pointless exercise – a game that doesn't teach us anything useful, has no wider social or physical purpose, but which weirdly keeps us interested.
There's a textbook psychological phenomenon called theZeigarnik Effect, named after Russian psychologist Bluma Zeigarnik. In the 1930s, Zeigarnik was in a busy cafe and heard that the waiters had fantastic memories for orders – but only up until the orders had been delivered. They could remember the requests of a party of 12, but once the food and drink had hit the table they forgot about it instantly, and were unable to recall what had been so solid moments before. Zeigarnik gave her name to the whole class of problems where incomplete tasks stick in memory.
The Zeigarnik Effect is also part of the reason why quiz shows are so compelling. You might not care about the year the British Broadcasting Corporation was founded or the percentage of the world's countries that have at least one McDonald's restaurant, but once someone has asked the question it becomes strangely irritating not to know the answer (1927 and 61%, by the way). The questions stick in the mind, unfinished until it is completed by the answer.
Game theory：
Tetris holds our attention by continually creating unfinished tasks. Each action in the game allows us to solve part of the puzzle, filling up a row or rows completely so that they disappear, but is also just as likely to create new, unfinished work. A chain of these partial-solutions and newly triggered unsolved tasks can easily stretch to hours, each moment full of the same kind of satisfaction as scratching an itch.
The other reason why Tetris works so well is that each unfinished task only appears at the same time as its potential solution – those blocks continuously fall from the sky, each one a problem and a potential solution. Tetris is a simple visual world, and solutions can immediately be tried out using the five control keys (move left, move right, rotate left, rotate right and drop – of course). Studies of Tetris players show that people prefer to rotate the blocks to see if they'll fit, rather than think about if they'll fit. Either method would work, of course, but Tetris creates a world where action is quicker than thought – and this is part of the key to why it is so absorbing. Unlike so much of life, Tetris makes an immediate connection between our insight into how we might solve a problem and the means to begin acting on it.
The Zeigarnik Effect describes a phenomenon, but it doesn't really give any reason for why it happens. This is a common trick of psychologists, to pretend they solved a riddle of the human mind by giving it a name, when all they've done is invented an agreed upon name for the mystery rather than solved it. A plausible explanation for the existence of the Effect is that the mind is designed to reorganise around the pursuit of goals. If those goals are met, then the mind turns to something else.
Trivia takes advantage of this goal orientation by frustrating us until it is satisfied. Tetris goes one step further, and creates a continual chain of frustration and satisfaction of goals. Like a clever parasite, Tetris takes advantage of the mind's basic pleasure in getting things done and uses it against us. We can go along with this, enjoying the short-term thrills in tidying up those blocks, even while a wiser, more reflective, part of us knows that the game is basically purposeless. But then all good games are, right?
If you would like to comment on this article or anything else you have seen on Future, head over to our Facebook page or message us on Twitter.
附录B 外文翻译
俄罗斯方块的心理效应
这一人们喜闻乐见的游戏成功的秘诀在于抓住了我们重复排列与使用的心理乐趣。
几何图形从屏幕上方缓缓降落，你要做的就是控制其降落方式并与其他图形排列消除。游戏的初衷很简单，但加上了令人上瘾的背景电子音乐后（据说来自俄罗斯民谣Korobeiniki）人们的娱乐生活发生了翻天覆地的变化。
自从1986年俄罗斯方块问世后，这一简单的游戏耗去了玩家数百万个小时。从那时起，从使命召唤到魔兽世界，游戏操纵平台的外观和性能都在茁壮发展。但像俄罗斯方块这样的方块益智类游戏始终占据了我们心中的一席之地。为何它们如此经久不衰呢？
作家杰弗里·戈德史密斯是沉迷于俄罗斯方块不能自拔，乃至于他写了一篇著名的文章，文中提到俄罗斯方块的发明者阿里克谢·帕吉诺特夫是否发明了一种“瘾药”——让人可以玩出瘾。一些人说自己连玩了几小时俄罗斯方块后连梦里都会出现降落的方块，还有看街上的大楼都在移动——这是一种名为“俄罗斯效应”的现象。这是游戏产生的心理推动作用，还有建议称那些患有创伤后精神紧张性障碍的人们需要预防游戏产生的幻觉重现。
当我十几岁的时候也有过一段俄罗斯方块沉迷期，我花了很多时间在方块的排列组合上。最近，我开始反思为什么俄罗斯方块这类游戏能够长青。说说我的结论吧，植根人们心中的心理驱使作用是整理这些方块的关键。
很多游戏的宗旨大体都是整理消除。落袋台球(snooker)就是典型的例子（对于非英国人来说叫做pool）。第一个人把球打乱后，其他人依照不同规则轮流将球射入落袋里。俄罗斯方块在这一基本框架中加入了电脑控制的成分——不光是玩家要整理方块，电脑还会不断从上方扔下额外的方块来制造凌乱。游戏看起来就是整一个漫无目的的过程，完全没有寓教于乐的成分在内，也没有深远的社交或是心理意义，但是我们却意外地为此着迷。
Es gibt ein typisches psychologisches Phänomen namens „Zaigarnik-Effekt“, benannt nach der russischen Psychologin Bruma Zegarnik. In den 1830er Jahren entdeckte Zeigarnik in einem belebten Café, dass die Kellner erstaunliche Erinnerungen hatten – allerdings nur bis zur Lieferung des Essens. Sie können sich daran erinnern, was an einem Tisch mit 12 Personen bestellt wurde, aber sobald das Essen und die Getränke serviert sind, vergessen sie alles und können sich nicht mehr an ihre zuvor guten Erinnerungen erinnern. Zeigarnik benannte dieses Phänomen, unerledigte Aufgaben im Gedächtnis zu behalten, nach sich selbst.
Der Zeigarnik-Effekt ist einer der Gründe, warum Geheimdienstsendungen so beliebt sind. Es ist Ihnen vielleicht egal, in welchem Jahr die BBC gegründet wurde oder wie viele Länder der Welt mindestens einen McDonald's haben, aber sobald eine Frage wie diese auftaucht, werden Sie sich unwohl fühlen, wenn Sie die Antwort nicht kennen (übrigens, die Antwort ist 1927 und 61 %). Fragen bleiben in Ihrem Kopf, bis sie beantwortet werden.
Spielprinzip
Tetris hält unsere Nerven im Griff, indem es ständig Aufgaben erstellt. Jeder Link im Spiel führt uns dazu, ein Rätsel zu lösen. Nach dem Aufstellen oder Vervollständigen einer Spalte verschwinden die Grafiken, aber es tauchen ständig neue auf und der Zyklus beginnt von vorne. Teilweise gelöste und neu gebildete Aufgabenketten sind ein sehr praktischer Zeitvertreib und immer wiederkehrende Gefühle von Zufriedenheit und Angst füllen jeden Moment.
Ein weiterer Grund für die Beliebtheit von Tetris liegt darin, dass den zu erledigenden Aufgaben mögliche Lösungen gegenübergestellt werden – jeder der nach und nach entstehenden Blöcke hat seine eigene Art der Platzierung. Tetris ist eine einfache visuelle Welt, in der durch Betätigen von fünf Tasten (links, rechts, links abbiegen, rechts abbiegen und landen, natürlich) schnell zu Lösungen gelangt werden kann. Studien an Tetris-Spielern zeigen, dass Menschen es im Allgemeinen vorziehen, die Blöcke zu drehen, um zu sehen, ob sie zusammenpassen, anstatt darüber nachzudenken, während sie den Blöcken beim Fallen zusehen. Natürlich sind beide Methoden möglich, aber in der Welt von Tetris steht immer die Action im Vordergrund – und das macht den Reiz aus. Anders als im Leben verbindet Tetris direkt das, was wir sehen und denken, wenn wir Probleme lösen, und wir können sofort Maßnahmen gegen das Problem ergreifen.
Der Zeigarnik-Effekt ist eine Beschreibung eines Phänomens, kann jedoch nicht dessen Ursache und Wirkung erklären. Dies ist ein gängiger Trick von Psychologen. Es scheint, dass sie die Geheimnisse der Menschen gelöst haben, indem sie ihnen Namen gegeben haben. Tatsächlich haben sie ihnen nur gierig Namen nach sich selbst gegeben und das Problem überhaupt nicht gelöst. Eine vernünftige Erklärung für diese Realität ist, dass sich die Gehirnschaltkreise im Prozess der Zielerreichung neu organisieren. Ist dieses Ziel erreicht, schweifen die Gedanken zu anderen Dingen ab.
Puzzlespiele nutzen das Prinzip der psychologischen Leistung aus, um uns so lange zu frustrieren, bis wir zufrieden sind. Tetris geht noch einen Schritt weiter, indem es eine kontinuierliche Kette zwischen Misserfolg und Erfolg schafft. Wie ein cleverer Parasit nutzt Tetris das psychologische Vergnügen der Menschen aus, Spiele zu vervollständigen und wiederzuverwenden. Während wir spielen, schwelgen wir kurz in dem Spaß, die Blöcke anzuordnen, auch wenn der rationale und reife Teil unserer Persönlichkeit versteht, dass dies im Grunde ein bedeutungsloses Spiel ist. Aber ist das nicht bei allen lustigen Spielen so, oder?
https://download.csdn.net/download/dwf1354046363/87813602