动物换位（含有源码）

﹏ヽ暗。殇╰゛Y 2024-03-26 11:07 22阅读 0赞

## 动物换位（含有源码） ##

这个是Java课程设计上面的一个小游戏，动物换位，这里给出这个源代码，供大家一起学习。

项目的题目：  
设计GUI界面的动物换位游戏，游戏结果是让左、右两组动物交换位置。具 体要求如下：  
①在水平排列的7个位置上左、右各有3个类型相同的动物，中间的位置上没有动物。左边动物将其右侧视为自己的前进方向，右边动物将其左侧视为自己的前进方向。  
②单击一个动物，如果该动物的前方位置上没有动物，该动物就跳跃到该位置上，如果该动物的前方位置上有其他动物，但相隔一位的位置上没有其他动物，该动物就越过自己前面的动物跳跃至该隔位上，其他情形下该动物不能跳跃（跳跃时不能越过两个位置)。  
③左面的动物只能向右方跳跃，右面的动物只能向左方跳跃。  
①单击“撒销”按钮撤销上一次移动的动物，单击“重新开始”按钮可重新开始游戏

**项目结构**  
![在这里插入图片描述][4966d4ba8a594f488bdbcc20172cccce.png]

**运行效果**  
![在这里插入图片描述][18652f37143146f295035e9e0daa0317.png]

### 完整代码 ###

#### data ####

##### Animal #####

public abstract class Animal {
        
        String name ;
        Point [] allCanAtPoint;    //全部点位置
        Point point;               //动物当前所在的点位置
        ViewForAnimal animalView;  //动物的外观视图
        public void setAtPoint(Point p) {
        
            if(p!=null){
        
               point = p;
               point.setIsHaveAnimal(true);
               point.setAtPointAnimal(this);
            } 
        }
        public Point getAtPoint() {
        
            return point;
        }
        public void setAllCanAtPoint(Point [] point){
        
            allCanAtPoint = point;
        }
        public void setAnimalView(ViewForAnimal animalView) {
        
            this.animalView = animalView;
            animalView.setAnimal(this);
        }
        public ViewForAnimal getAnimalView() {
        
             return animalView;
        }
        public void setName(String s) {
        
            name = s;
        }
        public String getName() {
        
            return name;
        }
        public abstract boolean move();
    }

##### LeftAnimal #####

public class LeftAnimal extends Animal{
        
       public boolean move(){
        
          int k = -1;
          boolean successMove = false;
          Point p = getAtPoint();
          for(int i=0;i<allCanAtPoint.length;i++){
        
             if(allCanAtPoint[i].equals(p)){
         
                k = i; //找到动物当前所处的位置:allCanAtPoint[k]
                break;
             }
          } 
          if(k==allCanAtPoint.length-1){
        //已经在最右面的点位置
              return false;
          }
          if(allCanAtPoint[k+1].isHaveAnimal()==false) {
         //前面位置上没有动物
             this.setAtPoint(allCanAtPoint[k+1]);
             successMove = true;
             p.setAtPointAnimal(null);
             return successMove ;
          }
          if((k+1)==allCanAtPoint.length-1){
         //前面位置上是已经到达终点的动物
              return false;
          }
          if(allCanAtPoint[k+2].isHaveAnimal()==false) {
        //前方隔位上没有动物
             this.setAtPoint(allCanAtPoint[k+2]);
             successMove = true;
             p.setAtPointAnimal(null);
             return successMove ;
          }
          return successMove ;  
       }  
    }

##### Point #####

public class Point{
        
        int x,y; 
        boolean haveAnimal; 
        Animal animal=null; //在该点位置上的动物
        public void setX(int x){
        
            this.x=x;
        }
        public void setY(int y){
        
            this.y=y;
        }
        public boolean isHaveAnimal(){
        
            return haveAnimal;
        }
        public void setIsHaveAnimal(boolean boo){
        
            haveAnimal=boo;
        }
        public int getX(){
        
            return x;
        }
        public int getY(){
        
            return y;
        }
        public void setAtPointAnimal(Animal animal){
        
            this.animal=animal;
            if(animal!=null) {
        
               haveAnimal = true;
            }
            else {
        
               haveAnimal = false;
            }
        }
        public Animal getAtPointAnimal(){
        
            return animal;
        }
    }

##### RightAnimal #####

public class RightAnimal extends Animal{
        
       public boolean move(){
        
          int k = -1;
          boolean successMove = false;
          Point p = getAtPoint();
          for(int i=0;i<allCanAtPoint.length;i++){
        
             if(allCanAtPoint[i].equals(p)){
        
                k = i;
                break;
             }
          }
          if(k==0){
          //�Ѿ���������ĵ�λ��
              return false;
          }
          if(allCanAtPoint[k-1].isHaveAnimal()==false) {
        //ǰ��λ����û�ж���
             this.setAtPoint(allCanAtPoint[k-1]);//���ﵽ��allCanAtPoint[k-1]��
             successMove = true;
             p.setAtPointAnimal(null);           //p������Ϊ�޶���
             return successMove ;
          }
          if((k-1)==0){
           //ǰ��λ�������Ѿ������յ�Ķ���
              return false;
          }
          if(allCanAtPoint[k-2].isHaveAnimal()==false) {
        //ǰ����λ��û�ж���
             this.setAtPoint(allCanAtPoint[k-2]); //���ﵽ��allCanAtPoint[k-2]��
             successMove = true;
             p.setAtPointAnimal(null);           //p������Ϊ�޶���
             return successMove ;
          }
          return successMove ;
       }
    }

##### ViewForAnimal #####

import javax.swing.JPanel;
    public abstract class ViewForAnimal extends JPanel {
        
        public abstract void setAnimal(Animal animal);
        public abstract void setImage(String name);
        public abstract Animal getAnimal();
        public abstract void setAnimalViewLocation(int x,int y);
        public abstract void setAnimalViewSize(int w,int h);
    }

#### gui ####

##### AppWindow #####

import javax.swing.*;
    import java.awt.*;
    import ch1.view.GamePanel;
    public class AppWindow extends JFrame {
        
        GamePanel gamePanel;
        public AppWindow(){
        
           setTitle("动物换位游戏");
           gamePanel = new GamePanel();
           gamePanel.setAnimalCount(6);
           gamePanel.setLeftAnimalImage("image/cat.jpg");
           gamePanel.setRightAnimalImage("image/dog.jpg");
           add(gamePanel,BorderLayout.CENTER);
           gamePanel.setBackground(Color.white);
           JPanel northP = new JPanel();
           northP.add(gamePanel.buttonReStart);
           northP.add(gamePanel.buttonRedo);
           add(northP,BorderLayout.NORTH);        
           setBounds(60,60,9*gamePanel.width+9*gamePanel.gap,300);  
           validate();
           setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
           setVisible(true); 
        }
        public static void main(String args[] ){
        
           AppWindow win = new AppWindow();  
        }
    }

#### Test ####

##### AppTest #####

import ch1.data.*;
    public class AppTest {
        
       public static void main(String [] args) {
        
           Point [] point = new Point[7];
           for(int i=0;i<point.length;i++) {
        
               point[i] = new Point();
               point[i].setX(i);
               point[i].setY(10);
           } 
           Animal [] left = new Animal[3];
           Animal [] right = new Animal[3];
           for(int i =0;i<left.length;i++ ){
        
              left[i] = new LeftAnimal();
              left[i].setName("è"+i);
              left[i].setAtPoint(point[i]);
              left[i].setAllCanAtPoint(point);
           } 
           for(int i =0;i<right.length;i++ ){
        
              right[i] = new RightAnimal();
              right[i].setName("��"+i);
              right[i].setAtPoint(point[4+i]);
              right[i].setAllCanAtPoint(point);
           } 
           input(point);
           if(right[0].move())
             input(point);
           if(left[2].move())
             input(point);
           if(left[1].move())
             input(point);
           if(right[0].move())
             input(point);
           if(right[1].move())
             input(point); 
           if(right[2].move())
             input(point); 
           if(left[2].move())
             input(point);
           if(left[1].move())
             input(point);
           if(left[0].move())
             input(point);
           if(right[0].move())
             input(point); 
           if(right[1].move())
             input(point);
           if(right[2].move())
             input(point); 
           if(left[1].move())
             input(point);
           if(left[0].move())
             input(point); 
           if(right[2].move())
             input(point);  
        }
        static void input(Point [] point){
        
           for(int i=0;i<point.length;i++){
        
              Animal animal=point[i].getAtPointAnimal();
              if(animal!=null)
                 System.out.print(animal.getName());
              else
                System.out.print("   ");  
           } 
           System.out.println();
        }
    }

#### view ####

##### AnimalView #####

import java.awt.*;
    import ch1.data.*;
    public class AnimalView extends ViewForAnimal{
        
       Animal animal;
       Image image;
       Toolkit tool;
       public AnimalView() {
        
          tool = getToolkit();
       }
       public void setAnimal(Animal animal){
        
          this.animal = animal;
       }
       public void setImage(String name){
        
          image = tool.getImage(name);
          repaint();
       }
     
       public Animal getAnimal() {
        
          return animal;
       }
       public void setAnimalViewLocation(int x,int y){
        
          setLocation(x,y);
       }
       public void setAnimalViewSize(int w,int h){
        
          setSize(w,h);
       }
       public void paintComponent(Graphics g){
        
          super.paintComponent(g);
          int w=getBounds().width;
          int h=getBounds().height;
          g.drawImage(image,0,0,w,h,this);
       }
    }

##### GamePanel #####

import javax.swing.*;
    import java.awt.*;
    import ch1.data.Animal;
    import ch1.data.Point;
    import ch1.data.ViewForAnimal;
    import ch1.data.LeftAnimal;
    import ch1.data.RightAnimal;
    import java.util.*;
    import java.awt.geom.*; 
    public class GamePanel extends JPanel {
        
        public int animalCount = -1;
        public Point [] point ;
        Animal []  leftAnimal,rightAnimal; 
        public ViewForAnimal [] leftAnimalView,rightAnimalView;//������ͼ
        public int width =90,height=70;  //������ͼ�Ĵ�С
        public int gap = 2;              //����֮��ļ�϶           
        public JButton buttonRedo;//������ť
        public JButton buttonReStart;//���¿�ʼ��Ϸ
        public Stack<Point> saveAnimalStep; //��Ŷ����߶���λ�ã��Ա�ָ�
        HandleAnimalMove handleAnimalMove;//������MouseEvent�ļ�����
        HandleRedo handleRedo;           //����ActionEvent�ļ����� 
        HandleReStart handleReStart;    //����ActionEvent�ļ�����
        public GamePanel(){
        
           setLayout(null);
           buttonRedo = new JButton("����");
           buttonReStart = new JButton("���¿�ʼ");
           saveAnimalStep = new Stack<Point>();
        }
        public void setAnimalCount(int n){
        
           if(n%2 != 0 ||n<=1) {
        
              System.out.println(n+"�ĸ���������");
              System.exit(0);
           } 
           removeAll();  //�����Ƴ�����ӵ��������е�ȫ�����
           animalCount = n;
           initPoitAndAnimal();  //��ʼ�������λ�ö���
           initLeftAnimalView(); //��ʼ����ߵĶ�����ͼ
           initRightAnimalView();
           registerListener();   //ע�������
        }
        private void initPoitAndAnimal(){
        //��ʼ�������λ�ö���
           point = new Point[animalCount+1];
           int posionX = width; //���λ�õ�x����
           int posionY = height;
           for(int i=0;i<point.length;i++) {
        
               point[i] = new Point();
               point[i].setX(posionX);
               point[i].setY(posionY);
               posionX = posionX+width+gap;
           } 
           int m = animalCount/2;
           leftAnimal = new LeftAnimal[m];
           rightAnimal = new RightAnimal[m];
           for(int i =0;i<leftAnimal.length;i++ ){
        
              leftAnimal[i] = new LeftAnimal();
              leftAnimal[i].setAtPoint(point[i]);
              leftAnimal[i].setAllCanAtPoint(point);
           } 
           for(int i =0;i<rightAnimal.length;i++ ){
        
              rightAnimal[i] = new RightAnimal();
              rightAnimal[i].setAtPoint(point[m+1+i]);
              rightAnimal[i].setAllCanAtPoint(point);
           }  
        }
        private void initLeftAnimalView(){
        //��ʼ����ߵĶ�����ͼ
           int m = animalCount/2;
           leftAnimalView = new ViewForAnimal[m];
           for(int i =0;i<leftAnimalView.length;i++ ){
        
              leftAnimalView[i] = new AnimalView();
              leftAnimal[i].setAnimalView(leftAnimalView[i]);
              Point p = leftAnimal[i].getAtPoint();
              int x = p.getX();
              int y = p.getY();
              add(leftAnimalView[i]);
              //������ͼ����λ�úͶ������ڵ���ͬ��
              leftAnimalView[i].setAnimalViewLocation(x,y);
              leftAnimalView[i].setAnimalViewSize(width,height);
           } 
        }
        private void initRightAnimalView(){
        //��ʼ���ұߵĶ�����ͼ
           int m = animalCount/2;
           rightAnimalView = new ViewForAnimal[m];
           for(int i =0;i<rightAnimalView.length;i++ ){
        
              rightAnimalView[i] = new AnimalView();
              rightAnimal[i].setAnimalView(rightAnimalView[i]);
              Point p = rightAnimal[i].getAtPoint();
              int x = p.getX();
              int y = p.getY();
              add(rightAnimalView[i]);
              rightAnimalView[i].setAnimalViewLocation(x,y);
              rightAnimalView[i].setAnimalViewSize(width,height);
           } 
        }
        private void registerListener(){
        
            handleAnimalMove = new HandleAnimalMove(this);
            //�����û��ڶ�����ͼ�ϴ�����MouseEvent�¼���
            for(int i =0;i<rightAnimalView.length;i++ ){
        
               rightAnimalView[i].addMouseListener(handleAnimalMove);
            }
            for(int i =0;i<leftAnimalView.length;i++ ){
        
               leftAnimalView[i].addMouseListener(handleAnimalMove);
            }
            handleRedo = new HandleRedo(this);
            handleReStart = new HandleReStart(this);
            //�����û��ڰ�ť�ϴ�����ActionEvent�¼���
            buttonRedo.addActionListener(handleRedo);
            buttonReStart.addActionListener(handleReStart);
        }
        public void setLeftAnimalImage(String pic){
        
           if(animalCount==-1)
               return;
           for(int i =0;i<leftAnimalView.length;i++ ){
        
              leftAnimalView[i].setImage(pic);
           } 
        }
        public void setRightAnimalImage(String pic){
        
           if(animalCount==-1)
               return;
           for(int i =0;i<rightAnimalView.length;i++ ){
        
              rightAnimalView[i].setImage(pic);
           } 
        }
        public void paintComponent(Graphics g){
        
           int penHeight =12;  //���ʵĸ߶�
           super.paintComponent(g);
           int xStart =width+gap;
           int yStart =2*height+penHeight/2;
           int xEnd =(animalCount+2)*width+(animalCount+1)*2;
           int yEnd =2*height+penHeight/2;
           Line2D line=new Line2D.Double(xStart,yStart,xEnd,yEnd);
           Graphics2D g_2d=(Graphics2D)g;
           g_2d.setColor(Color.blue);
           BasicStroke bs=
           new BasicStroke(penHeight,BasicStroke.CAP_ROUND,BasicStroke.JOIN_MITER);
           g_2d.setStroke(bs);
           g_2d.draw(line);
       }
    }

##### HandleAnimalMove #####

import java.awt.event.*;
    import javax.swing.JOptionPane;
    import ch1.data.Point;
    import ch1.data.Animal;
    import ch1.data.ViewForAnimal;
    import ch1.data.LeftAnimal;
    import ch1.data.RightAnimal;
    public class HandleAnimalMove extends MouseAdapter {
        
         GamePanel panel;
         HandleAnimalMove(GamePanel panel){
        
            this.panel = panel;
         } 
         public void mousePressed(MouseEvent e){
        
            ViewForAnimal animalView = (ViewForAnimal)e.getSource();
            Animal animal = animalView.getAnimal();
            Point pStart = animal.getAtPoint(); //�õ������ƶ�ǰ���ڵ�
            if(animal.move()) {
        
               Point pEnd = animal.getAtPoint();//�õ������ƶ������ڵ�
               int x = pEnd.getX();
               int y = pEnd.getY();
               animalView.setAnimalViewLocation(x,y);//�ö�����ͼ����λ�úͶ������ڵ���ͬ
               panel.saveAnimalStep.push(pStart);
               panel.saveAnimalStep.push(pEnd);
            }
        } 
        public void mouseReleased(MouseEvent e){
        
             boolean success = true;
             int n =panel.animalCount/2;
             for(int i=0;i<n;i++){
        
                Animal animal=panel.point[i].getAtPointAnimal();
                success = success&&(animal instanceof RightAnimal);
                animal=panel.point[n+1+i].getAtPointAnimal();
                success = success&&(animal instanceof LeftAnimal);
                if(success == false)
                  break;
             }
             if(success) {
        
                JOptionPane.showMessageDialog(null,"���ɹ���","��Ϣ��",
                                                 JOptionPane.INFORMATION_MESSAGE); 
             }
        }
    }

##### HandleRedio #####

import ch1.data.Point;
    import ch1.data.Animal;
    import ch1.data.ViewForAnimal;
    import java.awt.event.*;
    public class HandleRedo implements ActionListener {
        
         GamePanel panel;
         HandleRedo(GamePanel panel){
        
            this.panel = panel;
         } 
         public void actionPerformed(ActionEvent e){
         //�����ƶ�����Ĳ���
               if(panel.saveAnimalStep.empty())
                   return;
               Point pEnd = panel.saveAnimalStep.pop();
               Point pStart = panel.saveAnimalStep.pop();
               Animal animal = pEnd.getAtPointAnimal(); 
               pEnd.setIsHaveAnimal(false);
               pEnd.setAtPointAnimal(null);
               animal.setAtPoint(pStart);
               ViewForAnimal animalView =animal.getAnimalView();
               int x = pStart.getX();
               int y = pStart.getY();
               animalView.setAnimalViewLocation(x,y);//�ö�����ͼ����λ�úͶ������ڵ���ͬ
        } 
    }

##### HandleReStart #####

import ch1.data.ViewForAnimal;
    import java.awt.event.*;
    public class HandleReStart implements ActionListener {
        
         GamePanel panel;
         HandleReStart(GamePanel panel){
        
            this.panel = panel;
         } 
         public void actionPerformed(ActionEvent e){
         //�������¿�ʼ
           panel.saveAnimalStep.clear();
           for(int i=0;i<panel.point.length;i++) {
        
               panel.point[i].setIsHaveAnimal(false);
           } 
           for(int i =0;i<panel.leftAnimal.length;i++ ){
        
               panel.leftAnimal[i].setAtPoint(panel.point[i]);
               int x = panel.point[i].getX();
               int y = panel.point[i].getY();
               //�ö�����ͼ����λ�úͶ������ڵ���ͬ
               ViewForAnimal animalView =panel.leftAnimal[i].getAnimalView();
               animalView.setAnimalViewLocation(x,y);
           } 
           for(int i =0;i<panel.rightAnimal.length;i++ ){
        
               int m = panel.animalCount/2;
               panel.rightAnimal[i].setAtPoint(panel.point[m+1+i]);
               int x = panel.point[m+1+i].getX();
               int y = panel.point[m+1+i].getY();
               //�ö�����ͼ����λ�úͶ������ڵ���ͬ
               ViewForAnimal animalView =panel.rightAnimal[i].getAnimalView();
               animalView.setAnimalViewLocation(x,y);
           }  
        
         } 
    }

资源地址：

[4966d4ba8a594f488bdbcc20172cccce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6f9ab0f164e44d16bf872bbcec9a426c.png
[18652f37143146f295035e9e0daa0317.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5d82e570800947f7bf02d0971b091b9e.png