Python雷电小游戏、战机小游戏源代码，单机版，相关图片及声音素材包请在网盘下载：https://pan.baidu.com/s/1zGxfSVWCBueDCscxL5bNCg，提供码请在公众号回复：雷电提取码。
 
 
'''
公众号：Python代码大全
'''
import pygame, os
import time
import random
from pygame.sprite import Sprite
from pygame.sprite import Group


def fire_music():
    pass
    # 设置开火音乐
    # effect = pygame.mixer.Sound('sounds/fire.wav')
    # pygame.mixer.Sound.play(effect)

class Boss(Sprite):
    def __init__(self,boss_img_name):
        super().__init__()
        # 加载BOSS图片
        self.image = pygame.image.load('图片/'+boss_img_name+'.png').convert_alpha()
        # 转换BOSS大小
        # self.image = pygame.transform.scale(self.image, (1, 12))
        # 生成BOSS矩形框架
        self.rect = self.image.get_rect()
        self.blood = 1000
        # boss左右移动的速度
        self.speed = 3.5

    def move(self):
        if self.rect.centerx>=512:
            self.speed =-self.speed
        if self.rect.centerx<=0:
            self.speed = -self.speed
        self.rect.centerx +=self.speed



class Enemy(Sprite):
    def __init__(self,screen):
        # 必须设置继承精灵 不然在使用精灵函数时会报错
        super().__init__()
        # 获取屏幕对象
        self.screen = screen
        # 随机 生成5个编号
        alien_num = random.randint(1,5)
        # 随机 加载五个飞机中的某个
        self.image = pygame.image.load('图片/alien_' + str(alien_num) + '.png')
        # picture = pygame.transform.scale(picture, (1280, 720))
        self.image = pygame.transform.scale(self.image,(62,62))
        # 获取飞机的 rect
        self.rect = self.image.get_rect()
        # 击落本机获得的分数
        self.score = 10
        # 加载子弹的图片
        self.bullet_img = pygame.image.load("图片/alien_bullet.png").convert_alpha()
        self.bullet_img = pygame.transform.scale(self.bullet_img, (12, 12))
        # 以下为可以调节子弹尺寸的代码
        # picture = pygame.transform.scale(picture, (1280, 720))
        #飞机的移动速度
        self.speed = random.randint(3,5)

        #生成子弹精灵组合
        self.bullets = Group()
        # 敌机射击频率
        self.shoot_frequency = 0

    # 飞机出现
    def move(self):
        self.rect.top += 5
        #暂时不用射击
        # self.shoot()
        # self.moveBullet()
    # 发射子弹
    def shoot(self):
        if self.shoot_frequency % 200 == 0:
            bullet = Enemy_Bullet(self.bullet_img, self.rect.midbottom)
            self.bullets.add(bullet)
        self.shoot_frequency += 1
        if self.shoot_frequency > 200:
            self.shoot_frequency = 1
    # 删除子弹
    def moveBullet(self):
        for bullet in self.bullets:
            bullet.move()
            if bullet.rect.bottom < 0:
                self.bullets.remove(bullet)
    # 绘制子弹
    def drawBullets(self, scr):
        self.bullets.draw(scr)


class Enemy_Bullet(pygame.sprite.Sprite):
    def __init__(self, init_pos):
        pygame.sprite.Sprite.__init__(self)

        self.image = pygame.image.load("图片/alien_bullet.png").convert_alpha()
        self.image = pygame.transform.scale(self.image, (12, 12))
        self.rect = self.image.get_rect()
        # 敌机子弹初始位置设置
        self.rect.midbottom = init_pos
        self.rect.centery +=36
        self.speed = 8

    def move(self):
        self.rect.top += self.speed
class MyHero(Sprite):
    _rate = 100 # 每帧停留的毫秒数
    def __init__(self,screen,size = 1):
        super().__init__()
        # 获取屏幕对象
        self.screen = screen
        # 获取整张图片
        self.image_big = pygame.image.load('图片/hero.png').convert_alpha()
        # subsurface 形成大图的子表面框架
        # 获取飞机正面图片
        self.image = self.image_big.subsurface(pygame.Rect(120, 0, 318 - 240, 87))
        # 获取飞机正面矩形框架尺寸
        self.rect = self.image.get_rect()
        # 获取屏幕对象矩形
        self.screen_rect = screen.get_rect()
        # 获取屏幕正中x坐标
        self.rect.centerx = self.screen_rect.centerx
        # 获取屏幕底部y坐标
        self.rect.centery = self.screen_rect.bottom - self.rect.height
        # 设置飞机初始位置
        self.centerX = float(self.rect.centerx)
        self.centerY = float(self.rect.centery)
        # 飞机尾焰
        self.air = None
        # 设置飞机尾焰位置
        self.air_rect = pygame.Rect(self.centerX - 20,self.centerY+int((self.rect.height+72)/2)-10-36,40,72)

        #玩家所有发射子弹的集合
        self.bullets = Group()
        self.bullet_image = pygame.image.load('图片/bullet_1.png').convert_alpha()

    # 子弹射击
    def shoot(self):
        # 产生一颗子弹实例
        bullet = Bullet(self.bullet_image,self.rect.midtop)
        # 在group子弹精灵集合中加入子弹
        self.bullets.add(bullet)
    # 子弹删除
    def moveBullet(self):
        # 逐个检查子弹精灵集合 到达屏幕顶端的子弹删除
        for bullet in self.bullets:
            bullet.move()
            if bullet.rect.bottom < 0:
                self.bullets.remove(bullet)
    # 子弹显示
    def drawBullets(self, scr):
        # 将精灵集合中的子弹绘制到屏幕上
        self.bullets.draw(scr)



    # 向上飞时，增加喷射火焰
    def set_air(self, case):
        if case == 'up':
            air = pygame.image.load('图片/air.png').convert_alpha()
            img = air.subsurface(pygame.Rect(80, 0, 50, 87))
            self.air = img
        elif case == 'remove':
            self.air = None

    # 根据移动方向获取飞机移动状态的图片
    def set_image(self, case):
        if case=='left':
            rect = pygame.Rect(195,0,318-248,87)
            image = self.image_big.subsurface(rect)
        elif case =='right':
            rect = pygame.Rect(195,0,318-248,87)
            image = pygame.transform.flip(self.image_big.subsurface(rect), True, False)
        elif case == 'up' or case == 'down':
            rect = pygame.Rect(120, 0, 318 - 240, 87)
            image = self.image_big.subsurface(rect)
        self.image = image

class Bullet(pygame.sprite.Sprite):
    def __init__(self, bullet_img, init_pos):
        pygame.sprite.Sprite.__init__(self)
        self.image = bullet_img
        self.rect = bullet_img.get_rect()
        self.rect.midbottom = init_pos
        self.speed = 25

    def move(self):
        self.rect.top -= self.speed


# 初始化pygame
pygame.init()
# pygame.mixer.init()
# pygame.mixer_music.load('sounds/enviro.mp3') # 加载播放音乐
# pygame.mixer.music.play(-1) #-1 为循环播放
# 设置游戏主题
pygame.display.set_caption('AirCraft')
# 初始化屏幕大小
screen = pygame.display.set_mode((512,768))

# 设置游戏背景图片
# 游戏刚开始时的背景图
bg_img0 = pygame.image.load('图片/start_bg.jpg').convert()
# 加载游戏开始图标
start_img = pygame.image.load('图片/start.png').convert_alpha()
start_rect = start_img.get_rect()
start_rect.centerx = 262
start_rect.centery = 455
#  游戏进行中的背景图
bg_img1 = pygame.image.load('图片/map1.jpg').convert()
bg_img2 = bg_img1.copy()
# 游戏结束时的背景图
bg_img3 = pygame.image.load('图片/map3.jpg').convert()
# 加载游戏结束图标
gameover_img = pygame.image.load('图片/gameover.png').convert_alpha()
# 加载游戏成功图标
gamesuccess = pygame.image.load('图片/success.png').convert_alpha()

# 加载重玩图标
restart_img = pygame.image.load('图片/restart.png').convert_alpha()
restart_rect = restart_img.get_rect()
restart_rect.centerx = 249
restart_rect.centery = 420
# 背景图片初始位置
pos_y1 = -768
pos_y2 = 0

# 实例化BOSS
boss = Boss('boss_1')
bosses = Group()
bosses.add(boss)
# 测试主角图片
# air = pygame.image.load('图片/air.png').convert_alpha()
# img = air.subsurface(pygame.Rect(80, 0, 50, 87))
# image_big = pygame.image.load('图片/hero.png').convert_alpha()
# image = image_big.subsurface(pygame.Rect(195,0,318-248,87))

# 生成我方飞机
student_plane = MyHero(screen)

# 生成敌方飞机
# 生成敌机group
enemies = Group()
# 生成敌机子弹
enemy_bullets = Group()
max_enemies = 9  # 设置敌机数量总数为9
# 敌机随机出现的节奏 下方randint参数 为43,55
ran1,ran2 = 30,40


# 生成计时频率变量
sec = 0
# 生成分数
score = 0
# 设置系统字体
my_font = pygame.font.Font('fonts/msyh.ttf', 18)

# 游戏主循环
# 设置游戏状态  开始 结束
game = 'wait'

while True:
    # 游戏在等待状态
    if game =='wait':
        # 最小游戏框架一个都不能省略
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()

        # 检测鼠标是否按下 重新开始按钮
            if event.type == pygame.MOUSEBUTTONDOWN:
                # 检测鼠标点击位置是否与重启rect重叠
                if start_rect.collidepoint(event.pos):
                    student_plane.__init__(screen)
                    game = 'ing'
        # 游戏结束游戏画面暂停
        screen.blit(bg_img0, (0, 0))
        screen.blit(start_img, start_rect)
        # 测试尾焰位置
        pygame.display.flip()
        time.sleep(0.05)

    # 游戏进行状态
    elif game == 'ing':
        # 设置这3行 监听事件 并且内部设定了延迟防止游戏卡死
        # 屏幕滚动-----------------------------------------------------
        screen.blit(bg_img1, (0, pos_y1))
        screen.blit(bg_img2, (0, pos_y2))
        # 测试尾焰位置
        # screen.blit(img, (100, 100))
        pos_y1 += 1
        pos_y2 += 1
        # 屏幕背景滚动完毕后重置位置
        if pos_y1 >= 0:
            pos_y1 = -768
        if pos_y2 >= 768:
            pos_y2 = 0


        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
            # 监听键盘事件
            # 按键弹起取消飞机向上尾焰 矫正飞机姿势
            if event.type == pygame.KEYUP:
                student_plane.set_image('down')
                student_plane.air = None
            # 发射子弹
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE and len(student_plane.bullets) <6: # 检查子弹集合的数量限制子弹最大数量
                    fire_music()
                    # 产生一颗子弹实例
                    # 在group子弹精灵集合中加入子弹
                    student_plane.shoot()
        # 将精灵集合中的子弹绘制到屏幕上
        student_plane.drawBullets(screen)
        # 逐个检查子弹精灵集合 到达屏幕顶端的子弹删除
        student_plane.moveBullet()

        keys = pygame.key.get_pressed()
        if keys[pygame.K_a]:
            # 设置飞机状态图片
            student_plane.set_image('left')
            if student_plane.rect.centerx>=40:
                student_plane.rect.centerx -=8.5

        elif keys[pygame.K_d]:
            # 设置飞机状态图片
            student_plane.set_image('right')
            if student_plane.rect.centerx <= 478:
                student_plane.rect.centerx +=8.5

        elif keys[pygame.K_w]:
            #设置飞机状态图片
            student_plane.set_image('up')
            student_plane.set_air('up')

            if student_plane.rect.centery >= 45:
                student_plane.rect.centery -=8.5

        elif keys[pygame.K_s]:
            # 设置飞机状态图片
            student_plane.set_image('down')
            if student_plane.rect.centery <= 727:
                student_plane.rect.centery +=8.5

        # 显示飞机
        screen.blit(student_plane.image,student_plane.rect)
        if student_plane.air != None:
            screen.blit(student_plane.air, (student_plane.rect.centerx-30, student_plane.rect.centery+33))

        # 敌机 ---------------------------------------------------------------------------------------

        # 敌机移动
        # 控制时间节奏 sec变量
        sec +=1
        #随机控制生成敌机的节奏
        rhy = random.randint(ran1,ran2)
        # 敌机最多数量

        if sec%rhy ==0 and len(enemies) < max_enemies or sec ==1: # 设置敌机数量总数为9
            # 生成一只敌机
            enemy = Enemy(screen)
            enemy.rect.centerx=random.randint(0,512)
            # 生成上述敌机的子弹
            enemy_bullet = Enemy_Bullet((enemy.rect.centerx,enemy.rect.centery))
            # 敌机group 和 敌机子弹group加载敌机和子弹
            enemies.add(enemy)
            enemy_bullets.add(enemy_bullet)
        # 敌机出现 和 敌机子弹出现
        enemies.draw(screen)
        enemy_bullets.draw(screen)
        # 迭代敌机集合
        for enemy in enemies:
            # 让每个对象移动起来
            enemy.move()
            # 敌机超出屏幕边界后 自动删除敌机
            collision_over1 = pygame.sprite.collide_rect(student_plane, enemy)

            if collision_over1:
                # 为了重启游戏时 防止有旧子弹和飞机存在
                enemies.remove(enemy)
                game = 'over'
            if enemy.rect.bottom >768:
                enemies.remove(enemy)
        for enemy_bullet in enemy_bullets:
            # 让每个对象移动起来
            enemy_bullet.move()

            collision_over2 = pygame.sprite.collide_rect(student_plane, enemy_bullet)
            if collision_over2:
                # 为了重启游戏时 防止有旧子弹和飞机存在
                enemy_bullets.remove(enemy_bullet)
                game = 'over'
            # 敌机子弹超出屏幕边界后 自动删除敌机
            if enemy_bullet.rect.bottom >768:
                enemy_bullets.remove(enemy_bullet)


        #  -----------------------Boss --------------------------
        if score >=140:
            # 小敌机出现的节奏
            ran1,ran2 = 15,25
            max_enemies = 17
            screen.blit(boss.image,boss.rect)
            boss.move()
            for my_bullet in student_plane.bullets:
                hit_boss = pygame.sprite.collide_rect(boss,my_bullet)
                if hit_boss:
                    boss.blood -=1.2
                    score+=1
                if boss.blood <=0:
                    game = 'success'


        # 处理碰撞    ---------------------------碰撞检测--------------------------------------------------
        # 　　参数：
        # 　　group1：精灵组1。
        # 　　group2：精灵组2。
        # 　　dokill1：发生碰撞时，是否销毁精灵组1中的发生碰撞的精灵。
        # 　　dokill2：发生碰撞时，是否销毁精灵组2中的发生碰撞的精灵。
        collisions = pygame.sprite.groupcollide(student_plane.bullets, enemies, True, True)
        if collisions:
            score+=10

        # -----------游戏结束------------

        # 分数和奖励的显示-------------------------------------------------------------------------
        surface1 = my_font.render(u"当前得分：%s"%(score),True,[255,0,0])
        screen.blit(surface1,[20,20])

        # 更新画面
        pygame.display.flip()
        # 设置帧数和延迟
        time.sleep(0.05)

    #游戏结束状态
    elif game == 'over':
        score = 0
        # 最小游戏框架一个都不能省略
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()

        # 检测鼠标是否按下 重新开始按钮
            if event.type == pygame.MOUSEBUTTONDOWN:
                # 检测鼠标点击位置是否与重启rect重叠
                if restart_rect.collidepoint(event.pos):
                    student_plane.__init__(screen)
                    game = 'ing'

        # 游戏结束游戏画面暂停
        screen.blit(bg_img1, (0, pos_y1))
        screen.blit(bg_img2, (0, pos_y2))

        screen.blit(gameover_img, (163, 310))
        screen.blit(restart_img, restart_rect)
        # 测试尾焰位置
        # screen.blit(img, (100, 100))
        pos_y1 += 0
        pos_y2 += 0
        pygame.display.flip()
        time.sleep(0.05)
        # surface2 = my_font.render("Game Over" , True, [255, 0, 0])
        # screen.blit(surface1, [250, 350])
    elif game == 'success':
        score = 0
        boss.blood = 1000
        # 最小游戏框架一个都不能省略
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()

        # 检测鼠标是否按下 重新开始按钮
            if event.type == pygame.MOUSEBUTTONDOWN:
                # 检测鼠标点击位置是否与重启rect重叠
                if restart_rect.collidepoint(event.pos):
                    student_plane.__init__(screen)
                    game = 'ing'

        # 游戏结束游戏画面暂停
        screen.blit(bg_img1, (0, pos_y1))
        screen.blit(bg_img2, (0, pos_y2))

        screen.blit(gamesuccess, (170, 220))
        screen.blit(restart_img, restart_rect)
        # 测试尾焰位置
        # screen.blit(img, (100, 100))
        pos_y1 += 0
        pos_y2 += 0
        pygame.display.flip()
        time.sleep(0.05)
 
更多Python源程序、源代码，请关注公众号：Python代码大全
 

源代码加图片加背景音乐
 链接：https://pan.baidu.com/s/1Ll_vVsBC-lYNpLrSRAz5ew
 提取码：h2ds
 复制这段内容后打开百度网盘手机App，操作更方便哦
 
源代码链接：https://pan.baidu.com/s/1_15FmYYbl1nhydKbkCyfRQ
 提取码：kl56
 复制这段内容后打开百度网盘手机App，操作更方便哦
 
贪吃蛇小游戏运行结果如下：
 启动界面：
 
 运行界面：
 
 重启界面：
 
 源代码框架如下：
 
 注：在运行程序的时候，得重新设计窗体的大小，以适合自己的电脑，其次，图片类和音乐类都保存在我自己电脑的F盘的相应路径下，在运行程序的时候需要将图片类和音乐类保存到自己的本地磁盘路径中，然后在程序中改变路径。
 
Java贪吃蛇小游戏之启动界面
 
package snakeGame;

/* Test类的主要任务是设计程序运行后的界面，包括 程序启动的界面和游戏运行界面。
 * 程序启动的界面包括背景图片和进入运行界面的Button，点击按钮之后程序关闭启动界面进入到运行界面，
 * 运行界面设置在SnakeGame类中，Test类大体设置了运行界面的大小可见与否等。
 */

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Label;
import java.awt.Panel;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Start    extends JFrame implements ActionListener  {	   
	static  JFrame frame = new  JFrame( );
	public static void main(String[] args) {	
    	 new  Start();                                         
    }
	public  Start(){                                                 //设置启动界面
		 frame.setUndecorated(true);                                //用于取消边框背景
         frame.setLayout (null);
         frame.setSize(1600,900);
         frame.setLocation(300, 100);
         frame.setLocationRelativeTo (null);
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
         AddButton();
         AddPicture();            
	}  	
	//定义进入游戏按钮	
	public  void  AddButton() {	                                      
		RButton  enterButton =new RButton("进入游戏");
        enterButton.setFont(new Font("华文行楷", Font.BOLD, 35));
        enterButton.setForeground(Color.red);
        enterButton.setBounds (700,  600 , 200, 100);
        enterButton.setBackground(Color.white);      
        frame.add(enterButton);
        enterButton.addActionListener(this); 
        //定义按键         
	}
  //加入背景图片
	public  void  AddPicture() {	                                           	
		ImageIcon img = new ImageIcon("F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\timg.jpg");
        JLabel Label= new JLabel(img);
        Label.setBounds(0,0,img.getIconWidth(),img.getIconHeight());            //设置大小
        frame.getLayeredPane().add(Label,new Integer(Integer.MIN_VALUE));      //设置图片底层和按钮在容器中的顺序   
        JPanel  jp  =(JPanel)frame.getContentPane();   
        jp.setOpaque(false);                                                   //设置透明与否
	}
	
	/*设置按钮的监听器事件
	 * 进入按钮的监听器事件的主要功能是当点击按钮以后，程序关掉启动界面，并转入运行界面。
	 * 主要实现原理是定义一个新界面的类，作为运行界面，然后定义一个关掉启动界面的方法，然后在监听器事件中，
	 * 调用关掉界面的方法，实例化运行界面 
	 */
	@Override
	 
	public void actionPerformed(ActionEvent e) {                                  
		new  pushButtonMusic ();		 
		// TODO 自动生成的方法存根
		closeThis();		                                                       //关掉新界面的方法
	    try {	    
			new Frame2 ();                                                         //实例化运行界面
		} catch (InterruptedException e1) {
			// TODO 自动生成的 catch 块
			e1.printStackTrace();
		}  //创建新的窗体，以达到切换窗体的效果
	}	
	 private void closeThis() {
		// TODO 自动生成的方法存根
		 frame.dispose();
	}
	 /*
	  * 游戏运行界面，实例化SnakeGame类，并加入到运行界面中
	  */
	 class  Frame2 extends JFrame      {  		 	 		   		  			  
		     JFrame    frame1 = new  JFrame(); //游戏图形界面            
		      public   Frame2() throws InterruptedException{			  				 					    		  		  
			  frame1.setUndecorated(true);
			  frame1.setBounds(200,70,1600,900);		           		 
			//  frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
			  frame1.setVisible(true);			  
	          SnakeGame sn = new SnakeGame();	         
	          frame1.add(sn);
	          sn.requestFocus();//布局的中间	         	         
			}			 
      }	 
}
 
Java贪吃蛇小游戏之运行界面：
 
package snakeGame;

/*
 * SnakeGame类来设计贪吃蛇小游戏的运行界面，运行界面是贪吃蛇游戏的主体部分，  界面主要包括两个方面的内容，
 * 一方面是运行界面的内容，贪吃蛇长度显示，游戏说明，速度控制，游戏开始，暂停退出等按钮。
 * 另一方面，主要包括贪吃蛇的形状和移动，贪吃蛇移动区域，随机点的定义
 * 运行界面的过程是这样的：在开始姐爱你点击进入游戏按钮以后，程序运行到运行界面，开始播放背景音乐。
 * 点击游戏说明按钮，弹出一个对话框，说明游戏运行的操作过程。点击开始按钮以后，
 * 贪吃蛇开始向上移动，鼠标在向上区域点击，贪吃蛇向上，向左区域点击，贪吃蛇向左，依次赖推。
 * 当贪吃蛇碰到草莓时，吃掉它，蛇身变长，并有背景音乐显示，长度显示加一，
 * 点击暂停按钮游戏暂停，点击退出按钮后，退出游戏。
 * 当贪吃蛇撞到自己或者墙体的时候，贪吃蛇会死亡，然后弹出一个界面，重启界面，用来决定游戏继续进行或者退出游戏。
 * 贪吃蛇的形状和移动通过数组的形式实现，在界面中，定义一个x轴和y轴定义的坐标系，定义一个数组，数组的移动就是贪吃蛇的移动，
 * 移动方式是贪吃蛇坐标的改变，可以通过鼠标控制或键盘控制来实现贪吃蛇的移动，
 * 随机点产生是在坐标系中产生随机数来实现，
 */
import java.applet.AudioClip;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Time;
import java.util.Date;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
import java.util.TimerTask;

import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.Timer;

import java.applet.AudioClip;
import java.net.MalformedURLException;
import java.net.URL;
import javax.swing.JApplet;

public class SnakeGame extends JPanel  implements ActionListener   {	 
      private final int length = 15;//定义活动范围
      private final int width = 25;//定义活动范围
      private final int unit = 45;//定义单位长度
      private final  int GameLOCX=40;
      private final  int  GameLOCY=40;
      private  final int GameWidth=width*unit;
      private  final  int GameLength=length*unit;
      //随机点坐标   
      int newY1 =0 ; 
      int newX1 = 0 ;  
      
      int mousex=1;
      int mousey=1;
      //播放背景音乐
      AudioClip christmas = loadSound ("F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\Music\\backgroundMusic.wav");
      int direction = 1;//定义一个按下按钮后要去的方向                 
      private ArrayList<SnakeNode> snake = new ArrayList<>();//定义蛇身的数组集合
      private int Direction;//定义蛇头的方向
      private int Length ;//定义蛇身的长度
      private SnakeNode newNode = new SnakeNode(1,1,Color.BLACK);//定义随机点
          
       boolean  startFlag  =false;
      //定义按钮，速度控制，开始暂停退出按钮等
       RButton   SspeedButton , TspeedButton,FspeedButton,THspeedButton ,ShowButton; 
       RButton    startButton , stopButton , quitButton  ,reStartButton,closeButton;
       //定义标签，长度显示，方向显示，按钮提示等   
       JLabel  snakeScore, label1,  label3,label4;
       //初始速度控制
       private static int Difficult_Degree=1;
       //蛇的移动控制，利用线程来实现用鼠标控制，利用计时器来实现用键盘控制。
      Thread  tr= new Thread(new ThingsListener());
      Timer time = new Timer(1000, new ThingsListener1());//定义一个定时器对象，这里我们还要创建一个ThingsListener事件
      
      public SnakeGame() {//初始化区域
    	 //循环播放背景音乐
    	  christmas.loop ();
    	  
    	 // time.start(); 
         tr.start();   	 
    	  //定义按键
         //在容器中添加按钮标签等的时候，需要说明布局管理为空，不然的话，加进去的按钮会按照一定的布局来实现，
    	  this.setLayout (null);
    	  //定义按钮
         startButton = new  RButton("开始游戏"); 	 
		  stopButton =new  RButton("暂停游戏");
		  quitButton =new  RButton("退出游戏");
		  
		  FspeedButton =new  RButton("速度一");		          
		  SspeedButton =new  RButton("速度二");
		  TspeedButton=new  RButton("速度三");
		  THspeedButton=new  RButton("速度四");		
	      ShowButton  =new   RButton("游戏指南");
		  	
	      //定义标签
		  snakeScore =new  JLabel("3");
		  label1 =new  JLabel("当前长度");
		   		 
		  label3 =new  JLabel("速度设置");
		  label4 =new  JLabel( );
          
		  //设置字体
		  startButton.setFont(new Font("华文行楷", Font.BOLD, 35));
		  stopButton.setFont(new Font("华文行楷", Font.BOLD, 35));
		  quitButton.setFont(new Font("华文行楷", Font.BOLD, 35));
		 
		  FspeedButton.setFont(new Font("华文行楷", Font.BOLD, 15));
		  TspeedButton.setFont(new Font("华文行楷", Font.BOLD, 15));
		  SspeedButton.setFont(new Font("华文行楷", Font.BOLD, 15));
		  THspeedButton.setFont(new Font("华文行楷", Font.BOLD, 15));
		 
		  ShowButton.setFont(new Font("华文行楷", Font.BOLD, 30));
		  
		  label1.setFont(new Font("华文行楷", Font.BOLD, 35));
		  snakeScore.setFont(new Font("华文行楷", Font.BOLD, 50));
		  		 	 
		  label3.setFont(new Font("华文行楷", Font.BOLD, 30));
		  label4.setFont(new Font("华文行楷", Font.BOLD, 35));
		 //定义按钮标签位置
	      startButton.setBounds (1390, 500 , 190, 90);
	      stopButton.setBounds (1390,  600 , 190, 90);
	      quitButton.setBounds (1390,  700 , 190, 90);
	      snakeScore.setBounds(1450, 70, 150, 90);
	      label1.setBounds(1390, 10, 190, 90);
	      
	      ShowButton.setBounds(1390, 170, 190, 90);
	     
	      label3.setBounds(1390, 270, 190, 90);
	      label4.setBounds(0, 0, 190, 90);
          
	      FspeedButton.setBounds (1390, 350 , 85, 60);
	      SspeedButton.setBounds (1500,350 , 85, 60);
	      TspeedButton.setBounds (1390, 420 , 85, 60);
	      THspeedButton.setBounds (1500, 420 , 85, 60);
	     
	      THspeedButton.setBackground(Color.green);
		  SspeedButton.setBackground(Color.blue);
		  TspeedButton.setBackground(Color.red);
	      FspeedButton.setBackground(Color.red);
		  	      
	     // 添加 按钮和标签，用this关键字指向当前容器
	   
         this.add(startButton);
         this.add(stopButton);
         this.add(quitButton);

         this.add(FspeedButton);
         this.add(SspeedButton);
         this.add(TspeedButton);
         this.add(THspeedButton);
                          
         this.add(label1);
         this.add(snakeScore);        
         this.add( ShowButton);
         this.add(label3);
         this.add(label4);
         
        // 添加三个按键的监听事件
         startButton.addActionListener(this);
         stopButton.addActionListener(this);
         quitButton.addActionListener(this);
             
         THspeedButton.addActionListener(this);
         SspeedButton.addActionListener(this);
         TspeedButton.addActionListener(this);
         FspeedButton.addActionListener(this);
          ShowButton.addActionListener(this);
            
         snake.add(new SnakeNode(width/2,length/2 ,Color.red));
         snake.add(new SnakeNode(width/2,length/2+1 ,Color.blue));
         snake.add(new SnakeNode(width/2,length/2+2 ,Color.green));
    	 
          Direction = 1;//定义初始方向为向上
          Length = 3;//蛇身长度为3
          CreateNode1();//产生随机点
         // CreateNode2();
     /*//采用键盘控制的控制模式，利用键盘的上下左右键，来实现让·direction的变化，从而使贪吃蛇能够按照键盘的控制来实现移动
        this.addKeyListener(new KeyAdapter() {//捕捉键盘的按键事件 设置监听器
            public void keyPressed(KeyEvent e) {
            	 
                switch(e.getKeyCode()) {
                    case KeyEvent.VK_UP://按下向上，返回1
                        direction = 1;
                        break;
                    case KeyEvent.VK_DOWN://按下向下，返回-1
                        direction = -1;
                        break;
                    case KeyEvent.VK_LEFT://按下相左，返回2
                        direction = 2;
                        break;
                    case KeyEvent.VK_RIGHT://按下向右，返回-2
                        direction = -2;
                        break;
                    default:
                        break;
                }
                if(direction + Direction !=0) {//不能反向运动
                    Direction = direction;
                    Move(direction);
                    repaint();
                }
            }
        });
        */
             
        //采用 鼠标控制的控制模式     通过监听鼠标在容器中的位置，点击上下左右区域，改变direction的值，即可实现贪吃蛇的移动，
          this.addMouseListener(new MouseAdapter(){  //匿名内部类，鼠标事件
              public void  mousePressed(MouseEvent e){ 
            	  int a=0;//鼠标完成点击事件
                     //e.getButton就会返回点鼠标的那个键，左键还是右健，3代表右键
                       mousex = e.getX();  //得到鼠标x坐标
                       mousey = e.getY();  //得到鼠标y坐标
                       double  k=0.6;            //直线斜率
                       double  Y1=0.6*mousex;
                       double  Y2=-0.6*mousex+810;
                       double   X1=1.6*mousey;
                       double   X2=-1.6*mousey+1350;
                       if(mousex > X1&&mousex<X2&&mousey>0&&mousey<405) {   //第一象限  		向上
                    	   label4.setText( "向上" );
                       	a=1;   	 
                       }
                       if(mousex>X2&&mousex<X1&&mousey>405&&mousey<810) {  // 第二象限             向下
                    	   label4.setText( "  向下" );
                       	 a=2;
                           }
                 if(mousex>0&&mousex<675&&mousey>Y1&&mousey<Y2) {    //第三象限     向左
                    	   label4.setText( " 向左" );
                       	 a=3;
                            }   
                       if(mousex>675&&mousex<1350&&mousey>Y2&&mousey<Y1) {   //第四象限    向右
                    	   label4.setText( "  向右" );
                           a=4;
                           } 
                
                      switch( a) {
                      case  1://按下向上，返回1
                          direction = 1;
                          break;
                      case 2://按下向下，返回-1
                          direction = -1;
                          break;
                      case 3://按下相左，返回2
                          direction = 2;
                          break;
                      case 4://按下向右，返回-2
                          direction = -2;
                          break;
                      default:
                          break;
                  }
                      
                      if(direction + Direction !=0) {//不能反向运动
                          Direction = direction;
                          Move(direction);
                            repaint();
                  }
                }
               
          });         
      } 
   /*定义蛇移动的方法  
    *   贪吃蛇的移动方法主要包括方向控制，碰到随机点，碰到自己，碰到边界以及设计贪吃蛇从前向后的移动
    * 
    */
      public void Move(int direction) {                 	 
        int FirstX = snake.get(0).getX();            //获取蛇第一个点的横坐标
        int FirstY = snake.get(0).getY();            //获取蛇第一个点的纵坐标                  
        if(!startFlag) 
            return ; 
        //方向控制
        switch(direction) {
            case 1:
                FirstY--;
                break;
            case -1:
                FirstY++;
                break;
            case 2: 
                FirstX--;
                break;
            case -2:
                FirstX++;
                break;
            default:
                break;
        }
      //当碰到随机点时
        if(FirstX == newNode.getX()&&FirstY == newNode.getY()) { 
        	new  eatFoodMusic();
            getNode();
            return;
        }
      //当碰到蛇身自己时
        for(int x = 0; x < Length; x++) { 
            if((FirstX==snake.get(x).getX())&&(FirstY == snake.get(x).getY())) {
            	startFlag=false;
            	new  DeadMusic();
            	 new  Restart();   
            	 christmas.stop ();
            }
        }
         //当贪吃蛇撞到边界
        if(FirstX < 1  || FirstX >29  || FirstY < 1 || FirstY >18) {        	
        	startFlag=false;
        	new  DeadMusic();
        	new  Restart();
        	 christmas.stop ();
        //	new  Test();
        } 
        //定义循环，使得贪吃蛇从前向后移动
        for(int x = Length - 1; x > 0; x--) {
            snake.get(x).setX(snake.get(x-1).getX());
            snake.get(x).setY(snake.get(x-1).getY());
        }
        snake.get(0).setX(FirstX);
        snake.get(0).setY(FirstY);
        repaint();
    }    
      //获取随机点
	public void getNode() {                            
        snake.add(new SnakeNode());
        Length++;
        
        for(int x = Length-1; x >0; x--) {
            snake.get(x).setX(snake.get(x-1).getX());
            snake.get(x).setY(snake.get(x-1).getY());
            snake.get(x).setColor(snake.get(x-1).getColor());
        }
        snakeScore.setText( ""+( Length ));         //定义蛇的长度
        snake.get(0).setX(newNode.getX());
        snake.get(0).setY(newNode.getY());
        snake.get(0).setColor(newNode.getColor());
        CreateNode1();//产生随机点
       // CreateNode2();
        repaint();
        //当长度超过10的时候，产生鼓掌声
        if(Length==10) {
        	new  applauseMusic();
        }
    }
   
	public void CreateNode1() {                     //创造随机点的方法                 
                            
           Boolean flag = true;
           while(flag) {
        	  newY1 = new Random().nextInt(15)+1;     
        	  newX1= new Random().nextInt(25)+1; 
        	  for(int x = 0; x < Length; x++) {
        	        if(snake.get(x).getX() == newX1 && snake.get(x).getY() == newY1) {
        	        flag = true;
        	        break;
        	        }
        	        flag = false; 
        	    }
        	//随机点不能超出面板，并且不能出现在蛇身上
                   
              for(int i = 0; i < Length; i++) {
                  if(snake.get(i).getX()> 5&& snake.get(i).getX()<newX1  &&snake.get(i).getY() > 5
                		  && snake.get(i).getY()<newY1) {    
                      flag = true;
                      break;
                     }
                    flag= false;
              }
        }
                
       Color color = new Color(new Random().nextInt(255),new Random().nextInt(255),new Random().nextInt(255));
        newNode.setColor(color);
        newNode.setX(newX1);                                
        newNode.setY(newY1);                  
    }
	
/*
 * 这里是自己新建一个事件处理，每隔Timer的时间间隔，就开始移动Directon的位置，
 * 由因为Direction的位置是构造方法中定义好的，所以就会自动地移动方向。而每当玩家使用键盘时，Direction的值变化，之后每次自动移动的方向也随之变化。
 * 
 * 
 */
	//定义内部类，贪吃蛇不断移动
	
	public class ThingsListener1 implements ActionListener {
	    public void actionPerformed(ActionEvent e) {
	        Move(direction);
	        }
	    }// 

	public AudioClip loadSound ( String filename )
    {
     URL url = null;
      try
   {
    url = new URL ("file:" + filename);
    }
   catch (MalformedURLException e)
   {}
   return JApplet.newAudioClip (url);
   }
	
	/*
	 * 当startflag为真的时候，贪吃蛇在线程时间的脉冲下继续移动，这个过程包含在if语句块中，当程序启动时，每隔1.2s就有一个响应， 
	 *上一个方法采用Timer， Timer的构造方法是Timer(int delay, ActionListner listener)通俗的说就是创建一个每 delay秒触发一次动作的计时器，
	 * 每隔特定的时间就会触发特定的事件。可以使用start方法启动计时器。
	 * 优点在于形式简单，缺点在于当采用速度控制的时候不易控制，而同样作为时间触发作用的线程控制可以实现这个目的，即通过控制时间来控制贪吃蛇的移动速度
	 * 之所以之前的设计有错误，在于while后面没有用if进行startflag的检验，即startflag只有在真的条件下才可以移动，时间脉冲触发下才可以移动。
	 * 
	 * 	 
	*/
	//定义线程类，使得贪吃蛇能够在线程的控制下不断移动
    class ThingsListener  implements  Runnable   {
		@Override
		public void run() {
			// TODO 自动生成的方法存根
			while( true) {
				if(startFlag) {      
				Move(Direction);
				repaint();
				}
				try {					
					Thread.sleep(1200/Difficult_Degree);
				}catch(InterruptedException  e){
					e.printStackTrace();
				}
			}	 		
		}//设置一个监听器事件,用来控制蛇的不断移动       
    }
   //定义图像类，画出贪吃蛇移动的运行界面，如贪吃蛇的形状，背景图片，蛇头蛇尾等      
   //描述蛇函数的主体形状，随机点的形状和蛇的形状 
   
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);//加背景
        Image  im=Toolkit.getDefaultToolkit().getImage("F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\background1.jpg");
        g.drawImage(im, 0, 0, this.getWidth(), this.getHeight(), this);//画出蛇头
      		if(direction ==1||Direction==1){      			
      			
      			Toolkit toolup = this.getToolkit();
      	        Image headup =  toolup.getImage( "F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\up.png");
      	        g.drawImage(headup,snake.get(0).getX()*unit, snake.get(0).getY()*unit, unit, unit,this);     	        
      		}else if(direction ==-1){
     			      	
      			 Toolkit tooldown = this.getToolkit();
      	        Image headdown =  tooldown.getImage( "F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\down.png");
      	        g.drawImage(headdown,snake.get(0).getX()*unit, snake.get(0).getY()*unit, unit, unit,this);
      	        
      		}else if(direction ==2){
            	Toolkit toolleft = this.getToolkit();
      	        Image headleft =  toolleft.getImage( "F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\left.png");
      	        g.drawImage(headleft,snake.get(0).getX()*unit, snake.get(0).getY()*unit, unit, unit,this);      		
      		}else if(direction ==-2){     			 
      			Toolkit toolright = this.getToolkit();
      	        Image headright =  toolright.getImage( "F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\right.png");
      	        g.drawImage(headright,snake.get(0).getX()*unit, snake.get(0).getY()*unit, unit, unit,this);
      	     	}      	      		
      	//画出食物的形状	      	 
        Toolkit tool1 = this.getToolkit();
        Image food=  tool1.getImage( "F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\food.png");
        g.drawImage(food,newNode.getX()*unit, newNode.getY()*unit, unit, unit,this);       
        
        Toolkit tool2 = this.getToolkit();
        Image food1=  tool2.getImage( "F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\food.png");
        g.drawImage(food1,newNode.getX()*unit, newNode.getY()*unit, unit, unit,this); 
                        
      //绘制指定矩形的边框。矩形的左边和右边位于 x 和 x + width。顶边和底边位于 y 和 y + height。使用图形上下文的当前颜色绘制该矩形。
        g.drawRect(40, 30, 1350, 810 );             
        for(int x = 1; x < Length-1; x++) {                   //利用循环，来绘制蛇的形状
            g.setColor(snake.get(x).getColor());
            g.fillOval(snake.get(x).getX()*unit, snake.get(x).getY()*unit, unit, unit);   //给蛇的每一个节点画椭圆                  
        }                     
          for(int x = Length-1; x < Length; x++) {        	       
        Toolkit toolright = this.getToolkit();
          Image headright =  toolright.getImage( "F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\body.png");
  	       g.drawImage(headright,snake.get(x).getX()*unit, snake.get(x).getY()*unit, unit,unit,this);//利用循环，来绘制蛇的形状           
        }
   }  
                  
    //设置按钮的监听器事件
	@Override
	public void actionPerformed(ActionEvent e) {
		// TODO 自动生成的方法存根
		//按开始键
		if(e.getSource() == startButton) {
			new  pushButtonMusic ();
            startFlag = true;
            startButton.setEnabled(false);
            stopButton.setEnabled(true); 
            
        }//按暂停键
        if(e.getSource() == stopButton) {
        	new  pushButtonMusic ();
            startFlag = false;
            startButton.setEnabled(true);
            stopButton.setEnabled(false);             
     }
          //        退出程序
        if(e.getSource() == quitButton) {
        	 
            System.exit(0);
        }//按游戏指南建
        if(e.getSource() ==  ShowButton) {
        	new  pushButtonMusic ();
        	 JDialog frame = new JDialog();//构造一个新的JFrame，作为新窗口。
             frame.setBounds( 600,300,815,515 );             
             JTextArea  Myarea=new  JTextArea(3,10);
              Myarea.setText( " \n " 
                     +"这个小游戏点击开始按钮后贪吃蛇开始移动， 鼠标前后左右移动\n"+"会使贪吃蛇也前后左右移动。\n"
                     + "你的任务是通过控制蛇的移动来吃掉小草莓，这样贪吃蛇就长大了。\n"
                     +"点击暂停游戏按钮可以使得贪吃蛇停止移动,"
                     +"点击退出游戏按钮自然游\n"+"戏就结束啦！\n"
                     + "点击速度一，速度二等按钮就可以控制贪吃蛇的移动速度 \n" 
                     );			 
		     frame.setLayout(null);              
              Myarea.setBounds( 10,10,815,350);             			 
             Myarea.setFont(new Font("华文行楷",Font.BOLD,25));          
             frame.add(Myarea);           
             frame.setModalityType(JDialog.ModalityType.APPLICATION_MODAL);    // 设置模式类型。
             frame.setVisible(true);              
     }//按速度一键
        if(e.getSource() == FspeedButton) {
        	new speedButtonMusic ();
        	  Difficult_Degree= 2;                      	
     }//按速度二键
        if(e.getSource() == SspeedButton) {
        	new speedButtonMusic ();
             
        	 Difficult_Degree=  3;        	
     }//按速度三键
        if(e.getSource() == TspeedButton) {
        	new speedButtonMusic ();
        	 Difficult_Degree= 4;        	        	
     }//按速度四键
        if(e.getSource() == THspeedButton) {
        	new  speedButtonMusic ();
        	 Difficult_Degree= 5;      	
     }
        this.requestFocus();
    }
 	 
}

 
 
Java贪吃蛇小游戏之重启界面：
 
package snakeGame;
/*
 * ReStart类的功能和start相类似，设计程序运行后的界面，包括程序重启界面和游戏运行界面。运行界面和start类运行的一样，
 * 重启界面包括包括两个按钮和一个背景图片，点击重启游戏按钮游戏进入运行界面，点击退出按钮后结束游戏。
 */

import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

class Restart   extends  JFrame   implements ActionListener{
	public  static  void main(String [] args) {
		new  Restart();	
	   }
	
	//定义窗体
	   JFrame frame2=new JFrame(); 
	   JButton reStartButton=new  JButton("重新开始");
	   JButton  closeButton =new JButton("结束游戏");
	
	   
	//定义界面按钮等内容。		   
	public  Restart() {
    	frame2.setUndecorated(true);  //用于取消边框背景	
		frame2.setSize(800,480);
		frame2.setLocation(600,300);
		//frame2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame2.setVisible(true);
		frame2.setLayout(null);	
		
		//设置按钮颜色
		
		Color  color2=new  Color(124,252,0);
		reStartButton.setBackground(color2);				
		Color color1 = new Color(124,252,0 );
		closeButton.setBackground(color1 );
		//设置按钮大小和位置			 
		reStartButton.setBounds(140, 364, 120, 110);
		closeButton.setBounds(280,270,120,110);
		//设置按钮颜色和字体
		reStartButton.setFont(new Font("华文行楷", Font.BOLD, 20));
		closeButton.setFont(new Font("华文行楷", Font.BOLD, 20));
		//在容器中加入按钮
		frame2.add(reStartButton);
		frame2.add(closeButton);
	    addPicture();
	    reStartButton.addActionListener(this);
	    closeButton.addActionListener(this);
        }
	
	   //设置背景图片
		 public  void  addPicture() {      //游戏结束时弹出的界面的背景
		    ImageIcon  deadPicture  =new  ImageIcon("F:\\MYJAVA\\Myprogram\\Snakeexample\\src\\image\\restartPicture.jpg");
		    JLabel  pictureLabel  =new  JLabel(deadPicture);
			pictureLabel.setBounds(0, 0,deadPicture.getIconWidth(), deadPicture.getIconHeight());
			frame2.getLayeredPane().add(pictureLabel,new Integer(Integer.MIN_VALUE));
			JPanel  jp1=(JPanel)frame2.getContentPane();
			jp1.setOpaque(false);
		}
	 //按钮加入监听器事件
		@Override
		public void actionPerformed(ActionEvent e) {
			// TODO 自动生成的方法存根
			if(e.getSource()==reStartButton) {
				 closeThis();
	             new  Frame3();	            	
	  	            }				 			
			if(e.getSource()==closeButton) {
				System.exit(0);
 	        }		
	     }
		private void closeThis() {
			// TODO 自动生成的方法存根
			frame2.dispose();
	}
	
	//	游戏运行界面，实例化SnakeGame类，并加入到运行界面中			
   class  Frame3 extends JFrame      {  	  
	    JFrame  frame1 = new JFrame(); //游戏图形界面            
	  public   Frame3(){ 
		   frame1.setUndecorated(true);  //用于取消边框背景
		   frame1.setBounds(200,70,1600,900);		           		 
		 /// frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		   frame1.setVisible(true);			  
	        SnakeGame   sn  =new  SnakeGame();    
	        frame1.add(sn);
	        sn.requestFocus();//布局的中间		  								 
	   }			 
    }
}
 
Java贪吃蛇小游戏之贪吃蛇
 
package snakeGame;
/*
 * 定义一个类，用来描述贪吃蛇游戏中的蛇，蛇身上的每一个点，通过建立snakeNode的对象，指定不同的X轴和Y轴的值，就能组成一个蛇身。
 * 同时可以获得蛇身上的x和y点坐标，和颜色
 */
import java.awt.Color;

public class SnakeNode {    //定义蛇身集合中的各个元素点，x，y。以及颜色三个蛇的关键组成
    private int x;
    private int y;
    private Color color;
	 
	public int setX=20;
	public int setY=20;
	 
    public SnakeNode() {
        super();

    }
    public SnakeNode(int x, int y, Color color) {
        super();
        this.x = x;
        this.y = y;
        this.color = color;
    }
    public int getX() {
        return x;
    }
    public void setX(int x) {
        this.x = x;
    }
    public int getY() {
        return y;
    }
    public void setY(int y) {
        this.y = y;
    }
    public Color getColor() {
        return color;
    }
    public void setColor(Color color) {
        this.color = color;
    }
}

代码的下载地址
 截图
 
 

 
 
 
设计需求
 
基础功能
 实现windows扫雷游戏初级的所有功能
 扫雷尺寸99 方格 每个方格尺寸3030
 游戏初始化时，随机分布10个地雷
 当左键点击雷区任意方格时，则游戏开始
 鼠标左键点击为翻开方格，为雷则游戏失败，非雷则显示其周围一圈地雷的数量（0-8）
 鼠标右键单击标记为旗帜，此时左键单击无效。
 鼠标右键再次单击标记为旗帜的方格，则标记转为问号，表明疑问，此时左键单击有效。
 第一步 默认不能踩雷 （如果是雷，强制重新随机分布直至为非雷）
 
点开一片区域
 当左键点击方格时，如果为非雷且其周围一圈的地雷数量为0，则自动翻开其周围一圈的方格，再检测是否还存在数量为0的方格，如有则继续翻开其周围一圈方格，直至没有数量为0的方格为止。（视觉效果上相当于点开一片区域）
 
当鼠标左键和右键同时单击一块方格时：
 1） 未翻开方格点击无效
 2） 已翻开方格，获取方格的数字（1-8），然后检测其周围8个方格中
 剩余未翻开方格 == 当前方格数字，则自动标记为旗帜
 剩余未翻开方格 > 当前方格数字，无动作
 剩余未翻开方格中已标记旗帜数量 == 当前方格数字，则自动翻开其它剩余未翻开方格，如果有雷则游戏失败
 剩余未翻开方格中已标记旗帜数量 != 当前方格数字，无动作
 
其它功能
 计时器：方格第一步左键翻开之后即开始计时，直至游戏结束（成功或失败）
 雷数：每标记一个旗帜则雷数减1，雷数允许为负值
 游戏状态：游戏开始为normal脸，游戏成功为smile脸，游戏失败为cry脸。任意时刻点击任意状态的脸都将重置游戏
 
游戏失败判定：左键翻开方格为雷或者左键右键同时点击自动翻开未翻开方格时有雷则判定游戏失败
 游戏成功判定：正确使用旗帜标记出所有地雷，且雷数显示为0（即没有多标旗帜）
 
主要功能模块实现思路
 
1） 如何检测鼠标左键和右键同时按下
 设置鼠标每个键（左键，右键，滚轮）的状态位，检测其按下和松开两个状态
 当鼠标左键按下且未松开时，检测到右键按下时，则认为两键同时按下
 反之同理
 
2）随机雷分布
 通过列表生成式生成二维数组，表示地雷分布的row和line值。
 随机生成的二维数组可能存在重复值，所以需要先将列表转换为tuple，再通过set去重
 去重后数组可能小于10，所以为简化操作，一开始生成12组数值，如果去重后小于10则重复生成直到生成的去重数组大于10为止。
 实际只取前10组数据。
 参考代码如下：
 
#生成大于10个不重复的二维数组，如果数组长度小于10则再次生成直到数组长度大于10为止
num = 0
while num <10:
	random_number_0 = [[random.randint(0,8) for i in range(2)] for j in range(12)]
	#将列表转换为tuple，再通过set去重复数据
	random_number = list(set([tuple(t) for t in random_number_0]))
	num = len(random_number)
 
3）点开一片区域
 利用 递归函数
 先获取周围方格的坐标，然后计算周围方格的地雷数量，不为0则显示相应的数字，为0的话，则调用递归函数，继续计算。直至没有数量为0的方格为止
 
4）左右键同时按下的操作
 
未翻开方格点击无效
 已翻开方格，获取方格的数字（1-8），然后检测其周围8个方格中
 
 
剩余未翻开方格 == 当前方格数字，则自动标记为旗帜
 
 
剩余未翻开方格 > 当前方格数字，无动作
 
 
剩余未翻开方格中已标记旗帜数量 == 当前方格数字，则自动翻开其它剩余未翻开方格，如果有雷则游戏失败
 
 
剩余未翻开方格中已标记旗帜数量 != 当前方格数字，无动作
 
 
5）第一步就是雷的情况
 如果第一次左键单击的方格就是雷，则强制重新执行随机雷分布，并不断检测点击的方格是否仍有地雷，如果还是有雷，则反复执行，直到该点击方格无雷为止
 
代码的下载地址

单机五子棋的代码实现（python）
 
五子棋的规则大家肯定都了解，也是大家在百忙之中娱乐的一部分，也都在网上玩过五子棋的游戏，那么大家有没有想过自己编写一个五子棋游戏呢。很多人都感觉做“游戏”这个词汇听着就很难，不知道怎么去实现。那么“接下来就是见证奇迹的时刻”。
 
思路：
 
（1）准备好棋盘图片，棋子图片（白棋、黑棋），获胜时的图片共四张。想要图片资源可以点击此链接: https://pan.baidu.com/s/13Ajqv29YXL2zWlDNk63rxA 提取码: rvh2 ；最好将图片文件夹放在自己要创建的项目里。
 （2）以下是编写单机五子棋程序的几个重要部分：
 【1】创建初始化棋盘方法initChessSquare(x,y)：根据棋盘图片的交叉点个数，遍历其所有交叉点坐标。
 【2】创建监听各种事件的方法eventHander()：如：鼠标点击退出位置，程序能实现退出响应（退出很重要，因为游戏界面的显示就是一个死循环whileTrue；一个不断刷新界面（背景图片）的过程，因此，不做退出操作，此窗口会进入死锁状态，用户将无法操作）；鼠标只有点击棋盘的交叉点位置时，才通过pygame.mouse.get_pos()获取鼠标点击的坐标并给出相应的棋子类型value。通过列表封装后，再存入到全局列表initChessList中。
 【3】创建判断输赢的规则方法judgeResult(i,j,value)：创建标志位flag为False，当满足赢的规则时，标志位flag再为True；判断横向、纵向、左斜向、右斜向有没有出现5连（在边缘依次向内逐一遍历，是否五个棋子的类型一样，一样则为赢，即五子连珠）
 【4】创建主方法main()：其中包含初始化游戏环境pygame.init()；绘制游戏窗口pygame.display.set_mode((600,600),0,0)（其中第一个参数(600，600)为设定窗口的大小，第二个参数为标志位，如果不用什么特性就指定为0(指定为FULLSCREEN时，绘制的是一个全屏窗口，如果没有相应的退出机制，只有按 菜单键 才能跳回之前界面),第三个参数为色深）；通过pygame.image.load(“图片路径”)的方法加载棋子以及判赢的图片；遍历全局列表initChessList中的子列表，再遍历子列表中封装的棋子类型value，通过之前的响应值来绘制相应棋子类型的图片；当其中一方为赢时，清空棋盘，重新初始化棋盘，绘制赢的图片，再更新显示的视图；最后调用监听事件方法（函数），监听用户的鼠标操作。
 【5】定义入口函数，调用主方法main()。
 至此，单机五子棋完成，当然，有的地方还可进一步完善，但对于初学者来说，如上的大体概括已经受用了。如上思路只作为下面具体的代码参考。
 
具体实现代码如下：
 
import pygame        #导入pygame游戏模块
import time
import sys
from pygame.locals import *

initChessList = []          #保存的是棋盘坐标
initRole = 1                #1：代表白棋； 2：代表黑棋
resultFlag = 0              #结果标志

class StornPoint():
    def __init__(self,x,y,value):
        '''
        :param x: 代表x轴坐标
        :param y: 代表y轴坐标
        :param value: 当前坐标点的棋子：0:没有棋子 1:白子 2:黑子
        '''
        self.x = x            #初始化成员变量
        self.y = y
        self.value = value

def initChessSquare(x,y):     #初始化棋盘
    for i in range(15):       # 每一行的交叉点坐标
        rowlist = []
        for j in range(15):   # 每一列的交叉点坐标
            pointX = x+ j*40
            pointY = y+ i*40
            sp = StornPoint(pointX,pointY,0)
            rowlist.append(sp)
        initChessList.append(rowlist)

def eventHander():            #监听各种事件
    for event in pygame.event.get():
        global initRole
        if event.type == QUIT:#事件类型为退出时
            pygame.quit()
            sys.exit()
        if event.type == MOUSEBUTTONDOWN: #当点击鼠标时
            x,y = pygame.mouse.get_pos()  #获取点击鼠标的位置坐标
            i=0
            j=0
            for temp in initChessList:
                for point in temp:
                    if x>=point.x-10 and x<=point.x+10 and y>=point.y-10 and y<=point.y+10:
                        if point.value == 0 and initRole == 1:   #当棋盘位置为空；棋子类型为白棋
                            point.value = 1             #鼠标点击时，棋子为白棋
                            judgeResult(i,j,1)
                            initRole = 2                #切换角色
                        elif point.value == 0 and initRole ==2:  #当棋盘位置为空；棋子类型为黑棋
                            point.value = 2             #鼠标点击时，棋子为黑棋
                            judgeResult(i,j,2)
                            initRole = 1                #切换角色
                        break
                    j+=1
                i+=1
                j=0

def judgeResult(i,j,value):   #横向判断
    global resultFlag
    flag = False
    for  x in  range(j - 4, j + 5):  # 横向有没有出现5连（在边缘依次逐一遍历，是否五个棋子的类型一样）
        if x >= 0 and x + 4 < 15 :
            if initChessList[i][x].value == value and \
                initChessList[i][x + 1].value == value and \
                initChessList[i][x + 2].value == value and \
                initChessList[i][x + 3].value == value and \
                initChessList[i][x + 4].value == value :
                flag = True
                break
                pass
    for x in range(i - 4, i + 5):  # 纵向有没有出现5连（在边缘依次逐一遍历，是否五个棋子的类型一样）
        if x >= 0 and x + 4 < 15:
            if initChessList[x][j].value == value and \
                    initChessList[x + 1][j].value == value and \
                    initChessList[x + 2][j].value == value and \
                    initChessList[x + 3][j].value == value and \
                    initChessList[x + 4][j].value == value:
                flag = True
                break
                pass

    # 先判断东北方向的对角下输赢 x 列轴， y是行轴 ， i 是行 j 是列（右斜向）（在边缘依次逐一遍历，是否五个棋子的类型一样）
    for x, y in zip(range(j + 4, j - 5, -1), range(i - 4, i + 5)):
        if x >= 0 and x + 4 < 15 and y + 4 >= 0 and y < 15:
            if initChessList[y][x].value == value and \
                    initChessList[y - 1][x + 1].value == value and \
                    initChessList[y - 2][x + 2].value == value and \
                    initChessList[y - 3][x + 3].value == value and \
                    initChessList[y - 4][x + 4].value == value:
                flag = True

    # 2、判断西北方向的对角下输赢 x 列轴， y是行轴 ， i 是行 j 是列（左斜向）（在边缘依次逐一遍历，是否五个棋子的类型一样）
    for x, y in zip(range(j - 4, j + 5), range(i - 4, i + 5)):
        if x >= 0 and x + 4 < 15 and y >= 0 and y + 4 < 15:
            if initChessList[y][x].value == value and \
                    initChessList[y + 1][x + 1].value == value and \
                    initChessList[y + 2][x + 2].value == value and \
                    initChessList[y + 3][x + 3].value == value and \
                    initChessList[y + 4][x + 4].value == value:
                flag = True


    if flag:               #如果条件成立，证明五子连珠
        resultFlag = value #获取成立的棋子颜色
        print("白棋赢" if value ==1 else "黑棋赢")

# 加载素材
def main():
    global initChessList,resultFlag
    initChessSquare(27,27)
    pygame.init()     # 初始化游戏环境
    screen = pygame.display.set_mode((620,620),0,0)          # 创建游戏窗口 # 第一个参数是元组：窗口的长和宽
    pygame.display.set_caption("老手er五子棋")                # 添加游戏标题
    background = pygame.image.load("images/bg.png")          #加载背景图片
    whiteStorn = pygame.image.load("images/storn_white.png") #加载白棋图片
    blackStorn = pygame.image.load("images/storn_black.png") #加载黑棋图片
    resultStorn = pygame.image.load("images/resultStorn.jpg")#加载 赢 时的图片
    rect = blackStorn.get_rect()

    while True:
        screen.blit(background,(0,0))
        for temp in initChessList:
            for point in temp:
                if point.value == 1:          #当棋子类型为1时，绘制白棋
                    screen.blit(whiteStorn,(point.x-18,point.y-18))
                elif point.value == 2:        #当棋子类型为2时，绘制黑棋
                    screen.blit(blackStorn,(point.x-18,point.y-18))

        if resultFlag >0:
            initChessList = []                 # 清空棋盘
            initChessSquare(27,27)             # 重新初始化棋盘
            screen.blit(resultStorn,(200,200)) #绘制获胜时的图片
        pygame.display.update()                #更新视图

        if resultFlag >0:
            time.sleep(3)
            resultFlag = 0                     #置空之前的获胜结果
        eventHander()                          #调用之前定义的事件函数
if __name__ == '__main__':
    main()        #调用主函数绘制窗口
    pass
 
至此，对访问当前博客的你来说，或许对游戏也有了新的认识吧！没错，之前的我也感同身受。时不我待，咱们下篇博客见。当然，如有纰漏，请多指教！