Comment implémenter des jeux de combat entre propriétaires et de devinettes en Java ?

Mini jeu Dou DiZhu : Mélanger et distribuer des cartes

Description de la tâche

Écrire un programme pour distribuer et distribuer des cartes dans Dou DiZhu Il est nécessaire de terminer le processus de mélange et de distribution de cartes conformément aux règles de Dou DiZhu The. les cartes sont composées de couleurs, de couleurs et de chiffres (y compris les lettres J, Q, K et A), et les couleurs des couleurs comprennent les cœurs, les piques, les carreaux et les trèfles. Il y a aussi des grands rois et des petits rois. L'ordre de ces 54 cartes est perturbé et trois joueurs participent au jeu. Chaque joueur tire à tour de rôle une carte à la fois, et les trois cartes restantes sont utilisées comme cartes fermées. Le programme se termine et les cartes et cartes fermées rentrent. la main de chaque joueur est imprimée.

Résultats d'exécution

Objectif de la tâche

• Apprenez à analyser les idées de mise en œuvre du programme "Dou Di Zhu Mini Game - Shuffling and Dealing Cards".

• Capable de compléter de manière indépendante l'écriture de code, la compilation et le fonctionnement du programme "Doudizhu Mini Game - Shuffling and Dealing Cards" en fonction d'idées.

• Maîtrisez les caractéristiques des collections ArrayList et HashMap et améliorez l'utilisation des boucles for.

Idée de mise en œuvre

① Pour mettre en œuvre le programme de cartes, vous devez d'abord ajouter 54 cartes au programme. Ces cartes comprennent 13 de chacun des cœurs, des piques, des trèfles et des carreaux, plus le roi et le roi.

② Effectuez une boucle imbriquée sur l'ensemble de combinaisons et l'ensemble de numéros, combinez les combinaisons et les numéros pour former 52 cartes et attribuez-leur des numéros. Placez les cartes combinées dans l'ensemble HashMap. La valeur clé de l'ensemble est le nombre. , la valeur est la carte assemblée, ainsi que le grand roi et le petit roi. En raison des règles d'assemblage incohérentes, ces deux cartes doivent être ajoutées à la collection HashMap en utilisant la méthode add() séparément.

③Créez un ensemble de numéros et utilisez cet ensemble de numéros pour remplacer les cartes afin de terminer les opérations de mélange et de distribution des cartes. Puisqu'il y a 54 cartes au total, la plage de l'ensemble créé est de 0 à 53.

④ Vous pouvez utiliser la méthode shuffle() de la classe Collections pour terminer l'opération de brassage de la collection de numéros afin d'obtenir l'effet de brassage. Puisqu'il n'y a que trois personnes, vous pouvez utiliser une boucle for pour distribuer les nombres représentant différentes cartes à différentes personnes et cartes fermées en prenant le reste du nombre et 3 pour obtenir l'effet de distribution de cartes.

⑤Une fois le mélange et la distribution des cartes terminés, le tri peut être effectué via la méthode sort() de la classe Collections. Ensuite, en améliorant la collection HashMap de la boucle for, les chaînes de cartes correspondantes sont recherchées en fonction des numéros et stockées. dans la collection de chaînes nouvellement créée. Enfin, la collection de chaînes est affichée.

Code d'implémentation

package Swing;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 public class DoudiZhu {
     public static void main(String[]args) {
         //准备花色
         ArrayList<String>color=new ArrayList<String >();
         color.add("黑桃");
         color.add("红桃");
         color.add("方块");
         color.add("梅花");
         //准备数字，用列表将纸牌从大到小排列
         ArrayList<String >number=new ArrayList<String >();
         for(int i=3;i<=10;i++){
             number.add(i+"");
         }
         number.add("J");
         number.add("Q");
         number.add("K");
         number.add("A");
         number.add("2");
         //定义一个map集合，用来将数字与每一张纸牌进行对应
         HashMap<Integer,String>map=new HashMap<Integer,String>();
         //纸牌编号
         int index=0;
         //循环纸牌数字
         for(String thisNumber:number){
             //循环纸牌花色
             for(String thisColor:color){
                 //将花色与数字组合，形成52张牌，并赋予编号
                 map.put(index++,thisColor+thisNumber);
             }
         }
         map.put(index++,"小王");
         map.put(index++,"大王");
         //创建0-53的数字集合代表54张牌
         ArrayList<Integer>cards=new ArrayList<Integer>();
         for(int i=0;i<=53;i++){
             cards.add(i);
         }
         //洗牌，使用Collections工具类的shuffle()方法
         Collections.shuffle(cards);
         //创建三个玩家和底牌
         ArrayList<Integer>iPlayer=new ArrayList<Integer>();
         ArrayList<Integer>iPlayer2=new ArrayList<Integer>();
         ArrayList<Integer>iPlayer3=new ArrayList<Integer>();
         ArrayList<Integer>iSecretCards=new ArrayList<Integer>();
         //遍历这副洗好的牌，遍历的过程中，将牌发到三个玩家和底牌中
         for(int i=0;i<cards.size();i++){
             if(i>=51){
                 //留取三个底牌
                 iSecretCards.add(cards.get(i));
 
             }else{
                 if(i%3==0){//与3取余为0的发给玩家1
                     iPlayer.add(cards.get(i));
                 }else if(i%3==1){//与3取余为1的发给玩家2
                     iPlayer2.add(cards.get(i));
                 }else {//剩余的牌发给玩家3
                     iPlayer3.add(cards.get(i));
                 }
             }
         }
         //对每个人手中的牌进行排序，使用的使Collections工具类中的sort()方法
         Collections.sort(iPlayer);
         Collections.sort(iPlayer2);
         Collections.sort(iPlayer3);
         ArrayList<String>sPlayer=new ArrayList<String>();
         ArrayList<String>sPlayer2=new ArrayList<String>();
         ArrayList<String>sPlayer3=new ArrayList<String>();
         ArrayList<String>sSectCards=new ArrayList<String>();
         //循环主键，从map中获取纸牌
         for (Integer key:iPlayer){
             sPlayer.add(map.get(key));
         }
         for (Integer key:iPlayer2){
             sPlayer2.add(map.get(key));
         }
         for (Integer key:iPlayer3){
             sPlayer3.add(map.get(key));
         }
         for (Integer key:iSecretCards){
             sSectCards.add(map.get(key));
         }
         //将分发的牌显示出来
         System.out.println("玩家1:"+sPlayer);
         System.out.println("玩家2:"+sPlayer2);
         System.out.println("玩家3:"+sPlayer3);
         System.out.println("底牌:"+sSectCards);
     }
 }

Jeu de devinettes

Description de la tâche

Écrivez un jeu de devinettes. Ce jeu est "vous trouvez un nombre, je devinerai". 9, et le clavier utilisateur Entrez un numéro deviné. Si le numéro saisi est le même que le numéro pré-généré en arrière-plan, cela signifie que la supposition est correcte. À ce moment, le programme imprimera « Félicitations, la réponse est. correct." S'ils ne sont pas identiques, comparez le numéro saisi avec le numéro d'arrière-plan. La taille du numéro pré-généré. S'il est plus grand, "Désolé, votre estimation est trop élevée!" sera imprimé ; si c'est le cas petit, « désolé, votre supposition est trop petite » sera imprimé ; si c'est toujours faux, le jeu continuera jusqu'à ce que le nombre soit correct.

Résultats d'exécution

Objectif de la tâche

• Apprenez à analyser les idées de mise en œuvre du programme "Jeu de devinettes".

• Compléter de manière indépendante l'écriture, la compilation et le fonctionnement du code source du "jeu de devinettes de nombres" basé sur l'idée.

• Maîtriser l'utilisation de la structure de sélection if et des instructions de structure de boucle while pour effectuer des opérations dans les programmes.

Idée d'implémentation

①Pour réaliser cette fonction, le programme doit d'abord pré-générer un nombre aléatoire de 0 à 9 en arrière-plan. Pour générer un nombre aléatoire, vous pouvez utiliser la méthode nextInt(int n) dans Random. classe. Sa définition spécifique est la suivante :

 public int nextInt(int n)

②Pour utiliser le clavier pour saisir le numéro deviné, vous pouvez utiliser la classe Scanner, qui permet à l'utilisateur de saisir le numéro à partir du clavier.

 Scanner sc=new Scanner(System.in);
 int i=sc.nextInt();

③Après avoir saisi le numéro, vous devez comparer le numéro saisi par le clavier et le numéro pré-généré en arrière-plan. Puisque deviner le numéro ne réussit pas nécessairement une fois, cela sera probablement fait plusieurs fois. Le programme peut être saisi plusieurs fois à partir du clavier via une boucle while. Chaque fois que vous entrez, devinez si le nombre est bon ou faux. Si vous avez bien deviné, sortez de la boucle et affichez « Félicitations, vous avez la bonne réponse ! » et le jeu se termine.

④ Si vous vous trompez, utilisez l'instruction if...else pour juger et diviser l'erreur en deux résultats : deviner trop haut et deviner trop bas. Si la supposition est trop élevée, imprimez « désolé, votre supposition est trop petite ! » et continuez le cycle suivant ; si la supposition est trop petite, imprimez « désolé, votre supposition est trop petite ! » et continuez le cycle suivant. Sur la base du résultat, un indice est donné, puis le nombre continue d'être deviné et le jeu continue.

Code d'implémentation

 package math;
 import java.util.Random;
 import java.util.Scanner;
 public class CaishuZi {
     public static void main(String[] args) {
         int randomNumber = new Random().nextInt(10);
         System.out.println("随机数已经生成");
         System.out.println("请输入你所猜的数字");
         Scanner sc =new Scanner(System.in);
         int enterNumber =sc.nextInt();
         //通过while循环，进行猜数字对错判断
         //猜对，跳出循环，游戏结束
         while(enterNumber!=randomNumber){
             //猜错了，根据结果，给出提示，接着猜数字，游戏继续
             if(enterNumber>randomNumber){
                 //猜大了给出的提示
                 System.out.println("sorry，你猜大了");
             }else{
                 //猜小了，给出的提示
                 System.out.println("sorry，你猜小了");
             }
             //输入猜的数字
             System.out.println("请输入你猜的数字");
             enterNumber = sc.nextInt();
         }
         System.out.println("恭喜你，答对了!");
     }
 }

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!