Conception et implémentation du jeu Tetris basé sur Java
Tetris est un jeu populaire dans le monde entier et a été populaire sur les ordinateurs, les téléphones mobiles et les consoles de jeu portables depuis le début jusqu'à nos jours. C'est un jeu classique simple avec des règles de jeu simples, mais il ne manque pas de plaisir. facile à apprendre et applicable. La portée est large et bien connue. Les règles de base simples du jeu Tetris sont que 7 graphiques réguliers différents composés de petits carrés tombent de l'écran les uns après les autres. Le joueur se déplace pour former une barre horizontale complète lorsqu'elle tombe, puis disparaît. Le joueur marque des points et le jeu Le niveau augmente. Le jeu se termine lorsque les graphiques restants s'empilent jusqu'en haut de l'écran.
Tetris était à l'origine un jeu occasionnel développé par le Russe Alexei Pajitnov en 1984. Il créait autrefois une valeur commerciale sans précédent et influençait le développement et la chaîne industrielle d'une génération de jeux occasionnels. Avec le développement continu et les changements de l'ère de l'information et de la science et de la technologie, les ordinateurs ont été popularisés dans la vie de chacun. Dans la vie professionnelle bien remplie, ce type de jeux occasionnels apporte une certaine détente aux gens.
Cet article décrit et analyse en détail les idées de base et quelques règles de jeu de base de la mise en œuvre traditionnelle classique de Tetris. Sur cette base, il développe davantage le modèle innovant et créatif de Tetris et développe un jeu d'accompagnement basé sur le jeu classique. augmente et le niveau augmente, la difficulté augmente. Des modules capables de contrôler le changement de couleur des blocs ont été développés de manière créative et des modules de son et de musique de jeu ont été ajoutés. Cet article fournit un processus de mise en œuvre spécifique, une description détaillée et du code source pour les fonctions ci-dessus.
Cet article explique le développement et l'historique du développement du jeu Tetris, l'importance du développement de ce jeu, l'environnement de développement et les connaissances pertinentes en matière de développement de logiciels et de programmation Java basées sur l'ingénierie logicielle, ainsi que l'analyse des exigences du programme, la conception des grandes lignes, conception et mise en œuvre détaillées, ainsi que débogage. Une série de descriptions est donnée pour l'opération.
La conception de ce programme est basée sur le système Microsoft Windows 7, utilisant Java comme langage de développement, ainsi que la conception et la mise en œuvre du jeu sur la plateforme de développement Eclipse.
Mots clés : conception de jeux ; Tetris ; génie logiciel ; Java ; Eclipse.
Table des matières
Conception et réalisation du jeu Tetris basé sur Java ........................ I
Résumé................................................. ..................... JE
Basé sur la conception et l'implémentation du jeu Java Tetris .............. II
Abstrait ................................................. .................II
1. Introduction................................................ ..................... 1
1.3 État actuel de la recherche sur le jeu Tetris.................................. 2
1.3.2 Revue de la littérature.................................................. ... ........ 3
2.1 Introduction à JAVA............................................................ .............. 4
2.4.1 Plateforme matérielle :............................................ .... ....... 6
2.4.2 Plateforme logicielle :............................................ .... ....... 6
3 Analyse du système.................................................. . ........................ 7
3.1 Analyse de faisabilité.................................................. . ........... 7
3.1.1 Analyse de faisabilité économique.................................. .... 8
3.1.2 Analyse de faisabilité technique.................................................. .... .... 8
3.1.3 Analyse de faisabilité sociale.................................................. .... .... 8
3.2 Analyse des besoins............................................................ ............. 8
3.2.1 Exigences fonctionnelles.................................................. ..... .. 9
3.2.2 Exigences non fonctionnelles.................................................. ... ... 9
3.2.3 Contrôle des interfaces.................................................. ... ....... 9
4.1.1 Processus de base du traitement commercial manuel.................................. 11
4.1.2 Modules fonctionnels du processus de base.................................. 12
5.2 Module d'affichage toile et boîte.................................. 16
5.2.2 Aperçu de la conception du module de bloc.................................. ..... 19
5.3 Module du panneau de commande............................................ .. ........ 25
5.3.1 Conception du module de la barre de menus.................................. ....... .. 25
5.3.2 Conception des boutons du panneau de commande.................................. ..... 26
6.1 Aperçu des tests............................................................ ........29
6.1.1 Principes des tests........................................................ ... ...... 29
6.1.2 Méthode d'essai.................................................. ... ...... 30
6.1.3 Signification du test et précautions.................. 31
6.3 Test fonctionnel des options de menu dans l'interface de jeu................................. 32
6.4 Test fonctionnel des événements clés.................................................. .... 34
6.5 Test de la fonction d'empilement et d'élimination de blocs.................................. 35
6.6 Résultats des tests............................................................ ............. 35
en conclusion................................................ ............. 36
les références................................................ . ............... 38
Annexe A Texte étranger original.................................................. ..... ........40
La psychologie de Tetris............................................................ 40
Les effets psychologiques de Tetris............................................ ..... 43
1. Introduction
L'introduction décrit brièvement le contexte du développement du programme, l'importance du développement, la technologie de développement requise et l'état actuel de la recherche sur le jeu Tetris au pays et à l'étranger.
1.1 Contexte et importance du développement du programme
Le jeu Tetris est un jeu populaire et durable dans le monde entier. C'est un jeu occasionnel qui peut être joué sur une série de produits tels que des ordinateurs, des téléphones mobiles, des consoles de jeux TV, des consoles de jeux portables, etc. est une sensation sans précédent et une valeur commerciale incalculable pour n'importe quel jeu. C'est un événement important dans l'histoire du développement de jeux et de logiciels.
Un jour de juin 1984, Alex Pajitnov, un mathématicien de Moscou, en Russie, a été soudainement inspiré pour concevoir ce jeu après avoir joué à un puzzle au Centre informatique scientifique de Moscou où il travaillait. Au début, il le développait uniquement sur Electronica 60 ( un ordinateur), et plus tard, il a été porté sur PC via Vadim Gerasimov, et il s'est largement répandu dans la communauté informatique de Moscou. Tetris a commencé à devenir populaire et est devenu le jeu occasionnel classique le plus vendu de l'histoire, il conserve toujours son charme car toujours. Les règles de jeu de base simples de Tetris se situent sur un terrain de jeu virtuel standard permettant de placer des petits carrés. L'unité de base est un petit carré ; il est composé de quatre petits carrés et de 7 graphiques réguliers différents (forme de champ, forme de Z, forme de Z inversé, En forme de 7, en forme de 7 inversé, en forme de T, longue barre) Il y a 28 schémas graphiques au total pour faire pivoter le bloc à 90 degrés, 180 degrés, 270 degrés, 360 degrés grâce à l'opération du joueur sur la touche supérieure, gauche et touches droite et touche bas. Pour ajuster la position en accélérant la chute, les blocs sont formés en un ou plusieurs blocs complets en bas de l'écran, puis éliminés pour laisser la place aux blocs nouvellement tombés. Chaque fois qu'un bloc complet La barre horizontale est éliminée, le niveau du joueur augmente d'un niveau. Lorsque le niveau atteint un certain niveau. Au fil du temps, la vitesse de chute s'accélère. Une fois que les blocs qui n'ont pas été éliminés atteignent le haut de l'écran, le jeu se termine.
Avec la mise à jour et le développement continus de la technologie informatique, les jeux Tetris introduisent constamment différents modes et il existe de nombreuses versions différentes pour que tout le monde puisse y jouer, car le jeu lui-même peut être simple ou complexe et peut bien entraîner les joueurs. et la capacité de réflexion logique peut également apporter un plaisir de jeu sans fin aux joueurs, elle est donc profondément appréciée par la majorité des joueurs. Lorsqu'il s'agit de développer des logiciels de jeux, la plupart des gens pensent que c'est hors de portée et magique. Avec l'innovation continue des méthodes et des outils de développement, il n'est pas hors de portée de développer soi-même quelques petits jeux. Le jeu Tetris a un statut sans précédent dans l'histoire des jeux. L'interface du jeu est simple et le code n'est pas très compliqué. Il existe également de nombreux algorithmes et conceptions pour la mise en œuvre du jeu Tetris sur Internet, et la difficulté n'est pas particulièrement haut.
Tetris est un jeu de puzzle simple. Avec son interface unique et concise et son mode de jeu extrêmement amusant, de nombreux passionnés de jeux y sont profondément impliqués et ne peuvent pas s'en sortir. Il convient à tous les âges. Dans la vie trépidante d'aujourd'hui, la pression des études et du travail sur les étudiants et les groupes de travail augmente également. Les tâches de chacun deviennent de plus en plus lourdes et il y a de moins en moins de temps libre pour se reposer, ce qui rend les gens de plus en plus urgents de quelque chose de simple. jeu occasionnel qui fait gagner du temps et dont tout le monde peut profiter. Il ne fait aucun doute que Tetris est un puzzle simple et un jeu occasionnel intéressant, et il peut être transplanté sur une série d'appareils portables tels que des ordinateurs, des téléphones mobiles, des tablettes, des consoles de jeux TV, des consoles de jeux portables, des dictionnaires électroniques, des MP4 et autres portables. dispositifs. Ce projet de recherche est très précieux tant en termes de développement technique que de signification sociale. C'est une tentative audacieuse de ma part de développer des jeux.
1.2 Aperçu de la technologie de développement
Le génie logiciel est une discipline qui étudie l'utilisation de méthodes d'ingénierie pour créer et maintenir des logiciels efficaces, pratiques et de haute qualité ; la conception comprend les langages de programmation, les bases de données, les algorithmes, les outils de développement logiciel, les plates-formes système, les modèles de conception et bien d'autres aspects ; en In Dans la société moderne, les logiciels sont utilisés dans de nombreux aspects typiques tels que le courrier électronique, les systèmes embarqués, les interfaces d'interaction homme-machine, les suites bureautiques, les systèmes d'exploitation, les éditeurs, les bases de données, les jeux, etc. ; en même temps, dans diverses industries de la société actuelle. sont des applications logicielles informatiques, notamment dans l'industrie, l'agriculture, la banque, l'aviation, les ministères, etc., qui peuvent promouvoir efficacement le développement économique et social et améliorer l'efficacité du travail et de la vie des personnes.
Le code de développement du jeu Tetris n'est relativement pas particulièrement complexe. Cet article est basé sur le langage de programmation Java et utilise des composants Swing couramment utilisés dans le langage Java. Swing est une boîte à outils d'interface utilisateur graphique (GUI) en Java. Il fait partie de la classe de base Java. Il comprend des zones de texte, des volets séparés, des boutons, des tableaux et d'autres périphériques GUI. Il est écrit en Java pur. Les développeurs peuvent utiliser un petit Une grande quantité de code pour les diverses fonctions flexibles et riches et les composants modulaires de Swing peuvent être écrits pour créer des interfaces utilisateur belles et gracieuses. Le composant Java Swing comprend les classes suivantes couramment utilisées : JFrame est un objet graphique à l'écran, qui peut effectuer des opérations de base telles que la maximisation, la réduction et la fermeture. C'est l'idée de base de la programmation Java GUI ; JPanel peut être utilisé pour l'imbrication. Les composants ayant les mêmes fonctions logiques dans le formulaire peuvent être combinés et ajoutés au formulaire JFrame. Il s'agit d'une classe de conteneur de panneaux dans Swing. L'objet JLabel est utilisé pour afficher du texte, des images ou les deux et peut définir certaines de ses propriétés ; JTextField est un composant en cours d'exécution utilisé pour modifier une seule ligne de texte ; JButton est une classe utilisée pour créer des boutons. De plus, le composant Swing en Java contient également de nombreuses classes fonctionnelles, qui peuvent facilement créer de belles interfaces graphiques.
1.3 Statut de recherche du jeu Tetris
1.3.1 Statut de recherche en Suisse et à l'étranger
Depuis le début du 21e siècle, les ordinateurs ont continué à se développer et l'industrie du sport électronique a également continué à entrer dans une phase ascendante. Le développement de logiciels de jeux est devenu de plus en plus populaire. Les logiciels de jeux, comme les drames et les films, sont un nouveau type de technologie qui devient de plus en plus populaire.Produit artistique complet. Différent du développement Web général et du développement de logiciels, le développement de logiciels de jeux informatiques nécessite non seulement que les concepteurs et les développeurs maîtrisent des compétences professionnelles en programmation et des méthodes d'ingénierie logicielle, mais nécessite également des connaissances professionnelles dans le domaine du jeu et des connaissances professionnelles en développement de jeux pour être efficace. Développer et mettre en œuvre l'interface vivante du jeu, le traitement des effets sonores et obtenir une interaction parfaite avec les joueurs, etc.
Le jeu "Tetris", développé à l'origine par l'ancien scientifique soviétique Alex Pajitnov, était un logiciel éducatif, puis a commencé à être concédé sous licence à diverses sociétés de jeux. Depuis lors, il est disponible sur toutes les principales plates-formes. Diverses versions du jeu sont apparues.
La version Game Boy de Tetris s'est vendue à 4,24 millions d'unités au Japon, ce qui en fait le jeu le plus populaire de l'histoire des jeux Game Boy. Pendant la guerre du Golfe, le jeu Tetris est devenu l’un des jeux de perte de temps les plus adaptés aux troupes américaines en première ligne.
Les principes de base de Tetris sont relativement simples pour la plupart des programmeurs, et Tetris est mathématique, dynamique et bien connu. Il est également souvent utilisé comme sujet de pratique pour la programmation de jeux.
1.3.2 Revue de la littérature
Les documents [1] et [2] visent une explication base zéro, en utilisant des exemples pour guider les lecteurs dans leur apprentissage en profondeur, en utilisant le mode d'explication des connaissances de base → technologie de base → application avancée → pratique réelle du projet pour expliquer diverses technologies et pratiques Java dans termes simples et faciles à comprendre. Du point de vue des débutants, à travers un langage facile à comprendre et des exemples colorés, il présente en détail tous les aspects de la technologie qui doivent être maîtrisés dans le développement de programmes utilisant le langage Java. Incluant : familiarité avec les outils de développement Eclipse, les bases du langage Java, les classes et les objets, les classes d'empaquetage, les classes de traitement des nombres, les interfaces, l'héritage et le polymorphisme, les fonctionnalités avancées des classes, la gestion des exceptions, la programmation Swing, les classes de collection, les entrées et sorties d'E/S, Réflexion, types énumérés et génériques, multithreading, communication réseau, opérations de base de données, composants de table Swing, composants d'arborescence Swing, autres composants Swing avancés, gestionnaires de mise en page avancés, gestion avancée des événements, dessin AWT et lecture audio, etc. Ces deux documents couvrent le langage et la technologie Java « suffisants », avec des exemples riches et un contenu détaillé. Pour les débutants et les étudiants ayant une certaine base Java, ils peuvent rapidement améliorer la technologie et les compétences de développement des étudiants. Dans la conception de ce projet, les contenus liés à la conception de l'interface graphique, aux composants et à la conception de l'interface utilisateur, au traitement des événements et aux composants de construction de fenêtres, ainsi que les connaissances de base de Swing et de sa série de composants ont tous été référencés à ces deux documents, qui m'a donné beaucoup d'inspiration.
Le document [3] explique principalement le dessin 2D ; la production d'animations de jeux ; la base du programme réseau ; l'interface de jeu améliorée ; l'intelligence artificielle et les jeux 2.5D ; le dragueur de mines, le labyrinthe, Tetris et d'autres exemples de jeux ; les collisions, le système de particules, les coordonnées tridimensionnelles 5D et autres. algorithmes de dessin; production de jeux en ligne multijoueurs. Une série de formules algorithmiques sont collectées afin que les lecteurs puissent les utiliser plus facilement. Dans une approche étape par étape, le processus de conception de jeux est progressivement analysé, amenant les lecteurs à résoudre les problèmes qui peuvent être rencontrés au cours de la phase de développement du jeu et résumant l'expérience pratique dans la production de jeux Java. Les principes des jeux, de la mise en œuvre de l'animation, du traitement des effets sonores, du traitement des événements de souris et de clavier, de l'intelligence artificielle et d'autres connaissances dans la conception de ce cours font tous référence à ce document.
La littérature [4] discute du principe du programme et de la technologie de mise en œuvre du jeu informatique classique Tetris, et décrit les exigences fonctionnelles du programme, la structure des données, la rotation graphique, la transformation des coordonnées et d'autres technologies clés du point de vue de l'ingénierie logicielle. Grâce à ce document, j'ai appris davantage sur le domaine professionnel du développement de jeux Tetris.
Le document [5] est un livre avancé qui se concentre davantage sur l'explication de la manière d'utiliser Java pour réfléchir et résoudre des problèmes. Ce document m'a beaucoup aidé avec les idées et techniques de programmation Java lors de la conception du cours.
2Technologies associées
2.1 Introduction à JAVA
Java est le nom général du langage de programmation orienté objet Java et de la plate-forme Java lancée par Sun Microsystems. Il s'agit d'un langage de programmation orienté objet capable d'écrire des logiciels d'application multiplateformes . La technologie Java présente une bonne polyvalence, efficacité, multiplateforme et sécurité. Elle est largement utilisée dans les PC, les centres de données, les consoles de jeux, les superordinateurs scientifiques, les téléphones mobiles et Internet. Elle possède également la plus grande communauté professionnelle de développeurs au monde.
Au cours des vingt dernières années, le langage Java est devenu l'un des langages de programmation les plus influents de l'histoire des ordinateurs humains. Dans une certaine mesure, il a même dépassé le cadre d'un langage de programmation et est devenu une plateforme de développement et un plateforme de développement.Mode canonique. Plus encore : Java est devenu une sorte de croyance. L'open source, la liberté et d'autres esprits prônés par le langage Java ont attiré d'innombrables programmeurs exceptionnels à travers le monde. En fait, depuis l’histoire de l’humanité, il n’y a jamais eu de langage de programmation capable d’attirer autant de programmeurs exceptionnels, et aucun langage de programmation ne peut dériver autant de frameworks open source.
Le langage Java est un langage de programmation orienté objet très pur. Il réunit les différents avantages du langage C et du langage C++, et abandonne les concepts difficiles à comprendre tels que l'héritage multiple et les pointeurs du langage C++. Le langage Java est puissant et la simplicité et la facilité d'utilisation sont deux très bonnes fonctionnalités. En tant que représentant des langages de programmation statiques orientés objet, le langage Java incarne parfaitement la théorie orientée objet et permet aux programmeurs de mener un développement de programmation plus complexe avec une manière de penser plus élégante.
De plus, les spécifications Java EE pertinentes dans le langage Java contiennent les concepts d'ingénierie logicielle les plus populaires aujourd'hui, et diverses idées de conception avancées peuvent être mises en œuvre dans les spécifications, plates-formes et cadres associés Java EE. Dans une certaine mesure, apprendre à maîtriser divers aspects des connaissances liées au langage Java équivaut à acquérir systématiquement des connaissances pertinentes en matière de développement de logiciels, plutôt qu'à simplement apprendre un langage de programmation.
Aujourd'hui, la plupart des systèmes bancaires, de télécommunications, de valeurs mobilières, de commerce électronique, d'administration électronique et autres ont été construits à l'aide de la plate-forme Java EE ou sont en train de migrer progressivement vers la plate-forme Java EE. La spécification Java EE est actuellement la plus mature. est également la spécification de développement d'applications au niveau de l'entreprise la plus largement utilisée.
2.2Introduction aux composants Swing
L'API Swing est un ensemble extensible de composants GUI permettant de créer des applications frontales/GUI basées sur JAVA. Il est construit sur l'API AWT et remplace l'API AWT car presque tous les contrôles qu'il contient correspondent à un contrôle AWT. Les composants Swing suivent l'architecture modèle-vue-contrôleur pour répondre aux directives suivantes. Une seule API suffit pour prendre en charge plusieurs looks et styles ; l'API est pilotée par simulation, de sorte que l'API de plus haut niveau n'a pas besoin de données ; l'API utilise le modèle Java Bean, afin que les outils de construction et les IDE puissent fournir de meilleures performances. services aux développeurs pour l'utiliser.
L'architecture de l'API Swing suit une architecture MVC vaguement basée de la manière suivante. Le modèle représente les données du composant. Une vue représente une représentation visuelle des données d'un composant. Le contrôleur accepte les entrées de l'utilisateur sur la vue et reflète les modifications sur les données du composant. Les composants Swing traitent le modèle comme un élément distinct et combinent les parties de vue et de contrôleur en éléments d'interface utilisateur. En utilisant cette approche, Swing a une architecture d’apparence enfichable. Les principales fonctionnalités de Swing sont :
Léger : les composants Swing sont indépendants de l'API native du système d'exploitation, car les contrôles de l'API Swing sont généralement rendus à l'aide de code JAVA pur plutôt qu'à l'aide d'appels sous-jacents au système d'exploitation.
Contrôles riches - Swing fournit un riche ensemble de contrôles avancés, tels que des arbres, des formulaires à onglets, des curseurs, des sélecteurs de couleurs et des contrôles de table.
Personnalisation avancée - Les contrôles Swing peuvent être personnalisés de manière très simple car l'apparence visuelle est indépendante de la représentation interne.
Apparence et convivialité enfichables - L'apparence et la convivialité d'une application GUI basée sur Swing peuvent être modifiées au moment de l'exécution en fonction de valeurs valides.
2.3 Introduction à la plateforme de développement Eclipse
Eclipse est une plate-forme de développement extensible open source basée sur Java qui vise à fournir une plate-forme industrielle complète de qualité commerciale pour le développement d'outils hautement intégrés. Eclipse n'est qu'un framework et un ensemble de services permettant de créer des environnements de développement via des composants plug-in. Eclipse est livré avec un ensemble standard de plug-ins, notamment des outils de développement Java (JDT).
Eclipse a été lancé en avril 1999. Il a été initialement développé par IBM en tant qu'environnement de développement IDE de nouvelle génération pour remplacer le logiciel commercial Visual Age pour Java. IBM a fourni la base de code initiale d'Eclipse, comprenant Platform, JDT et PDE, en novembre 2001. Pour la communauté open source, actuellement dirigée par IBM, le projet Eclipse s'est développé en une immense alliance Eclipse, avec plus de 150 éditeurs de logiciels participant au projet Eclipse, dont Borland, Rational Software, Red Hat et Sybase, etc., et est désormais dirigé par Gouverné par la Fondation Eclipse, une alliance à but non lucratif d'éditeurs de logiciels. En 2003, Eclipse 3.0 a sélectionné la spécification de plate-forme de services OSGi comme architecture d'exécution. En juin 2007, la version stable 3.3 est sortie. La version 3.4, nom de code Ganymède, est sortie en juin 2008.
Eclipse est un environnement de développement intégré (IDE) multiplateforme gratuit bien connu. Il était à l'origine principalement utilisé pour le développement du langage Java, mais actuellement certaines personnes utilisent des plug-ins pour l'utiliser comme outil de développement pour d'autres langages informatiques tels que C++ et Python. Eclipse n'était à l'origine qu'une plate-forme-cadre, fournissant un environnement de développement de plug-ins (Plug-in Development Environment, PDE). Ce composant est principalement destiné aux développeurs de logiciels qui souhaitent étendre Eclipse, permettant la construction d'outils parfaitement intégrés au Environnement Eclipse. La prise en charge de nombreux plug-ins rend Eclipse Il a une flexibilité que d'autres logiciels IDE avec des fonctions relativement fixes sont difficiles à avoir. Étant donné que tout dans Eclipse est un plug-in, la fourniture de plug-ins pour Eclipse offre aux utilisateurs un environnement de développement intégré cohérent et unifié, afin que tous les développeurs d'outils aient une place égale pour jouer.
Avantages d'Eclipse :
Actuellement, des millions de personnes dans le monde utilisent Eclipse pour le développement. Pourquoi Eclipse a-t-il autant de fans ? Cela a beaucoup à voir avec le fait qu'Eclipse intègre de nombreuses fonctionnalités en une seule.
Eclipse est un logiciel open source. Cela signifie que non seulement Eclipse est gratuit, mais que vous pouvez apprendre les techniques de programmation des meilleurs développeurs mondiaux en étudiant le code source, et que vous pouvez partager des bibliothèques publiques de code open source fournies par des développeurs du monde entier.
Eclipse est véritablement extensible et configurable. Eclipse utilise un mécanisme enfichable, qui ressemble à un vase. Vous pouvez ajouter des fleurs au vase à tout moment et vous pouvez également facilement retirer les fleurs qui ne sont plus nécessaires. À l'heure actuelle, les plug-ins gratuits et payants fleurissent partout sur Internet, et le travail de développement de plug-ins bat également son plein dans le pays et à l'étranger.
Eclipse prend en charge de nombreux langages de développement, pas seulement Java. Eclipse ne fournit aux développeurs qu'un noyau minimal pouvant étendre les fonctions du système. L'architecture de plug-in basée sur des points d'extension permet à Eclipse de prendre en charge plusieurs langages. Tant que le plug-in pour le langage correspondant est installé, Eclipse peut prendre en charge le développement de ce langage. Actuellement, Eclipse peut prendre en charge C/C++, COBOL, PHP, Perl, Python et d'autres langages. (Bien qu'Eclipse soit avant tout un environnement de développement Java, son architecture garantit la prise en charge d'autres langages de programmation).
Eclipse prend en charge plusieurs fonctionnalités de plate-forme. Les développeurs peuvent utiliser la plateforme avec laquelle ils se sentent le plus à l'aise et familiers, comme Windows, Linux, MacOS, etc. Eclipse dispose de sa propre boîte à outils graphique distincte pour chaque plate-forme, ce qui donne aux applications une apparence proche du système d'exploitation natif et de meilleures performances.
Basé sur la spécification OSGi leader du secteur. La spécification OSGi a été lancée pour la première fois par Sun Microsystems, IBM, Ericsson, etc. en 1999. Ses plates-formes de services comprennent : les passerelles de services, les automobiles, les téléphones mobiles, l'automatisation industrielle, l'automatisation des bâtiments, l'informatique en grille sur PDA, le divertissement (comme iPronto) et l'IDE. , etc. Les systèmes basés sur OSGi fonctionnent sous la forme de micro-noyaux, ce qui leur permet de réaliser facilement des systèmes stables et efficaces, remplaçables à chaud et à changement dynamique, dont rêve l'industrie du logiciel. À partir de la version 3.1, Eclipse a résolument abandonné son framework d'origine reconnu par l'industrie et a adopté OSGi comme architecture. À partir d'Eclipse3.2, Eclipse prend en charge le développement basé sur OSGi et les développeurs peuvent l'utiliser pour développer des systèmes basés sur OSGi.
La superbe interface homme-machine d'Eclipse a été largement saluée. Eclipse fournit une nouvelle API SWT/JFace (au lieu d'AWT/Swing), qui modifie le style d'interface monotone et ennuyeux de SWT/Swing, permettant de développer des applications locales avec des interfaces graphiques riches, tout comme une brise printanière soufflant Le domaine du développement de postes de travail Java donne aux gens un sentiment de fraîcheur.
Eclipse est lancé par des leaders de l'industrie et dispose d'une forte puissance industrielle. La Fondation Eclipse a absorbé un grand nombre d'institutions de recherche universitaires et d'organisations commerciales pour diriger la planification et le développement à long terme d'Eclipse et garantir qu'Eclipse occupe une position de leader dans l'industrie des outils logiciels.
2.4 Environnement de la plateforme système :
2.4.1 Plateforme matérielle :
Le matériel informatique développé par ce programme est le suivant :
Disque dur : 500G
Processeur : Intel (R) Core (TM) i5 – Processeur 3 230 M à 2,60 GHz
Outils interactifs : clavier, souris
Affichage: écran LCD
2.4.2 Plateforme logicielle :
L'environnement de développement de ce système est le suivant
Système d'exploitation : Microsoft Windows 7 Ultimate
Version JDK : jdk-8u121-windows-x64
Version Eclipse : version Neon.2 (4.6.2), Eclipse-inst-win64
3 Analyse du système
L'analyse du système est la première étape que nous franchissons dans le processus de développement logiciel, y compris l'analyse des exigences du système et l'analyse de faisabilité. L'analyse des exigences du système est principalement utilisée pour expliquer ce qu'est le système et à quoi il doit être utilisé, et pour parvenir à un consensus entre les développeurs et les principaux utilisateurs sur cette question. L'analyse de faisabilité du système consiste principalement à analyser la mise en œuvre de toutes les ressources du système pour expliquer la rationalité, la faisabilité et l'inévitabilité du développement et de l'investissement du système, et à rationaliser les problèmes imprévus qui peuvent survenir. Le maillon le plus difficile du développement de logiciels est l'analyse de la demande du système. Le temps consacré à l'analyse de la demande est sans aucun doute très précieux. Si les changements de demande se produisent fréquemment, cela entraînera des problèmes dans les tâches de développement de logiciels réalisées dans le cadre du plan prévu. Des effets négatifs très graves. Faire un bon travail d'analyse des exigences du système et d'analyse de faisabilité contribuera à améliorer la commodité du processus de développement logiciel, permettra la surveillance et la gestion en temps réel du processus de développement logiciel et facilitera la procédure comme prévu, atteignant ainsi l'objectif d'amélioration. la qualité du logiciel.Fournir une communication et une coopération plus portables pour les développeurs de programmes, les utilisateurs, etc. En tant que base originale des résultats du travail, l'analyse de la demande du système et l'analyse de faisabilité peuvent également exprimer indirectement les fonctions du système aux utilisateurs potentiels, permettant aux utilisateurs de juger si les fonctions du système répondent aux besoins à réaliser.
3.1 Analyse de faisabilité
L'analyse de faisabilité est basée sur le contenu principal et les conditions de soutien du projet en termes de technologie, d'économie, d'ingénierie, de technologie, etc., telles que la demande du marché, l'offre de ressources, l'échelle de construction, l'itinéraire du processus, la sélection des équipements, l'impact environnemental, la collecte de fonds. , rentabilité, etc. La recherche, l'analyse et la comparaison d'autres aspects, la prévision des impacts environnementaux financiers, économiques et sociaux qui pourraient être obtenus une fois le projet terminé, la question de savoir si le projet vaut la peine d'investir et la manière de consulter et de prendre des décisions concernant le projet, constituent la base de une méthode complète d’analyse du système. L’analyse de faisabilité doit être clairvoyante, équitable, fiable et scientifique.
Afin de garantir la scientificité, l'objectivité et l'impartialité des travaux de l'étude de faisabilité et d'éviter efficacement les erreurs et les omissions, dans l'étude de faisabilité, nous devons d'abord mener des enquêtes et des recherches d'un point de vue objectif et impartial et faire du bon travail dans la collecte des données de base. Les données de base collectées doivent être démontrées et évaluées sur la base de conditions réelles objectives, reflétant fidèlement les lois économiques objectives, et en partant de données objectives et par une analyse scientifique pour tirer une conclusion sur la faisabilité du projet.
La profondeur du contenu du rapport d'étude de faisabilité doit répondre aux normes stipulées par l'État, le contenu de base doit être complet et autant de données que possible doivent être utilisées pour éviter le travail de mauvaise qualité et le formalisme.
Les points clés suivants doivent être maîtrisés en pratique : Démontrer d'abord, puis prendre des décisions ; Gérer correctement la relation entre les trois étapes de la proposition de projet, de l'étude de faisabilité et de l'évaluation. La recherche doit être arrêtée à tout moment lorsqu'elle s'avère irréalisable ; des enquêtes et des recherches doivent être menées. Il est nécessaire de maîtriser des informations pratiques et fiables pour garantir l'exhaustivité, l'importance, l'objectivité et la continuité de la sélection des données ; comparer plusieurs options et choisir la meilleure. Pour les projets liés à l'étranger, ou les projets qui doivent être conformes aux normes étrangères sous la pression de facteurs externes tels que l'adhésion à l'OMC, le contenu et la profondeur de l'étude de faisabilité doivent être aussi conformes que possible aux normes internationales.
Afin de garantir la qualité de l'étude de faisabilité, un cycle de travail suffisant de l'unité de conception-conseil doit être assuré pour éviter tout comportement irresponsable et précipité pour diverses raisons.
Le but de l’analyse de faisabilité est de déterminer si le problème peut être résolu dans les plus brefs délais et au moindre coût. L’objectif principal de l’analyse de faisabilité n’est pas de résoudre des problèmes, mais d’étudier si ces problèmes valent la peine d’investir des ressources humaines et financières pour les étudier et les résoudre. S'il existe un moyen simple et facile, alors oui.
3.1.1 Analyse de faisabilité économique
Le but de l'analyse de faisabilité économique du système est de calculer l'investissement en capital requis depuis le développement et la construction jusqu'à l'exploitation du système, ainsi que la demande du marché et les avantages économiques du nouveau système, de comparer le budget d'investissement avec les avantages attendus et de calculer les coûts économiques, la faisabilité.
Ce système de jeu est principalement utilisé pour la conception de cours de fin d'études en génie logiciel pour les étudiants, et il n'est pas nécessaire de prendre en compte les avantages économiques qu'il peut générer ni l'état de développement futur du jeu. Les exigences économiques du système de jeu lui-même ne sont pas élevées, mais les connaissances et les capacités des étudiants sont améliorées grâce au développement de ce système de jeu. Tout ce dont vous avez besoin est un ordinateur équipé de l'environnement d'exploitation JDK et du logiciel Eclipse, outil de développement Java, vous n'avez donc pas besoin de considérer les problèmes économiques.
3.1.2 Analyse de faisabilité technique
Il existe de nombreux langages de programmation qui peuvent être utilisés pour écrire des jeux Tetris. Ce sujet consiste principalement à développer le système de jeu dans un environnement basé sur Java. Par conséquent, ce système utilise principalement des composants Swing en Java pour le développement et nécessite une définition et une définition de variables. initialisation. , conception de l'interface, initialisation du jeu, entrée dans le jeu, sortie du jeu, gestion de diverses opérations pendant le jeu et exécution des exigences de code pour les fonctions correspondantes. Les exigences techniques ne sont pas particulièrement difficiles et techniquement réalisables.
3.1.3 Analyse de faisabilité sociale
Le développement de ce système de jeu est principalement utilisé pour la conception de cours et de thèses de fin d'études, afin de consolider les connaissances de quatre années d'études universitaires. Il s'adresse principalement aux particuliers et aux écoles. Il est uniquement destiné au divertissement personnel et à la conception de cours scolaires et à la vérification des thèses de fin d'études. Cela n’aura aucun impact sur la société, il n’est donc pas nécessaire de prendre en compte des facteurs juridiques, de droits d’auteur et autres facteurs sociaux. C’est tout à fait réalisable à cet égard.
3.2 Analyse des besoins
Ce qu'on appelle « l'analyse des besoins » fait référence à une analyse détaillée du problème à résoudre, clarifiant les exigences du problème, y compris quelles données doivent être saisies, quels résultats sont obtenus et ce qui devrait être produit au final. On peut dire que « l'analyse des besoins » en génie logiciel consiste à déterminer ce que l'ordinateur « fait » et quel effet il produit. On peut dire que l'analyse des besoins est terminée avant que le système ne soit terminé.
En génie logiciel, l'analyse des exigences fait référence à tous les travaux nécessaires pour décrire l'objectif, la portée, la définition et la fonctionnalité du nouveau système lors de la création d'un nouveau système informatique ou de la modification d'un système informatique existant. L'analyse des besoins est un processus clé en génie logiciel. Au cours de ce processus, les analystes système et les ingénieurs logiciels déterminent les besoins du client. Ce n’est qu’une fois ces besoins identifiés que les solutions pour le nouveau système pourront être analysées et mises en œuvre. La tâche de la phase d'analyse des besoins est de déterminer la fonctionnalité du système logiciel.
Dans l’histoire du génie logiciel, les gens ont toujours pensé que l’analyse des exigences était l’étape la plus simple du génie logiciel. Mais au cours de la dernière décennie, on s’est de plus en plus rendu compte que l’analyse des besoins était le processus le plus important. Si l'analyste ne peut pas comprendre correctement les besoins du client lors de l'analyse de la demande, le logiciel final ne répondra pas réellement aux besoins du client ou le projet logiciel ne sera pas terminé dans les délais impartis.
3.2.1 Exigences fonctionnelles
L'ensemble du système de jeu générera aléatoirement 7 formes différentes de blocs composés de quatre petits blocs. Après rotation, 28 états seront obtenus. Si la difficulté du jeu est augmentée, six formes différentes de blocs seront ajoutées. Après rotation, 24 types seront ajouté. Les blocs tombent librement à une certaine vitesse. Le joueur contrôle le mouvement et la rotation gauche et droite des blocs grâce aux touches haut, bas, gauche et droite du clavier, et place les blocs dans la position appropriée après la chute. Lorsque le bloc tombe, si une ligne entière est remplie de blocs après la chute du bloc, alors toute la ligne sera éliminée. Lorsqu'une ligne est éliminée, le score du joueur augmente de 10 points. Lorsque le score atteint 100 points, le niveau du joueur augmente d'un niveau, la vitesse augmente d'un niveau et la difficulté augmente. Si toute l'interface du canevas de jeu est occupée après la chute du bloc, le bloc ne tombera plus et le jeu échouera. Les exigences fonctionnelles spécifiques du jeu sont les suivantes :
▪ Exigences relatives à l'interface du jeu : Une bonne interface du jeu fera briller les yeux des joueurs, et ils pourront pleinement ressentir le divertissement et la détente apportés par le jeu. La couleur d'arrière-plan par défaut de ce jeu est vert foncé. L'écran d'interface principal du jeu peut être personnalisé selon votre image préférée et peut être modifié. La couleur par défaut des carrés de l'interface principale est orange et la couleur par défaut des carrés de pré-affichage est lavande. La couleur d'arrière-plan et la couleur de premier plan contrastent fortement pour rendre les yeux du joueur plus brillants. Lorsque le jeu atteint un niveau élevé et que la vitesse de chute des blocs augmente, les joueurs peuvent clairement distinguer la forme des blocs qui tombent, ce qui augmente l'ambiance de le jeu. Irritant.
▪ Exigences relatives à la forme du jeu : utilisez un tableau comme structure de données pour stocker 52 états du bloc, à savoir un total de 7 formes, dont une longue barre de niveau primaire, une forme en Z, une forme en Z inversé, une forme de champ et une forme à 7. , forme 7 inversée et forme en T. Déformation par rotation dans 4 directions, trois blocs au niveau intermédiaire et 12 états différents, et trois blocs au niveau avancé avec 12 états différents. Chaque bloc peut tourner dans le sens inverse des aiguilles d'une montre, et la question de savoir si le bloc peut tourner doit être jugée par les conditions. Si le bloc peut franchir la limite après la rotation, il ne peut pas tourner et la position doit être ajustée pour garantir qu'il peut tourner.
▪ Conditions requises pour l'événement de traitement du clavier : Lorsque le bloc tombe, le joueur peut utiliser les touches de direction du clavier : la touche haut pour tourner, la touche bas pour accélérer la chute, la touche gauche pour se déplacer vers la gauche, la touche droite pour se déplacer vers la droite, et la barre d'espace pour réaliser une chute en un clic. La touche de la lettre P implémente la pause et la touche de la lettre C implémente une série d'opérations telles que continuer.
▪ Conditions requises pour les événements de traitement de la souris : Avec la souris, vous pouvez cliquer sur le bouton de menu et le bouton d'aide dans le panneau de configuration, sélectionner les éléments de menu dans la barre de menu, démarrer le jeu, sélectionner le niveau de jeu, modifier l'affichage des couleurs des blocs dans le jeu et l'arrière-plan de l'interface principale du jeu. Afficher la couleur et la couleur de premier plan, modifier l'image d'arrière-plan du jeu, bloquer la vitesse de chute, savoir s'il faut jouer des sons dans le jeu et une série de fonctions.
▪ Exigences d'affichage : Les exigences d'affichage de ce programme de jeu sont que lorsque les blocs tombent et remplissent une ligne entière, la ligne sera éliminée et les lignes restantes non remplies se déplaceront automatiquement vers le bas, une par une. L'élimination d'une ligne augmentera le score sur la bonne interface de dix points. Lorsque le score augmente à 100 points, le niveau augmente d'un niveau. Lorsque le bloc tombe et se superpose sur toutes les lignes de l'interface principale, le bloc ne tombe plus, le jeu se termine et l'interface principale affiche le mot « Game Over ».
3.2.2 Exigences non fonctionnelles
Exigences non fonctionnelles : les exigences non fonctionnelles du système de jeu Tetris incluent l'affichage de l'icône dans le coin supérieur gauche de l'interface principale du jeu, l'ajustement de la taille de la fenêtre pour maximiser et minimiser (mais sans inclure la taille de l'interface principale), et la position de la fenêtre contextuelle lors de l'exécution du jeu. Un ensemble d'exigences non fonctionnelles.
3.2.3 Contrôle des interfaces
Sous le système d'exploitation Windows, ce système de jeu russe gère principalement le jeu via le clavier.
Vous pouvez utiliser la souris pour effectuer une série d'opérations telles que le démarrage, la sortie et les paramètres. Tout d'abord, le jeu utilise les touches du clavier pour faire fonctionner le jeu, il doit donc utiliser les événements de l'interface du clavier. Deuxièmement, pendant tout le processus du jeu, vous devez utiliser la souris pour contrôler le jeu, y compris le démarrage, la sélection des niveaux, la modification des paramètres, la modification des couleurs, l'affichage des informations de version, la sortie, etc., vous devez donc ajouter une interface à surveiller les événements pour les clics et les boutons de la souris. , écrire le code correspondant pour implémenter les fonctions correspondantes de la souris et du clavier.
4 Conception générale du système
4.1 Conception fonctionnelle du système
4.1.1 Processus de base du traitement commercial manuel
Ce jeu est conçu avec le divertissement comme intention originale et le puzzle comme objectif. Il est basé sur une étude approfondie des fonctions des précédents jeux Tetris classiques et en introduit de nouveaux, en ajoutant de nouvelles fonctions pour lui donner une nouvelle vitalité et vitalité. Le processus de base du jeu est expliqué en détail ci-dessous.
Mode d'emploi:
1>Exécutez le programme et cliquez sur « Démarrer » dans le panneau de configuration à droite ou sur le bouton « Démarrer » dans le menu « Contrôle » pour démarrer le jeu.
2> Utilisez les touches haut, bas, gauche, droite et la barre d'espace, la touche P et la touche C pour contrôler la déformation, la chute, le mouvement gauche et droit du bloc et la chute rapide, faites une pause et continuez en un seul clic.
3> Éliminez une rangée complète de blocs, le score augmentera automatiquement et le niveau augmentera automatiquement d'un niveau.
4>Au fur et à mesure que le niveau augmente et que la vitesse de chute des blocs augmente, appuyez sur les boutons « Élémentaire », « Intermédiaire » et « Avancé » sur le panneau de commande de droite ou dans le menu « Jeu » pour modifier manuellement la difficulté du jeu. Vous pouvez également cliquer sur les options du menu « Couleur du bloc » pour changer la couleur des blocs, etc. Vous pouvez également modifier certains attributs du jeu via les options du menu « Personnaliser ».
5> Appuyez sur la touche P du clavier pour mettre le jeu en pause, puis appuyez sur la touche C pour continuer la partie. Appuyer sur le bouton « Fin de partie » arrêtera complètement le jeu en cours, et appuyer sur « Démarrer » ou « Redémarrer » dans le menu « Contrôle » démarrera une nouvelle partie.
6>Lorsque les blocs occupent toute la fenêtre et qu'aucun nouveau bloc ne peut tomber, le jeu affichera une boîte de dialogue « Game Over » pour inviter le jeu à se terminer.
L'organigramme de base du jeu est présenté dans la figure 4-1 :
Figure 4-1 Organigramme de base du jeu
4.1.2 Modules fonctionnels du processus de base
Ce système conçoit chaque module fonctionnel du jeu en fonction des différentes fonctions du jeu. La figure 4-2 est un diagramme schématique des modules de fonction système de ce jeu. Comme le montre la figure, ce jeu comporte principalement deux modules : la zone d'interface de jeu et la zone de contrôle du jeu. L'interface de jeu est divisée en deux parties : l'affichage des opérations optionnelles du joueur et l'affichage des résultats des opérations du joueur. Le contrôle du jeu est divisé en quelques modules fonctionnels tels que le changement de couleur, le démarrage, le changement du niveau de jeu en élémentaire, le changement du niveau de jeu en intermédiaire, le changement du niveau de jeu en avancé, la personnalisation de la vitesse de chute, le changement d'arrière-plan, la sortie et autres.
Figure 4-2 Diagramme schématique des modules fonctionnels du système
La figure 4-3 est un diagramme schématique de la conception du module de zone d'interface de jeu. Comme le montre la figure, le module de zone d'interface de jeu peut être subdivisé en trois modules fonctionnels : entrer dans la nouvelle interface de jeu, traiter les opérations du joueur et afficher les résultats des opérations du joueur. .
Figure 4-3 Diagramme schématique du module d'interface
La figure 3-4 est un diagramme schématique de la conception de la zone de contrôle du jeu. Comme le montre la figure, le module de la zone de contrôle du jeu est divisé en modules fonctionnels tels que le démarrage, les paramètres de fonctionnement personnalisés, les paramètres de niveau de jeu initiaux, les paramètres de couleur initiaux et la sortie. .
Figure 4-4 Diagramme schématique du module de zone de contrôle
5Conception détaillée et mise en œuvre du système
Java est un langage de programmation purement orienté objet (Object-Oriented), et ses nombreux avantages ne seront pas abordés en détail ici. Partant du concept orienté objet, ce programme peut être principalement divisé en modules suivants :
●Module d'affichage de l'interface principale du jeu
●Module d'affichage de blocs et de données
●Module de contrôle de mouvement de bloc
●Module de contrôle des couleurs de l'interface de jeu
●Module de progression du jeu et de contrôle de niveau
La compétence d'analyse d'un objet réside dans son évolutivité fonctionnelle et son efficacité de maintenance. Imaginez simplement que si la fonction du programme doit être étendue ou maintenue en raison de changements dans l'environnement externe ou des besoins de l'utilisateur, le code devra être considérablement modifié, voire réécrit. De cette manière, l'avantage orienté objet sera perdu. , donc lors de l'analyse de ce programme, un module hautement indépendant est utilisé comme objet pour améliorer l'évolutivité et la maintenabilité du programme. Voici la conception des classes du jeu :
Classe MyFrame : héritée de la classe JFrame, en tant que classe principale du jeu, elle est chargée de contrôler le corps principal du jeu et de connecter et commander le hub de chaque classe.
Classe PreView : héritée de la classe JPanel, en tant que classe de panneau de commande, elle est chargée de placer la fenêtre principale du jeu, le tableau de bord, les boutons de contrôle de niveau et d'autres fenêtres pour contrôler le processus de jeu.
Classe GameCanvas : héritée de la classe JPanel, la classe de thread ChangeBlockColor modifie dynamiquement la couleur du carré de la classe Canvas. La classe Canvas reflète le mouvement et l'élimination du carré ChangeBlockColor en vérifiant la couleur du carré.
Classe Boîte : Classe Carrée, les éléments de base qui composent la boîte. L'expression principale est la couleur.
Classe de blocs : En tant que classe de manipulation de blocs, elle contrôle le mouvement, la chute et la déformation des blocs.
5.1 Module d'affichage de l'interface principale du jeu
Un excellent système logiciel ne se reflète pas seulement dans la diversité et la puissance des fonctions de base. Si l'utilisateur est confronté à une interface ennuyeuse et ancienne, alors le système logiciel échouera. Par conséquent, un système logiciel bon et exquis ne réussira pas. La conception des interfaces est un maillon extrêmement important. L’importance de concevoir et de produire une interface avec une présentation raisonnable et de bons effets visuels pour les joueurs va de soi.
L'interface principale du jeu est développée à l'aide de composants Swing et les auditeurs y sont enregistrés pour mettre en œuvre diverses fonctions de contrôle. Sur la base de la conception du formulaire de jeu, au moins trois auditeurs doivent y être enregistrés, à savoir l'auditeur d'action (ActionListener). et un écouteur de clavier, un écouteur (KeyListener), un écouteur d'options (ItemListener).
Selon la conception préliminaire, il peut être déterminé que les objets du composant Swing à utiliser sur le client incluent les objets JFrame, les objets JPanel, les objets JLabel, les objets JButton, les objets JMenuBar, les objets JMenu, les objets JMenuItem, les objets JTextField, les objets JTextArea, JDialog. objets, etc., au moins dix objets composant Swing. La figure 5-1 ci-dessous est une capture d'écran de l'interface principale du jeu.
Figure 5-1 Capture d'écran de l'interface principale du jeu
La correspondance initiale des couleurs de la conception de l'interface principale de ce jeu est basée sur le principe d'un contraste net. La couleur d'arrière-plan par défaut est vert foncé. L'icône Tetris est définie dans le coin supérieur gauche. La valeur initiale du score est 0, le la valeur initiale du niveau est 1 et la valeur initiale de l'enregistrement de score le plus élevé est 0. La taille du formulaire de jeu principal est définie sur (520, 580), le volet de plage de mouvement des blocs est contrôlé par un tableau bidimensionnel de 20 lignes et 12 colonnes, et l'icône dans le coin supérieur gauche est définie sur un motif de bloc. à des fins d'identification.
5.2 Module d'affichage toile et boîte
Dans ce jeu, la toile est conçue comme une image personnalisée. Vous pouvez modifier vous-même l'image d'arrière-plan selon vos propres besoins. Pendant le processus de chute des blocs, les blocs qui tombent sont identifiés en fonction des changements de couleur.
5.2.1 Conception du module de canevas d'arrière-plan
Le canevas d'arrière-plan principal du jeu est un tableau bidimensionnel composé de lignes 20 et de colonnes 12. L'affichage carré est identifié par les changements de couleur correspondants. Le formulaire principal est rempli de couleurs pour former le style d'arrière-plan et les carrés. Ce jeu utilise la classe GameCanvas héritée de JPanel pour contrôler l'affichage du canevas d'arrière-plan. Les lignes représentent le nombre de lignes du canevas et les colonnes représentent le nombre de colonnes du canevas. Le nombre de lignes et de colonnes détermine le nombre de carrés. la toile a. Le code d'implémentation principal du canevas d'arrière-plan est le suivant :
Tout d’abord, utilisez un constructeur de la classe canvas pour représenter le nombre de lignes, de colonnes et la bordure principale de l’ensemble de l’interface principale.
Position relative dans :
/**
* Constructeur de classe canvas
* @param rows int, le nombre de lignes dans le canevas
* @param cols int, le nombre de colonnes du canevas
* Le nombre de lignes et de colonnes détermine le nombre de carrés de la toile.
*/
public GameCanvas (int lignes, int cols) {
this.rows = lignes ;
this.cols = cols;
this.setOpaque(false);
boxes = new Box[lignes][cols];
pour (int i = 0; i < boxes.length; i++) {
pour (int j = 0; j < cases[i].length; j++) {
boîtes[i][j] = nouvelle Boîte(false);
}
}
setBounds(0, 0, 300, 500);//Définir les coordonnées de position relative
setBorder(nouveau EtchedBorder(
EtchedBorder.RAISED, Color.white, nouvelle couleur (148, 145, 140)));
}
/**
* Obtenez le nombre de rangées de carrés dans le canevas
* @return int, le nombre de lignes dans la grille
*/
public int getRows() {
renvoyer les lignes ;
}
/**
* Obtenez le nombre de colonnes dans le canevas
* @return int, le nombre de colonnes dans la grille
*/
public int getCols() {
retour des cols ;
}
Deuxièmement, définissez un constructeur de la classe canvas pour représenter la couleur de premier plan et la couleur d'arrière-plan de toute l'interface principale et obtenez ses couleurs de premier plan et d'arrière-plan :
/**
* Constructeur de classe canvas
* Les lignes @param sont identiques à GameCanvas public (int rows, int cols)
* @param cols est le même que public GameCanvas (int rows, int cols)
* @param backColor Couleur, couleur d'arrière-plan
* @param frontColor Couleur, couleur de premier plan
*/
public GameCanvas (int lignes, int cols,
Couleur backColor, Couleur frontColor) {
this(lignes, colonnes);
this.backColor = backColor;
this.frontColor = frontColor;
}
/**
* Définir la couleur d'arrière-plan du jeu
* @param backColor Couleur, couleur d'arrière-plan
*/
public void setBackgroundColor(Couleur backColor) {
this.backColor = backColor;
}
/**
* Obtenez la couleur d'arrière-plan du jeu
* @return Color, couleur d'arrière-plan
*/
couleur publique getBackgroundColor() {
retournerbackColor;
}
5.2.2 Aperçu de la conception du module de bloc
Les blocs et les informations sur les données sont les modules fonctionnels les plus basiques du jeu. Box, une classe de type grille, est l'élément de base qui constitue un bloc. Il utilise sa propre couleur pour représenter l'apparence du bloc. MyTask hérite de la classe TimerTask pour chronométrer les déplacements et utilise des méthodes de comptage pour obtenir des changements de vitesse. La classe MyListener hérite de la classe KeyAdapter pour implémenter la surveillance des boutons, contrôler le haut, le bas, la gauche et la droite du bloc. Définissez une matrice carrée 4x4 avec un total de 16 cellules. Utilisez "0" et "1" pour indiquer si chaque carré est peint avec une nouvelle couleur ou conserve la couleur d'arrière-plan.
Chaque fois qu'un nouveau bloc est obtenu, l'une des sept formes de blocs est sélectionnée au hasard. Le jeu définit une variable qui représente le modèle du nouveau bloc. Par exemple, définissez un tableau int STYLE pour représenter 28 types de blocs, avec 7 lignes et 4 colonnes, et chaque élément représente l'un des blocs. Autrement dit, 0<=blockkindnum<=6, 0=<blockstatusnum<=3
Ensuite, lorsque le bloc tombe et que vous avez besoin d'obtenir un nouveau bloc, il vous suffit d'obtenir au hasard une paire de valeurs blockkindnum et blockstatusnum, puis de construire le bloc correspondant en fonction de la valeur de ce STYLE. La question restante est de savoir comment générer aléatoirement une paire de valeurs de ligne et de colonne STYLE.
La classe Math du package de langage Java fournit une méthode random() pour générer des nombres aléatoires. L'appel de cette méthode générera un nombre à virgule flottante double précision compris entre 0 et 1. Ainsi, chaque fois que vous souhaitez obtenir un nouveau bloc, il vous suffit d'appeler cette méthode une seule fois pour obtenir un nombre à virgule flottante double précision de 0 à 1, puis de multiplier le nombre par 7, puis de le transformer en un entier pour obtenir un entier de 1 à 7. , utilisé pour contrôler les lignes. Multipliez ce nombre par 4, puis convertissez-le en un entier pour obtenir un entier de 1 à 4, qui est utilisé pour contrôler la colonne.
À partir de là, plusieurs définitions graphiques peuvent être combinées et les fonctions suivantes peuvent être implémentées à l'aide de code :
1> Chaque exécution génère d'abord une valeur initiale différente pour le nombre aléatoire.
int col = (int) (Math.random() * (gc.getCols() - 3));//Générer des colonnes à des positions aléatoires
int style = Constant.STYLES[(int) (Math.random() * Block.get_addl())][(int) (Math.random() * 4)];
Figure 5-2 Organigramme de blocs générés de manière aléatoire
2> Sélectionnez au hasard une figure, la figure 5-2 génère de manière aléatoire un schéma fonctionnel pour décrire spécifiquement la CNC aléatoire générée
Les graphiques résultants.
3>Les informations de position du graphique actuel dans sa grille 4*4.
Dessinez une grille de pré-affichage de 4 lignes et 4 colonnes de blocs et générez aléatoirement un style de bloc de pré-affichage. Ce jeu utilise un tableau bidimensionnel pour stocker 28 styles de blocs.
Il convient de noter que : sur la base du jeu traditionnel Tetris, afin de refléter une pensée innovante et conformément au principe d'apprentissage, ce système de jeu ajoute trois autres styles de blocs au niveau intermédiaire et trois niveaux avancés sur la base de le jeu traditionnel. autres styles de blocs. Il existe un total de 52 styles de bloc. Le code d'implémentation principal pour la méthode de stockage spécifique est le suivant :
/**
* Correspond respectivement à 52 états de 13 modèles
*/
public final static int[][] STYLES = {// 28 états au total
{0xf000, 0x8888, 0xf000, 0x8888}, // Quatre états de barre longue
{0x4e00, 0x4640, 0xe400, 0x4c40}, // Quatre états de type 'T'
{0x4620, 0x6c00, 0x4620, 0x6c00}, // Quatre états de forme en "Z" inversé
{0x2640, 0xc600, 0x2640, 0xc600}, // Quatre états de type 'Z'
{0x6220, 0x1700, 0x2230, 0x7400}, // Quatre états de type '7'
{0x6440, 0xe200, 0x44c0, 0x8e00}, // Quatre états de type '7' inversé
{0x6600, 0x6600, 0x6600, 0x6600}, // Quatre états du bloc
{0x8c88,0xf200,0x44c4,0x4f00},//Ajout de 3 blocs de style intermédiaires
{0xea00,0xc4c0,0xae00,0xc8c0},
{0x8c00,0xc800,0xc400,0x4c00},
{0xac00,0xcc40,0x6e00,0x8cc0},//Ajout de 3 blocs de style avancés
{0x4e40,0x4e40,0x4e40,0x4e40},
{0x8480,0xa400,0x4840,0x4a00},
} ;
Je pense que beaucoup de gens connaissent les 7 styles de blocs du jeu Tetris traditionnel, je ne prendrai donc pas de captures d'écran pour montrer les styles de blocs courants un par un. Voici trois modèles de blocs de difficulté intermédiaire et trois de difficulté avancée ajoutés au mode de jeu traditionnel :
●Ajout de trois modèles de blocs de difficulté intermédiaire (quatre états de rotation peuvent être obtenus après 90 degrés, 180 degrés, 270 degrés et 360 degrés)
Figure 5-10 Trois modèles supplémentaires de blocs de difficulté intermédiaire
●Ajout de trois modèles de blocs de difficulté avancés (quatre états de rotation peuvent être obtenus après 90 degrés, 180 degrés, 270 degrés et 360 degrés)
Figure 5-11 Trois modèles de blocs de difficulté avancés supplémentaires
5.2.3 Conception du module de mouvement et de rotation des blocs
Le retournement et le déplacement de blocs sont relativement simples à mettre en œuvre : pour déplacer un bloc, il suffit de changer l'abscisse ou l'ordonnée du bloc, puis de redessiner le bloc. Pour retourner le bloc, il vous suffit de modifier la valeur du tableau d'arrière-plan et de redessiner le bloc.
Lorsque les blocs de ce jeu tombent, un dessin dynamique est effectué et l'interface Cloneable est implémentée pour indiquer que la méthode Object.clone() peut légalement copier l'instance de cette classe par champs. La classe d'opération de bloc BlockOperation hérite de la classe Thread et remplace la méthode run() pour réaliser la localisation dynamique et correcte du bloc. Bien entendu, il est nécessaire de déterminer si le bloc est à l'état de déplacement ou à l'état de pause dans le thread.
exécution publicvoid()
{
// le déplacement détermine si le bloc tombe dynamiquement
en (bougeant)
{
essayer
{
//betweenleveltime indique la différence de temps entre les niveaux adjacents
dormir (entre le niveau et l'heure
* (ControlMainGame.maxlevel - niveau + flatgene));
} catch (InterruptedException, c'est-à-dire)
{
c'est à dire.printStackTrace();
}
//la pause détermine si le jeu est en pause
si (!pause)
déplacement = (moveTo(y + 1, x) && déplacement);
//le déplacement attend 100 millisecondes et le déplacement n'a pas été modifié.
}}
Bien sûr, dans le jeu, nous devons également déterminer le problème des limites du mouvement des blocs. Par exemple, un bloc a exactement une grille d'espace à sa gauche avant de pouvoir être retourné, mais il y a exactement une grille d'espace à sa droite. Dans ce cas, si le bloc ne peut pas être retourné, le retournement n'est pas pratique à utiliser pour les utilisateurs. S'il peut être retourné, il franchira la limite et occupera les blocs existants. Si vous souhaitez retourner le bloc sans sortir des limites, vous devez déplacer le bloc d'une case vers la droite après l'avoir retourné, puis dessiner à nouveau le bloc. De cette façon, le bloc n'évincera pas les autres blocs fixes. résout le problème du hors limites. .
1> Bloquer le jugement inversé
Le transfrontalier peut se produire dans deux situations : l'une est lorsque le bloc tombe et est fixe, et la seconde est lorsque l'espace environnant ne lui permet pas de se retourner.
Dans le premier cas, il suffit de se référer au jugement selon lequel le bloc ne peut plus bouger après sa chute.
Dans le deuxième cas, avant que chaque bloc ne soit retourné, l'espace autour du bloc doit d'abord être calculé et retourné si l'espace le permet. Sinon, il ne peut pas être retourné.
Parce que les sept types de carrés sont irréguliers, l'espace de retournement requis pour chaque type de carré est différent. Même dans ses différents états de retournement, l'espace de retournement requis est également différent. La première chose qui vient à l'esprit est naturellement de fournir à chaque carré différents espaces de retournement, types de blocs, et écrire une condition de jugement pour chaque état du bloc, mais cela serait trop gênant.
D'après l'observation, il n'est pas difficile de constater que parmi les sept formes de blocs, si un long bloc tombe sous la forme d'une barre horizontale, il peut être retourné aussi longtemps qu'il peut tomber. barre verticale, elle sera alors dans la position après le retournement. La position doit avoir un espace de grille de 4x1 avant de pouvoir être retournée. Pour le carré en forme de Tian, tant qu'il peut continuer à tomber, il pourra certainement se retourner, donc tant que le carré en forme de Tian ne tombe pas, il pourra toujours se retourner. Les cinq autres formes de blocs ont une chose en commun, c'est-à-dire qu'elles ont toutes deux états inversés qui occupent trois grilles d'espace horizontalement et deux espaces verticalement. Les deux autres états inversés occupent deux grilles d'espace horizontalement, occupant trois espaces de grille. dans la direction verticale. S'ils tombent dans un état d'occupation de trois grilles dans la direction horizontale, alors tant qu'ils peuvent tomber, ils pourront se retourner. S'ils tombent dans l'état de deux grilles dans la direction horizontale, alors après avoir retourné, l'environnement Il doit y avoir un espace de grille de 3x2.
Par conséquent, la détermination du retournement d'un bloc doit être divisée en trois situations : la première situation est que le bloc ne peut pas être retourné après une chute ; la deuxième situation est que le long bloc qui apparaît à l'état vertical est retourné ; la troisième situation est que le bloc long qui apparaît à l'état vertical est retourné. is En plus des longues bandes et des carrés en forme de champ, les cinq autres carrés qui apparaissent dans un état occupant deux grilles dans la direction horizontale sont jugés pour leur retournement.
Maintenant que le problème des circonstances dans lesquelles le bloc peut être retourné a été résolu, nous devons ensuite résoudre le problème de la position du bloc après son retournement, car ce n'est qu'en connaissant à l'avance la position du bloc après son retournement. Pouvons-nous déterminer la portée spatiale de cette position. Déterminez-la pour voir si elle peut accueillir le bloc.
Ce qui est sûr, c'est que quelle que soit la manière dont le bloc est retourné, il est toujours dans le tableau de blocs, ce qui signifie que le bloc doit se trouver dans un certain espace de grille 4x4 sur la carte du jeu.
Les coordonnées du tableau de blocs dans l'interface principale du jeu sont déterminées. Ce qui est incertain, c'est où le bloc se trouvera dans le tableau de blocs après le retournement. Afin de résoudre ce problème, nous pouvons limiter le principe de stockage du bloc dans le tableau de blocs. tableau de blocs vers la gauche ou la gauche. De cette façon, peu importe la façon dont vous le retournez, il y aura toujours des blocs dans la première ligne et la première colonne du tableau de blocs. Cela détermine également la position du bloc dans le tableau de blocs, et vous pouvez également savoir comment le bloc apparaîtra sur la carte du jeu après avoir été retourné.
Supposons que les coordonnées horizontales et verticales du tableau de blocs soient x et y, alors cette position est que la ligne où le long bloc est retourné est la yème ligne de la carte du jeu, et les colonnes qu'il occupe sont la xème à x+3. colonnes , les lignes occupées par les cinq types de carrés autres que la longue bande et la forme du champ après retournement sont les yème et y+1ème lignes de la carte du jeu, et les colonnes qu'ils occupent sont les xème à x+2 colonnes.
Par conséquent, s’il y a des cellules vides dans l’espace ci-dessus, les blocs peuvent être retournés.
2> Correction hors limites
Un bloc peut être retourné tant qu'il y a suffisamment d'espace dessus après le retournement, mais que se passe-t-il si l'espace après le retournement du bloc n'est pas suffisant, mais qu'il y a suffisamment d'espace de l'autre côté ?
Lorsque le bloc est à la limite, non seulement il peut tomber hors de la carte après avoir été retourné, mais le tableau peut également sortir des limites. Bien sûr, il vous suffit de définir un tableau de cartes plus grand pour éviter que le tableau ne soit hors limites. Pour le bloc hors limites, s'il se trouve de l'autre côté. S'il y a suffisamment d'espace, alors le bloc doit être déplacé dans l'autre direction par l'unité appropriée pour corriger l'erreur de bloc hors limites. Comme le montre l'organigramme de retournement de bloc de la figure 5-12, le retournement d'un bloc nécessite trois déterminations : s'il est tombé au fond, s'il y a suffisamment d'espace après le retournement et s'il a franchi la limite après le retournement.
Figure 5-12 Organigramme du traitement du retournement de bloc
Le joueur utilise le clavier pour déplacer et faire pivoter les blocs. Le code introduit la classe ControlKeyListener et hérite de la classe KeyAdapter pour implémenter la fonction de surveillance du clavier. La classe KeyAdapter hérite de la classe Object et implémente l'interface KeyListener, une classe d'adaptateur abstraite utilisée pour recevoir des événements de clavier. Les méthodes de cette classe sont vides. Cette classe existe pour faciliter la création d'objets d'écoute. Étendez cette classe pour créer un écouteur KeyEvent et remplacez la méthode de l'événement requis, qui est la classe ControlKeyListener. Utilisez ControlKeyListener pour créer un objet écouteur, puis enregistrez l'objet écouteur auprès du composant à l'aide de la méthode addKeyListener du composant. Lorsqu'une touche est enfoncée, relâchée ou saisie, la méthode correspondante dans l'objet écouteur est appelée et le KeyEvent est transmis à la méthode appropriée. Le code d'implémentation est le suivant :
privateclass ControlKeyListener étend KeyAdapter
{
publicvoid keyPressed (KeyEvent ke)
{
si (!game.isPlaying())
retour;
BlockOperation blockope = game.getCurBlock();
commutateur (ke.getKeyCode())
{
cas KeyEvent.VK_DOWN :
blockope.moveDown();
casser;
cas KeyEvent.VK_LEFT :
blockope.moveLeft();
casser;
cas KeyEvent.VK_RIGHT :
blockope.moveRight();
casser;
cas KeyEvent.VK_UP :
blockope.turnNext();
casser;
défaut:
casser;}}}
5.3Module du panneau de commande
5.3.1 Conception du module de la barre de menus
Il y a quatre options de menu « Jeu » et « Aide » dans la barre de menu. L'option « Jeu » est divisée en sept options : « Démarrer », « Débutant », « Intermédiaire », « Avancé », « Personnaliser », « Couleur de bloc » et « Quitter ». Il existe une option « À propos » dans l'option « Aide », qui est utilisée pour afficher des informations telles que la version du jeu.
1>La fonction du bouton « Démarrer » consiste à redessiner le canevas de jeu, similaire à la fonction de réinitialisation. Le code d'implémentation du suivi de ce bouton est le suivant :
/**
* Réinitialiser la toile
*/
public void réinitialiser() {
pour (int i = 0; i < boxes.length; i++) {
pour (int j = 0; j < cases[i].length; j++)
boîtes[i][j].setColor(false);
}
repeindre();
}
2>Les boutons « Élémentaire », « Intermédiaire » et « Avancé » permettent d'ajuster manuellement le niveau du jeu, modifiant ainsi le niveau de difficulté du jeu. Le bouton "Quitter" contrôle le jeu pour quitter à tout moment et terminer le jeu.
3>Cliquez sur le bouton « À propos » dans le bouton « Aide » pour afficher les informations relatives au logiciel de jeu lui-même. Les informations spécifiques sont telles qu'indiquées dans la figure :
Figure 4-19 Capture d'écran de l'option « À propos »
5.3.2 Conception des boutons du panneau de commande
Le panneau de contrôle du jeu contient des champs tels que les statistiques de score et les statistiques de niveau.
Les contrôles TextField sont fournis par les statistiques du jeu lui-même et les joueurs ne peuvent pas les modifier en privé. Les règles du jeu de ce jeu sont de 10 points pour chaque ligne éliminée, et chaque 100 points supplémentaires augmente d'un niveau. Le score initial est de 0 et le niveau initial est de 1.
Voici le code principal pour implémenter des fonctions telles que la mise à jour du score et du niveau :
/**
* Déterminez si la ligne est pleine. Si la ligne est pleine, appelez la méthode d'élimination.
*/
privé vide isFullLine() {
// TODO Stub de méthode généré automatiquement
pour (int je = 0; je < 20; i++) {
ligne entière = 0 ;
indicateur booléen = vrai ;
pour (int j = 0; j < 12; j++) {
si (!gc.getBox(i, j).isColorBox()) {
drapeau = faux ;
casser;
}
}
si (drapeau == vrai) {
rangée = je ;
gc.delete(ligne);//Supprimer la ligne
si(isMusic==true)
{mp.playEraseSound();}
addScor();//Ajouter un score
if(scor%100==0)//Défini sur 100 points pour augmenter d'un niveau
upspeed=true;//Augmente l'indicateur de vitesse à true
si(upspeed==true)
niveau supérieur();
}
}
}
/**
* Comment les scores sont calculés
*/
privé vide addScor() {
score=score+10 ;
jt9.setText("Score : "+MonFrame.scor);
}
}
réinitialisation privée du vide() {
note=0 ;
rang=0 ;
jt10.setText("Niveau :"+rang);
jt9.setText("Score : "+scor);
vitesse de montée = faux ;
jouer = vrai ;
runstop=faux ;
gc.setGameOver(false);
gc.repaint();
gc.reset();
}
Les fonctions des boutons du panneau de commande ont été codées en 4.3.1 et ne seront pas décrites à nouveau ici.
6 tests du système
6.1 Aperçu des tests
Les tests du système consistent à confirmer les logiciels, le matériel informatique, les équipements périphériques, le réseau et d'autres éléments ensemble pour les tests d'assemblage et les tests de confirmation de divers systèmes d'information. Les tests du système consistent à tester l'ensemble du système de produit dans le but de vérifier si le système répond aux exigences requises. Spécifications : Définir et identifier les incohérences ou contradictions avec les spécifications des exigences pour proposer une solution plus complète. Une fois que les tests du système ont révélé un problème, essayez de trouver la cause et l'emplacement de l'erreur, puis corrigez-la. Il s’agit de l’exigence globale du système basée sur des tests en boîte noire et doit couvrir tous les composants du système. Les objets incluent non seulement le logiciel à tester, mais également le matériel dont dépend le logiciel, les périphériques et même certaines données, certains logiciels de support et leurs interfaces.
Les tests système sont un logiciel de test intégré qui, en tant que partie intégrante du système informatique, se combine avec d'autres parties du système pour effectuer une série de tests stricts et efficaces dans l'environnement d'exploitation réel du système informatique afin d'identifier les problèmes potentiels avec le logiciel et de garantir le fonctionnement normal du système.
Le but des tests système est de vérifier si le système logiciel final répond aux exigences des utilisateurs.
Le contenu principal comprend :
(1) Tests fonctionnels. C'est-à-dire que le fonctionnement du système logiciel de test est correct conformément aux exigences du document, telles que la « Spécification des exigences du produit » . L’exactitude étant le facteur de qualité le plus important d’un logiciel, les tests fonctionnels sont cruciaux.
(2) Test de robustesse. C'est-à-dire la capacité de tester le fonctionnement normal d'un système logiciel dans des conditions anormales. La robustesse a deux significations : l’une est la tolérance aux pannes et l’autre la résilience.
6.1.1 Principes de test
Les principes de base des tests logiciels comprennent des tests complets du point de vue des utilisateurs du produit, la découverte d'autant de problèmes et de failles que possible dans le processus d'utilisation du système, la recherche et l'analyse, et la proposition de problèmes et de suggestions d'amélioration sur les aspects défectueux du produit. Le principe détaillé des tests est le suivant :
(1) Le plan de test logiciel est un guide d'action pour les tests logiciels. Les tests réels doivent être soigneusement et strictement mis en œuvre, et le plan de test doit être strictement mis en œuvre avec une grande faisabilité, en particulier pour déterminer la méthode de test et l'objectif du test.
(2) Les normes de test sont établies en fonction des besoins des utilisateurs. L'objectif principal des tests de logiciels est d'assurer la cohérence du produit et de vérifier que le produit peut répondre aux besoins des clients. Par conséquent, pendant le processus de test, vous devez toujours examiner le problème du point de vue de l'utilisateur. perspective et découvrez L'impact des défauts et des lacunes des logiciels, les erreurs les plus graves du système, les programmes qui ne répondent pas aux besoins des utilisateurs et les défauts fonctionnels.
(3) Les tests ne peuvent pas être traités avec désinvolture.
Surtout pour les tests du système et les tests répétés, si le plan de test n'est pas strictement mis en œuvre, il est très probable que de nouveaux BUG soient générés par négligence. Par conséquent, la phase de tests répétés doit également faire l'objet d'une attention particulière. Il existe de nombreuses erreurs dans la détection précoce, dont la plupart ne sont pas découvertes en raison de la négligence.
But:
(1) S'assurer que les activités de test du système sont effectuées normalement ;
(2) Vérifier l'inadéquation ou la contradiction entre les produits logiciels et les exigences du système ;
(3) Établir une base de données complète de suivi des défauts de test du système ;
(4) Veiller à ce que les groupes et les individus concernés soient informés en temps opportun des activités et des résultats des tests du système logiciel.
6.1.2 Méthodes d'essai
Afin de tester de manière exhaustive le système et de découvrir les problèmes et les défauts du système, l'utilisation de plusieurs méthodes de test pour tester ensemble peut résumer de manière plus complète les avantages et les inconvénients de la conception du système. Les méthodes de test suivantes sont utilisées :
Tests fonctionnels : testez si les points de fonction sous chaque module fonctionnel du système peuvent être utilisés normalement ;
Tests manuels : teste principalement les fonctions de saisie, de clic et autres ;
Test boîte noire : après la saisie, vérifiez si le résultat est correct.
Tests de récupération : en tant que test du système, les tests de récupération se concentrent principalement sur diverses conditions qui provoquent l'échec du logiciel et vérifient que le processus de récupération peut être mis en œuvre normalement. Dans certains cas, le système doit être tolérant aux pannes. De plus, les pannes du système doivent être corrigées dans les délais impartis, sinon de graves pertes économiques en résulteront. Les tests de récupération vérifient principalement la tolérance aux pannes du système. Lorsqu'une erreur système se produit, l'erreur peut-elle être corrigée et le système redémarré dans un intervalle de temps spécifié. Les tests de récupération doivent d'abord utiliser diverses méthodes pour forcer la panne du système, puis vérifier si le système peut être restauré dès que possible. Pour la récupération automatique, l'exactitude de la réinitialisation, des mécanismes de point de contrôle, de la récupération des données et du redémarrage doit être vérifiée ; pour les systèmes de récupération par intervention manuelle, le temps de réparation moyen doit être estimé et déterminer s'il se situe dans la plage acceptable.
Tests de sécurité : les tests de sécurité sont utilisés pour vérifier le mécanisme de protection au sein du système afin de prévenir les intrusions illégales. Lors des tests de sécurité, les testeurs jouent le rôle d’essayer d’envahir le système et utilisent diverses méthodes pour tenter de franchir les lignes de défense. Ainsi, la norme en matière de conception de la sécurité des systèmes consiste à trouver des moyens de rendre plus coûteuse l’intrusion dans le système. Les tests de sécurité vérifient la capacité du système à empêcher les intrusions illégales. Lors du test de sécurité, les testeurs se sont fait passer pour des intrus illégaux et ont utilisé diverses méthodes pour tenter de franchir les lignes de défense. Par exemple, ① essayez tous les moyens pour intercepter ou déchiffrer les mots de passe ; ② personnalisez spécialement le logiciel pour détruire le mécanisme de protection du système ; ③ provoquez délibérément une défaillance du système et tentez d'y accéder illégalement pendant sa récupération ; ④ essayez de déduire les informations requises en parcourant des données non confidentielles, etc. Théoriquement, avec suffisamment de temps et de ressources, aucun système n’est inaccessible. Par conséquent, le principe de la conception de la sécurité des systèmes est de faire en sorte que le coût d’une intrusion illégale dépasse la valeur des informations protégées. À ce stade, il n’y a aucun profit pour les intrus illégaux.
Tests de stress : les tests de stress font référence à la mise en œuvre d'un système utilisant un trafic, une fréquence ou des volumes de données anormaux avec des ressources normales. Les tests suivants peuvent être effectués lors du test de pression :
① Si le nombre moyen d'interruptions est de une à deux par seconde, alors le scénario de test spécial est conçu pour générer 10 interruptions par seconde.
② Augmentez la quantité de données d'entrée d'un ordre de grandeur pour déterminer la réponse de la fonction d'entrée.
③ Dans le système d'exploitation virtuel, des scénarios de test nécessitant la quantité maximale de mémoire ou d'autres ressources sont requis, ou des données de stockage sur disque excessives sont générées.
Dans des circonstances normales, le système doit être testé à plusieurs reprises. En raison des limitations du temps et des fonctions du système, le système ne peut pas être parfait. Il est donc nécessaire d’examiner ensemble les différentes méthodes de test.
Test de résistance
Les tests de résistance vérifient la résistance d'un programme à des conditions anormales. Les tests de résistance obligent toujours le système à s'exécuter dans des configurations de ressources anormales. Par exemple, ① Lorsque la fréquence normale des interruptions est d'une à deux par seconde, exécutez un scénario de test qui génère dix interruptions par seconde ; ② Augmentez quantitativement le taux d'entrée des données pour vérifier la capacité de réponse de la sous-fonction d'entrée ; ③ Le maximum espace de stockage requis pour le fonctionnement (ou d'autres ressources) ; ④ Exécuter des scénarios de test susceptibles de provoquer un crash du système d'exploitation de la mémoire virtuelle ou une instabilité violente des données du disque, etc.
Test de performance
Pour ces systèmes temps réel et embarqués, même si la partie logicielle répond aux exigences fonctionnelles, elle peut ne pas être en mesure de répondre aux exigences de performances. Bien qu'à partir du test unitaire, chaque étape de test inclut des tests de performances. Le testeur principal estime que seulement une fois que le système est véritablement intégré, il ne sera pas en mesure de répondre aux exigences de performances dans l'environnement réel.Les tests de performances du système sont conçus pour accomplir cette tâche afin de tester les performances opérationnelles de manière complète et fiable. Les tests de performances sont parfois combinés avec des tests de résistance et nécessitent souvent la prise en charge d'autres logiciels et matériels.
6.1.3 Signification du test et précautions
Les tests logiciels sont un maillon extrêmement important dans le processus de conception de logiciels et une garantie importante pour garantir la qualité des logiciels. La qualité de la méthode de test affectera directement la qualité du logiciel. Les tests de logiciels peuvent identifier les erreurs et les lacunes et les améliorer, obtenant ainsi un système efficace et fiable.
Les logiciels doivent être testés et analysés sous plusieurs angles afin que les erreurs puissent être détectées. Il est préférable de trouver des personnes qui n'ont rien à voir avec le système de conception ou des analystes lors des tests. Parce que lors du développement de logiciels, les développeurs ont formé leur propre état d'esprit et sont toujours liés par cet état d'esprit lors des tests. Il est difficile de trouver des erreurs et il est facile pour les personnes et les analystes qui n'ont rien à voir avec la conception de les trouver. s'est produit.
Vous devez être patient et prudent pendant le processus de débogage du programme. Une légère erreur empêchera toute la fonction d'être réalisée et beaucoup de temps sera perdu pour la modifier. Il convient de prêter attention aux aspects suivants :
1> Erreur grammaticale
Les erreurs de syntaxe sont des erreurs souvent rencontrées. Par exemple, une commande mal orthographiée ou des paramètres incorrects passés à une fonction généreront une erreur. Des erreurs de syntaxe peuvent vous empêcher de continuer à écrire du code.
2> Erreur logique
Les erreurs logiques peuvent souvent être latentes et difficiles à détecter. Lorsqu'il y a des erreurs logiques causées par des erreurs de frappe ou par le flux logique du programme, celui-ci peut s'exécuter correctement, mais les résultats produits sont erronés. Par exemple, lorsqu'un signe supérieur à est utilisé au lieu de comparer les valeurs alors qu'un signe inférieur à doit être utilisé, des résultats incorrects seront renvoyés.
3> Erreur d'exécution
Les erreurs d'exécution sont causées par des instructions qui tentent d'effectuer des actions impossibles pendant l'exécution. Les erreurs d'exécution doivent être corrigées pour garantir la fiabilité du fonctionnement du logiciel.
Au cours du processus de développement de ce jeu, diverses mesures efficaces ont été utilisées pour tester la qualité du logiciel. Le jeu a été testé pour la rotation des limites, le retournement de blocs et les tests transfrontaliers, ce qui a grandement assuré la qualité du logiciel et les taux d'erreur. Cependant, il peut encore y avoir d'autres erreurs et défauts dans le système. Par conséquent, le jeu doit passer par des tests répétés pour minimiser autant que possible les bugs.
6.2 Test des codes de jeu et des algorithmes
1> Lors de l'écriture de la méthode get(), une valeur de retour est requise, mais il n'y a pas d'instruction return dans le programme, provoquant une erreur lors de la compilation du programme. La solution consiste à ajouter une instruction return à la méthode et à renvoyer le contenu correspondant.
2> Lors de l'utilisation d'une fonction aléatoire pour générer des blocs, aucun paramètre n'est transmis à chaque bloc et la compilation ne peut pas réussir. La solution est de passer les paramètres correspondants en fonction de la construction de chaque bloc.
3> Lors de l'écriture de la position par défaut de chaque carré du carré en T, initialisez la variable i qui contrôle la position du carré à 0. Le résultat de l'opération est que le carré en forme de T devient un carré vertical par défaut. La solution consiste à changer la valeur d'initialisation de la variable i en 1 pour obtenir l'effet souhaité.
4> Lors de l'exécution du programme, les scores statistiques ne sont que les scores après l'élimination de chaque ligne complète, et les scores précédents seront écrasés et il n'y aura pas d'accumulation. La solution est de remplacer le "score=" dans le programme par "score+=", afin que les scores puissent être accumulés.
5> Les erreurs dans le processus d'algorithme se concentrent principalement sur la façon de détecter et d'éliminer les blocages, sur la manière de traiter l'accumulation de scores après avoir terminé le niveau et sur l'opportunité de mettre à niveau. Ces aspects ont finalement été résolus après des discussions avec des camarades de classe et des documents de référence.
6.3 Test fonctionnel des options du menu de l'interface de jeu
1> Test du menu « Jeu »
Tableau 6.1 Scénario de test du menu de jeu
| Numéro de cas de test |
Nom du projet de test |
Étapes d'exécution des tests |
sortir |
Résultats de test |
| 01 |
Test du bouton "Démarrer" |
Cliquez sur "Jeu" → "Démarrer" |
réinitialisation du jeu |
succès |
| 02 |
Test du bouton "Fin de partie" |
Cliquez sur "Jeu" → "Fin de partie" |
jeu terminé |
succès |
| 03 |
Test des boutons "de base" |
Cliquez sur "Jeu" → "Basique" |
Le niveau de jeu est sélectionné comme débutant |
succès |
| 04 |
Test du bouton "Intermédiaire" |
Cliquez sur "Jeu" → "Intermédiaire" |
Le niveau de jeu est sélectionné comme intermédiaire |
succès |
| 05 |
Test du bouton "Avancé" |
Cliquez sur "Jeu" → "Avancé" |
Le niveau de jeu est sélectionné comme Avancé |
succès |
| 06 |
Test du bouton "Personnalisé" |
Test du bouton "Personnalisé" |
Une boîte de dialogue apparaît pour modifier les informations personnalisées |
succès |
| 07 |
Test du curseur « Vitesse de chute » |
Cliquez sur "Jeu" → "Personnaliser" → "Vitesse de chute" |
Faites glisser le curseur pour modifier la vitesse de chute du bloc |
succès |
| 08 |
Test du bouton radio « Forme de bloc » |
Cliquez sur le bouton radio "Jeu" → "Personnaliser" → "Forme de bloc". |
Vous pouvez choisir la forme du bloc parmi élémentaire, intermédiaire ou avancée pour modifier la forme du bloc. |
succès |
| 09 |
Test de la boîte de sélection "Si la boîte monte automatiquement" |
Cliquez sur la boîte de sélection "Jeu" → "Personnaliser" → "Si le bloc montera automatiquement". |
Vous pouvez vérifier les petits carrés. Si vous les cochez, les carrés monteront automatiquement. Si vous ne les cochez pas, les carrés ne monteront pas automatiquement. |
succès |
| dix |
Test de la boîte de sélection « S'il faut jouer du son pendant le jeu » |
Cliquez sur la boîte de sélection "Jeu" → "Personnaliser" → "Si des sons doivent être émis pendant le jeu". |
Vous pouvez cocher la petite case. Si elle est cochée, le son sera joué pendant le jeu. Si elle n'est pas cochée, le son ne sera pas joué pendant la partie. |
succès |
| 11 |
Champ de sélection "Modifier l'arrière-plan" |
Cliquez sur la boîte de sélection "Jeu" → "Personnaliser" → "Si des sons doivent être émis pendant le jeu". |
Vous pouvez cocher le petit carré. Si vous le sélectionnez, l'image de fond du jeu sera modifiée. Si vous la décochez, l'image de fond du jeu ne sera pas modifiée. |
succès |
| 12 |
Test des boutons OK et Annuler |
Cliquez sur le bouton "Jeu" → "Personnaliser" → "OK" ou "Annuler". |
Cliquez sur OK pour enregistrer les paramètres modifiés et quitter la boîte de dialogue ; cliquez sur Annuler pour quitter la boîte de dialogue sans modifier les paramètres. |
succès |
| 13 |
Test du bouton "Couleur du bloc" |
Cliquez sur "Jeu" → "Couleur du bloc" |
Une boîte de dialogue apparaît et vous pouvez modifier la couleur du bloc, HSB, RVB et d'autres informations personnalisées. |
succès |
| 14 |
Test du bouton "Quitter" |
Cliquez sur "Jeu" → "Quitter" |
Quittez le jeu et fermez la fenêtre principale de l'interface |
succès |
2> Test du menu "Aide"
Tableau 6.2 Scénario de test du menu "Aide"
| Numéro de cas de test |
Nom du projet de test |
Étapes d'exécution des tests |
sortir |
Résultats de test |
| 15 |
Test du bouton "À propos" |
Cliquez sur "Aide" → "À propos" |
Une boîte de dialogue apparaît, demandant la version du jeu et d'autres informations. |
succès |
6.4 Tests fonctionnels des événements clés
Tableau 6.3 Scénarios de test de fonction d'événement clé
| Numéro de cas de test |
Nom du projet de test |
Étapes d'exécution des tests |
sortir |
Résultats de test |
| 16 |
Test de mouvement de bloc |
Pendant le jeu, cliquez sur "Gauche, Droite, Bas" |
Les blocs se déplacent normalement et ne sortent pas des limites |
succès |
| 17 |
Test de rotation des blocs |
Pendant le jeu, cliquez sur la touche de direction "haut" |
Les blocs peuvent être inversés sans frontières ni obstacles. |
succès |
6.5 Test de la fonction d'empilement et d'élimination de blocs
Tableau 6.4 Cas de test des fonctions d'empilement et d'élimination de blocs
| Numéro de cas de test |
Nom du projet de test |
Étapes d'exécution des tests |
sortir |
Résultats de test |
| 18 |
Test d'empilement de blocs |
Lorsque le bloc tombe au fond ou entre en contact avec un obstacle |
Les blocs sont empilés avec succès en bas |
succès |
| 19 |
Test d'élimination de blocs |
Lorsqu'une ligne complète se produit |
Toutes les lignes complètes sont éliminées et les blocs descendent un par un. |
succès |
| 20 |
test de fin de jeu |
Quand l'écran est plein |
Une fenêtre de session apparaît, invitant "Game Over" |
succès |
6.6 Résultats des tests
Après plusieurs méthodes de test pour tester divers aspects et fonctions du système, les résultats des tests montrent que le système répond fondamentalement aux exigences globales de conception et que les fonctions attendues sont pratiquement remplies. Le système peut essentiellement répondre aux exigences au début de la conception et du développement, et le test est terminé.Cependant, la fonction globale n'est pas assez puissante et l'innovation est légèrement inférieure.En tant que première version de développement, le jeu doit encore être amélioré dans de nombreux aspects tels que les fonctions et la conception de l'interface.
en conclusion
Avant de faire mon projet de fin d'études, mon développement lié à Java se limitait au niveau des connaissances théoriques. Ce projet de fin d'études m'a fait comprendre le principe selon lequel « ce que vous apprenez sur papier est finalement superficiel, mais vous devez le pratiquer si vous le savez. " Le manque d’expérience réelle en développement de logiciels est la conclusion que je me suis tirée. Grâce à ce projet de fin d'études, j'ai réalisé toutes les tâches de développement du jeu Tetris. J'ai rencontré de nombreux problèmes tout au long du processus de développement, tels que le dessin et la déformation des blocs, les problèmes de création de threads, le contrôle de synchronisation, le jugement des lignes complètes, le traitement des lignes d'élimination et la mise en œuvre de la fonction d'enregistrement du score le plus élevé, mais j'ai finalement résolu les un par un. , certains des points les plus importants sont résumés comme suit :
Tout d'abord, afin de me familiariser avec les fonctions et la conception associées de Tetris, je télécharge souvent la version autonome du jeu Tetris à partir des principaux sites de téléchargement de jeux, j'étudie la mise en œuvre des fonctions et la conception de l'interface, réfléchis et consulte les données pour l'analyse et la conception progressive. Après des modifications et des arguments répétés, le développement de l'ensemble du jeu a été achevé.
Deuxièmement, dans le processus de conception du jeu, j'adopte le modèle de conception du plus grossier au plus fin et le principe des tests du plus petit au plus grand. Concevez d'abord le cadre du jeu et testez-le couche par couche, puis ajoutez un code d'implémentation spécifique et effectuez progressivement des tests plus détaillés. Au cours du processus de conception, je rencontre souvent des problèmes. Grâce à des réflexions et des tests répétés, je découvre mes erreurs et les corrige, puis je passe à l'étape suivante pour m'assurer que tout se passe bien et je fais de mon mieux pour réduire la charge de travail de débogage finale.
Troisièmement, l'industrie du design de fin d'études peut être considérée comme un processus d'apprentissage constant de nouvelles choses.De l'incompréhension du design au début à la réussite à la fin, je réalise l'importance de l'apprentissage continu dans la pratique, ce qui est important pour moi trouver un emploi à l'avenir.importance éducative. Grâce à la création de mon projet de fin d'études, j'ai acquis une compréhension plus approfondie du cours Java, ce qui a également posé certaines bases pour mon futur emploi.
Le projet de fin d'études est la dernière étape de notre étape d'apprentissage en tant qu'étudiants. Il s'agit d'une application complète des connaissances de base et des connaissances professionnelles. Il s'agit d'un processus complet de réapprentissage puis d'amélioration. Le processus de capacité d'apprentissage, de réflexion indépendante et de capacité de travail des étudiants. est également une formation et un diplôme. Le niveau de conception reflète également le niveau complet de l'enseignement universitaire, de sorte que l'école attache une grande importance à la conception des diplômes et renforce l'orientation du travail de conception des diplômes et de l'éducation à la mobilisation. Dans le processus d'études universitaires, le projet de fin d'études est un élément important de notre participation sociale aux travaux pratiques, ainsi que de notre capacité à apprendre et à résoudre les problèmes de la vie, et constitue une transformation de la vie scolaire et de la vie sociale. Après avoir terminé mon projet de fin d'études, j'ai essayé d'intégrer la conception de recherche et les travaux pratiques. Cela nous permet davantage de renforcer nos capacités.
Après une période de travail acharné et avec l'aide de quelques camarades de classe et professeurs, j'ai enfin terminé mon projet de fin d'études, ce qui est une tâche importante. En regardant notre processus de conception, on peut dire que difficulté et facilité cohabitent. Parmi eux, intégrer les connaissances acquises à l'université est en fait un grand défi pour moi, et c'est aussi un test des connaissances universitaires.
Dans le processus de projet de fin d'études, nous avons rencontré de nombreuses difficultés, et beaucoup d'entre elles étaient des problèmes que nous n'avions jamais rencontrés auparavant. Si nous ne le faisions pas nous-mêmes, il pourrait être difficile de trouver les connaissances qui nous manquent dans une certaine mesure. Pour nous, trouver le problème, Pour résoudre le problème, c'est le plus pratique. Face à des problèmes difficiles à résoudre par soi-même, ces problèmes peuvent être résolus avec l'aide des enseignants et des étudiants tout en obtenant quelques informations, afin que le projet de fin d'études soit mené à bien. Il est entendu que la connaissance de ce projet est encore très approfondie, nous devons donc continuer à l'explorer non seulement maintenant, mais aussi dans le futur.
La combinaison de la théorie et de la pratique comprend non seulement la connaissance de la participation en classe, mais également la combinaison de la formation professionnelle et de l'orientation sur la manière dont les étudiants comprennent et abordent les choses socialement pertinentes. Les projets de fin d'études des étudiants, sous la direction de connaissances théoriques professionnelles, peuvent résoudre certains problèmes pratiques de diverses manières. Au cours du processus de conception, les étudiants peuvent utiliser les connaissances théoriques pour la pratique, non seulement pour approfondir leur compréhension des connaissances théoriques professionnelles, mais également pour enrichir et développer les connaissances théoriques de ce livre et les transformer en expériences et compétences de niveau supérieur. En raison du modèle d'enseignement existant, il existe une séparation importante entre les connaissances et compétences théoriques et la pratique de production. Les étudiants ne peuvent pas acquérir de connaissances en dehors de la salle de classe. Les problèmes pratiques de production sont souvent sans rapport avec l'apprentissage et ne peuvent pas être appliqués efficacement. Grâce à une sélection raisonnable de sujets, les étudiants sont amenés à utiliser consciemment les systèmes de connaissances et de compétences pour analyser et réfléchir, et contribuer à l'intégration organique des connaissances théoriques et de la pratique.
La société est en constante évolution. À l'heure actuelle, la société se transforme et se développe, et les exigences en matière de talents sont de plus en plus élevées. Utilisez la perspective pour examiner les problèmes, apprendre à innover et apprendre à s'adapter aux exigences du développement social. En dehors de l’école, entrez dans la société, saisissez les opportunités d’aujourd’hui et créez l’avenir. L'influence de l'enseignant et les connaissances du professeur m'ont permis de comprendre de nombreuses vérités et d'affronter les défis futurs avec un certain esprit d'innovation.
Bref, pour ce projet de fin d'études, j'ai le sentiment que je me suis non seulement familiarisé avec certaines connaissances professionnelles qu'avant, mais que j'ai également exercé mes capacités pratiques, et j'ai le sentiment d'avoir beaucoup gagné. En même temps, vous ressentirez également un petit sentiment d’accomplissement car vous avez travaillé dur pendant cette tâche. Dans le travail futur, nous devrions également travailler dur, sans chercher le meilleur, mais seulement mieux ! Je tiens également à exprimer ma sincère gratitude à mes instructeurs et camarades de classe pour leur aide dans ce processus de projet de fin d'études !
Le programme répond essentiellement aux besoins des utilisateurs, tant sur le plan technique que fonctionnel. Cependant, en raison de la conception initiale, les fonctions ne sont pas suffisamment parfaites et les détails de conception sont encore insuffisants.
这次的毕业设计，我受益匪浅，让我的思维方式更加缜密，能多个角度的看待、处理问题；知道遇到问题该如何去分析问题、解决问题。相信这些都会让我在以后的工作中受益无穷的。
参考文献
[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）。第一个人把球打乱后，其他人依照不同规则轮流将球射入落袋里。俄罗斯方块在这一基本框架中加入了电脑控制的成分——不光是玩家要整理方块，电脑还会不断从上方扔下额外的方块来制造凌乱。游戏看起来就是整一个漫无目的的过程，完全没有寓教于乐的成分在内，也没有深远的社交或是心理意义，但是我们却意外地为此着迷。
Il existe un phénomène psychologique typique appelé « effet Zaigarnik », du nom du psychologue russe Bruma Zegarnik. Dans les années 1830, Zeigarnik découvrit dans un café animé que les serveurs avaient des souvenirs incroyables, mais seulement jusqu'à ce que le repas soit livré. Ils peuvent se rappeler ce qu'une table de 12 personnes a commandé, mais une fois la nourriture et les boissons servies, ils oublient tout et ne peuvent plus se souvenir de leurs souvenirs auparavant solides. Zeigarnik a donné son nom à ce phénomène de persistance dans la mémoire de tâches inachevées.
L’effet Zeigarnik est l’une des raisons pour lesquelles les émissions de renseignement sont si populaires. Vous ne vous souciez peut-être pas de l'année de création de la BBC ni du nombre de pays dans le monde qui possèdent au moins un McDonald's, mais une fois qu'une question comme celle-ci se pose, vous vous sentirez mal à l'aise si vous ne connaissez pas la réponse (d'ailleurs, la réponse est 1927 et 61 %). Les questions persistent dans votre esprit jusqu'à ce qu'elles trouvent une réponse.
Principe du jeu
Tetris garde son emprise sur nos nerfs en créant constamment des tâches. Chaque lien du jeu nous amène à résoudre un mystère. Après avoir aligné ou complété une colonne, les graphiques disparaissent, mais de nouveaux apparaissent constamment et le cycle recommence. Les chaînes de tâches partiellement résolues et nouvellement formées sont très pratiques pour passer le temps, et des sentiments répétés de satisfaction et d'anxiété remplissent chaque instant.
Une autre raison de la popularité de Tetris est que les tâches à accomplir sont juxtaposées à des solutions potentielles - chacun des blocs qui ont progressivement émergé a sa propre façon de se placer. Tetris est un monde visuel simple où des solutions peuvent être rapidement trouvées en manipulant cinq boutons (gauche, droite, tourner à gauche, tourner à droite et atterrir, bien sûr). Des études sur les joueurs de Tetris montrent que les gens préfèrent généralement faire pivoter les blocs pour voir s'ils correspondent, plutôt que d'y penser en regardant les blocs tomber. Bien sûr, les deux méthodes sont possibles, mais dans le monde de Tetris, c'est l'action qui prime toujours - et c'est la clé de l'attrait. Contrairement à la vie, Tetris relie directement ce que nous voyons et pensons lorsque nous traitons de problèmes, et nous pouvons prendre des mesures immédiates pour résoudre le problème.
L’effet Zeigarnik est une description d’un phénomène, mais il ne peut en expliquer la cause et l’effet. C'est une astuce couramment utilisée par les psychologues. Il semble qu'ils aient résolu les mystères des êtres humains en les nommant. En fait, ils n'ont fait qu'avidement leur donner leur nom et n'ont pas du tout résolu le problème. Une explication raisonnable de cette réalité est que les circuits cérébraux se réorganisent au cours du processus d’atteinte des objectifs. Si cet objectif est atteint, les pensées iront vers autre chose.
Les jeux de réflexion exploitent le principe de réussite psychologique pour nous frustrer continuellement jusqu'à ce que nous soyons satisfaits. Tetris va encore plus loin en créant une chaîne continue entre l'échec et le succès. Tel un parasite intelligent, Tetris exploite le plaisir psychologique des gens à terminer et réutiliser des jeux. Pendant que nous jouons, nous nous amusons brièvement à disposer les blocs, même si la partie rationnelle et mature de notre personnalité comprend qu'il s'agit fondamentalement d'un jeu dénué de sens. Mais n’est-ce pas le cas de tous les jeux amusants, n’est-ce pas ?
https://download.csdn.net/download/dwf1354046363/87813602