原文： http://zetcode.com/kotlin/snake/

Kotlin 贪食蛇游戏教程展示了如何使用 Swing 在 Kotlin 中创建蛇游戏。

源代码和图像可从作者的 Github Kotlin-Snake-Game 存储库中获得。

贪食蛇

贪食蛇是较旧的经典视频游戏。 它最初是在 70 年代后期创建的。 后来它被带到 PC 上。 在这个游戏中，玩家控制蛇。 游戏的目的是尽可能多地吃苹果。 当蛇吃了一个苹果时，它的身体就长了。 蛇必须避开墙壁和自己的身体。 该游戏有时称为 Nibbles 。

Swing

Swing 是 Java 编程语言的主要 GUI 工具包。 它是 JFC（Java 基础类）的一部分，JFC 是用于为 Java 程序提供图形用户界面的 API。

Kotlin 贪食蛇游戏

蛇的每个关节的大小为 10 像素。 蛇由光标键控制。 最初，蛇具有三个关节。 如果游戏结束，则在面板中间显示"Game Over"消息。

Board.kt

  1. package com.zetcode
  3. import java.awt.*
  4. import java.awt.event.ActionEvent
  5. import java.awt.event.ActionListener
  6. import java.awt.event.KeyAdapter
  7. import java.awt.event.KeyEvent
  9. import javax.swing.ImageIcon
  10. import javax.swing.JPanel
  11. import javax.swing.Timer
  13. class Board : JPanel(), ActionListener {
  15.     private val boardWidth = 300
  16.     private val boardHeight = 300
  17.     private val dotSize = 10
  18.     private val allDots = 900
  19.     private val randPos = 29
  20.     private val delay = 140
  22.     private val x = IntArray(allDots)
  23.     private val y = IntArray(allDots)
  25.     private var nOfDots: Int = 0
  26.     private var appleX: Int = 0
  27.     private var appleY: Int = 0
  29.     private var leftDirection = false
  30.     private var rightDirection = true
  31.     private var upDirection = false
  32.     private var downDirection = false
  33.     private var inGame = true
  35.     private var timer: Timer? = null
  36.     private var ball: Image? = null
  37.     private var apple: Image? = null
  38.     private var head: Image? = null
  40.     init {
  42.         addKeyListener(TAdapter())
  43.         background = Color.black
  44.         isFocusable = true
  46.         preferredSize = Dimension(boardWidth, boardHeight)
  47.         loadImages()
  48.         initGame()
  49.     }
  51.     private fun loadImages() {
  53.         val iid = ImageIcon("src/main/resources/dot.png")
  54.         ball = iid.image
  56.         val iia = ImageIcon("src/main/resources/apple.png")
  57.         apple = iia.image
  59.         val iih = ImageIcon("src/main/resources/head.png")
  60.         head = iih.image
  61.     }
  63.     private fun initGame() {
  65.         nOfDots = 3
  67.         for (z in 0 until nOfDots) {
  68.             x[z] = 50 - z * 10
  69.             y[z] = 50
  70.         }
  72.         locateApple()
  74.         timer = Timer(delay, this)
  75.         timer!!.start()
  76.     }
  78.     public override fun paintComponent(g: Graphics) {
  79.         super.paintComponent(g)
  81.         doDrawing(g)
  82.     }
  84.     private fun doDrawing(g: Graphics) {
  86.         if (inGame) {
  88.             g.drawImage(apple, appleX, appleY, this)
  90.             for (z in 0 until nOfDots) {
  91.                 if (z == 0) {
  92.                     g.drawImage(head, x[z], y[z], this)
  93.                 } else {
  94.                     g.drawImage(ball, x[z], y[z], this)
  95.                 }
  96.             }
  98.             Toolkit.getDefaultToolkit().sync()
  100.         } else {
  102.             gameOver(g)
  103.         }
  104.     }
  106.     private fun gameOver(g: Graphics) {
  108.         val msg = "Game Over"
  109.         val small = Font("Helvetica", Font.BOLD, 14)
  110.         val fontMetrics = getFontMetrics(small)
  112.         val rh = RenderingHints(
  113.                 RenderingHints.KEY_ANTIALIASING,
  114.                 RenderingHints.VALUE_ANTIALIAS_ON)
  116.         rh[RenderingHints.KEY_RENDERING] = RenderingHints.VALUE_RENDER_QUALITY
  118.         (g as Graphics2D).setRenderingHints(rh)
  120.         g.color = Color.white
  121.         g.font = small
  122.         g.drawString(msg, (boardWidth - fontMetrics.stringWidth(msg)) / 2, 
  123.             boardHeight / 2)
  124.     }
  126.     private fun checkApple() {
  128.         if (x[0] == appleX && y[0] == appleY) {
  130.             nOfDots++
  131.             locateApple()
  132.         }
  133.     }
  135.     private fun move() {
  137.         for (z in nOfDots downTo 1) {
  138.             x[z] = x[z - 1]
  139.             y[z] = y[z - 1]
  140.         }
  142.         if (leftDirection) {
  143.             x[0] -= dotSize
  144.         }
  146.         if (rightDirection) {
  147.             x[0] += dotSize
  148.         }
  150.         if (upDirection) {
  151.             y[0] -= dotSize
  152.         }
  154.         if (downDirection) {
  155.             y[0] += dotSize
  156.         }
  157.     }
  159.     private fun checkCollision() {
  161.         for (z in nOfDots downTo 1) {
  163.             if (z > 4 && x[0] == x[z] && y[0] == y[z]) {
  164.                 inGame = false
  165.             }
  166.         }
  168.         if (y[0] >= boardHeight) {
  169.             inGame = false
  170.         }
  172.         if (y[0] < 0) {
  173.             inGame = false
  174.         }
  176.         if (x[0] >= boardWidth) {
  177.             inGame = false
  178.         }
  180.         if (x[0] < 0) {
  181.             inGame = false
  182.         }
  184.         if (!inGame) {
  185.             timer!!.stop()
  186.         }
  187.     }
  189.     private fun locateApple() {
  191.         var r = (Math.random() * randPos).toInt()
  192.         appleX = r * dotSize
  194.         r = (Math.random() * randPos).toInt()
  195.         appleY = r * dotSize
  196.     }
  198.     override fun actionPerformed(e: ActionEvent) {
  200.         if (inGame) {
  202.             checkApple()
  203.             checkCollision()
  204.             move()
  205.         }
  207.         repaint()
  208.     }
  210.     private inner class TAdapter : KeyAdapter() {
  212.         override fun keyPressed(e: KeyEvent?) {
  214.             val key = e!!.keyCode
  216.             if (key == KeyEvent.VK_LEFT && !rightDirection) {
  217.                 leftDirection = true
  218.                 upDirection = false
  219.                 downDirection = false
  220.             }
  222.             if (key == KeyEvent.VK_RIGHT && !leftDirection) {
  223.                 rightDirection = true
  224.                 upDirection = false
  225.                 downDirection = false
  226.             }
  228.             if (key == KeyEvent.VK_UP && !downDirection) {
  229.                 upDirection = true
  230.                 rightDirection = false
  231.                 leftDirection = false
  232.             }
  234.             if (key == KeyEvent.VK_DOWN && !upDirection) {
  235.                 downDirection = true
  236.                 rightDirection = false
  237.                 leftDirection = false
  238.             }
  239.         }
  240.     }
  241. }

首先，我们将定义游戏中使用的属性。

  1. private val boardWidth = 300
  2. private val boardHeight = 300
  3. private val dotSize = 10
  4. private val allDots = 900
  5. private val randPos = 29
  6. private val delay = 140

boardWidth和boardHeight属性确定电路板的大小。 dotSize是苹果的大小和蛇的点。 allDots属性定义了板上可能的最大点数（900 = (300 * 300) / (10 * 10)）。 randPos属性用于计算苹果的随机位置。 delay属性确定游戏的速度。

  1. private val x = IntArray(allDots)
  2. private val y = IntArray(allDots)

这两个数组存储蛇的所有关节的x和y坐标。

  1. private fun loadImages() {
  3.     val iid = ImageIcon("src/main/resources/dot.png")
  4.     ball = iid.image
  6.     val iia = ImageIcon("src/main/resources/apple.png")
  7.     apple = iia.image
  9.     val iih = ImageIcon("src/main/resources/head.png")
  10.     head = iih.image
  11. }

在loadImages()方法中，我们获得了游戏的图像。 ImageIcon类用于显示 PNG 图像。

  1. private fun initGame() {
  3.     nOfDots = 3
  5.     for (z in 0 until nOfDots) {
  6.         x[z] = 50 - z * 10
  7.         y[z] = 50
  8.     }
  10.     locateApple()
  12.     timer = Timer(delay, this)
  13.     timer!!.start()
  14. }

在initGame()方法中，我们创建蛇，在板上随机放置一个苹果，然后启动计时器。

  1. private fun doDrawing(g: Graphics) {
  3.     if (inGame) {
  5.         g.drawImage(apple, appleX, appleY, this)
  7.         for (z in 0 until nOfDots) {
  8.             if (z == 0) {
  9.                 g.drawImage(head, x[z], y[z], this)
  10.             } else {
  11.                 g.drawImage(ball, x[z], y[z], this)
  12.             }
  13.         }
  15.         Toolkit.getDefaultToolkit().sync()
  17.     } else {
  19.         gameOver(g)
  20.     }
  21. }

在doDrawing()方法中，我们绘制了苹果和蛇对象。 如果游戏结束，我们将根据消息绘制游戏。

  1. private fun gameOver(g: Graphics) {
  3.     val msg = "Game Over"
  4.     val small = Font("Helvetica", Font.BOLD, 14)
  5.     val fontMetrics = getFontMetrics(small)
  7.     val rh = RenderingHints(
  8.             RenderingHints.KEY_ANTIALIASING,
  9.             RenderingHints.VALUE_ANTIALIAS_ON)
  11.     rh[RenderingHints.KEY_RENDERING] = RenderingHints.VALUE_RENDER_QUALITY
  13.     (g as Graphics2D).setRenderingHints(rh)
  15.     g.color = Color.white
  16.     g.font = small
  17.     g.drawString(msg, (boardWidth - fontMetrics.stringWidth(msg)) / 2, 
  18.         boardHeight / 2)
  19. }

gameOver()方法在窗口中间绘制"Game Over"消息。 我们使用渲染提示来平滑地绘制消息。 我们使用字体指标来获取消息的大小。

  1. private fun checkApple() {
  3.     if (x[0] == appleX && y[0] == appleY) {
  5.         nOfDots++
  6.         locateApple()
  7.     }
  8. }

如果苹果与头部碰撞，我们会增加蛇的关节数。 我们称locateApple()方法为随机放置一个新的Apple对象。

在move()方法中，我们有游戏的关键算法。 要了解它，请看一下蛇是如何运动的。 我们控制蛇的头。 我们可以使用光标键更改其方向。 其余关节在链上向上移动一个位置。 第二关节移动到第一个关节的位置，第三关节移动到第二个关节的位置，依此类推。

  1. for (z in nOfDots downTo 1) {
  2.     x[z] = x[z - 1]
  3.     y[z] = y[z - 1]
  4. }

该代码将关节向上移动。

  1. if (leftDirection) {
  2.     x[0] -= dotSize
  3. }

这条线将头向左移动。

在checkCollision()方法中，我们确定蛇是否击中了自己或撞墙之一。

  1. for (z in nOfDots downTo 1) {
  3.     if (z > 4 && x[0] == x[z] && y[0] == y[z]) {
  4.         inGame = false
  5.     }
  6. }

如果蛇用头撞到其关节之一，则游戏结束。

  1. if (y[0] >= boardHeight) {
  2.     inGame = false
  3. }

如果蛇击中了棋盘的底部，则游戏结束。

Snake.kt

  1. package com.zetcode
  3. import java.awt.EventQueue
  4. import javax.swing.JFrame
  6. class Snake : JFrame() {
  8.     init {
  10.         initUI()
  11.     }
  13.     private fun initUI() {
  15.         add(Board())
  17.         title = "Snake"
  19.         isResizable = false
  20.         pack()
  22.         setLocationRelativeTo(null)
  23.         defaultCloseOperation = JFrame.EXIT_ON_CLOSE
  24.     }
  26.     companion object {
  28.         @JvmStatic
  29.         fun main(args: Array<String>) {
  31.             EventQueue.invokeLater {
  32.                 val ex = Snake()
  33.                 ex.isVisible = true
  34.             }
  35.         }
  36.     }
  37. }

这是主要的类。

  1. isResizable = false
  2. pack()

isResizable属性会影响某些平台上JFrame容器的插入。 因此，在pack()方法之前调用它很重要。 否则，蛇的头部与右边界和底边界的碰撞可能无法正常进行。

Kotlin 贪食蛇 - 图1

图：贪食蛇

这是 Kotlin 和 Swing 中的贪食蛇游戏。 您可能也对相关教程感兴趣： Kotlin Swing 教程， Kotlin 读取文件教程和 Kotlin 写入文件教程。