300行代码不到的tornadofx拼图游戏

package com.cyy.game.pingtu

import javafx.application.Application
import javafx.beans.property.SimpleObjectProperty
import javafx.event.EventHandler
import javafx.geometry.Pos
import javafx.geometry.Rectangle2D
import javafx.scene.control.Alert
import javafx.scene.control.RadioButton
import javafx.scene.image.Image
import javafx.scene.image.ImageView
import javafx.scene.input.MouseEvent
import javafx.scene.layout.GridPane
import javafx.scene.layout.VBox
import javafx.stage.FileChooser
import tornadofx.*
import java.io.File
import java.util.*
import kotlin.math.sqrt

fun main(args: Array<String>) = Application.launch(PingTuApp::class.java, *args)

class PingTuApp : App(PingTuView::class)

class PingTuView : View("拼图") {
    var N = intProperty(4)
    var n = random(N.value - 1)              //自定义的函数，产生逆序数为偶数的不重复数组
    var m = findnum(n)  //找出那个不在随机数组里面的数字
    var imageViews = (1..N.value).map { ImageView() }.toTypedArray()
    // 大图片路径
    val imgPath = stringProperty("pingtu/1.png")
    // 空图片路径
    val imgBlankPath = "pingtu/2.png"
    lateinit var rbox: VBox
    lateinit var gridPane: GridPane
    lateinit var bigImageView: ImageView
    lateinit var smallImageView: ImageView
    val bigImage = SimpleObjectProperty<Image>()
    val smallImage = SimpleObjectProperty<Image>()
    // 大图片宽度
    val imageSize = 300.0
    // 每个小方格宽度
    var smallSize = imageSize / sqrt(N.value.toDouble())

    override val root = borderpane {
        paddingAll = 10
        prefHeight = 700.0
        prefWidth = 1000.0
        primaryStage.isResizable = false
        top = hbox(10) {
            alignment=Pos.CENTER
            button("选择图片") {
                action {
                    val imgType = listOf("*.jpg", "*.png", "*.bmp", "*.gif")
                    val efset = arrayOf(FileChooser.ExtensionFilter("$imgType", imgType))
                    val imgFile = chooseFile("选择图片", efset, FileChooserMode.Single) {
                        // p初始目录为当前项目目录
                        initialDirectory = File(File("").canonicalPath)
                    }
                    if (imgFile.isNotEmpty()) {
                        val imgPath = imgFile.first().toString().replace("\\", "/")
                        bigImage.value = Image(File(imgPath).inputStream())
                        imageViews=initImageViews1(N.value, imgPath)
                        initView(N.value, imgPath, smallSize,imageViews)
                    }
                }
            }

            togglegroup {
                listOf(4,9, 16, 25).map { v ->
                    radiobutton(v.toString(), this, v) { if (v === 4) isSelected = true }
                }
                selectedToggleProperty().addListener { _, _, _ ->
                    N.value = (selectedToggle as RadioButton).text.toInt()
                    smallSize = imageSize / sqrt(N.value.toDouble())
                }
            }

            button("重置") {
                action {
                    bigImage.value = Image(imgPath.value)

                    imageViews =initImageViews(N.value,imgPath.value)
                    initView(N.value, imgPath.value, smallSize,imageViews)
                }
            }
            paddingAll = 10
        }
        center = gridpane {
            alignment=Pos.CENTER

            gridPane = this
            isGridLinesVisible = true
        }
        right = vbox(20) {
            alignment=Pos.CENTER

            rbox = this
            //显示空格子的图片
            imageview(smallImage) {
                smallImageView = this
            }
            //完整的大图
            imageview(bigImage) {
                bigImageView = this
                fitHeight = imageSize
                fitWidth = imageSize
            }
        }
    }

    inner class Myevent : EventHandler<MouseEvent> {               //点击事件的实现
        override fun handle(arg0: MouseEvent) {
            val img = arg0.source as ImageView
            val sx = img.layoutX
            val sy = img.layoutY
            val dispx = sx - imageViews[m].layoutX
            val dispy = sy - imageViews[m].layoutY
            if (dispx == -smallSize && dispy == 0.0) {               //点击的空格左边的格子
                swapimg(img, imageViews[m])             //交换imageView
                if (issucc(imageViews)) {                          //判断是否拼成功
                    val alert = Alert(Alert.AlertType.WARNING, "成功！")
                    alert.show()
                }
            } else if (dispx == 0.0 && dispy == -smallSize) {        //上面的格子
                swapimg(img, imageViews[m])
                if (issucc(imageViews)) {
                    val alert = Alert(Alert.AlertType.WARNING, "成功！")
                    alert.show()
                }
            } else if (dispx == smallSize && dispy == 0.0) {               //右边的格子
                swapimg(img, imageViews[m])
                if (issucc(imageViews)) {
                    val alert = Alert(Alert.AlertType.WARNING, "成功！")
                    alert.show()
                }
            } else if (dispx == 0.0 && dispy == smallSize) {                //下面的格子
                swapimg(img, imageViews[m])
                if (issucc(imageViews)) {
                    val alert = Alert(Alert.AlertType.WARNING, "成功！")
                    alert.show()
                }
            }
        }

        fun swapimg(i1: ImageView, i2: ImageView) {              //交换两个imageView的实现
            val row1 = GridPane.getRowIndex(i1)
            val colu1 = GridPane.getColumnIndex(i1)
            val row2 = GridPane.getRowIndex(i2)
            val colu2 = GridPane.getColumnIndex(i2)

            GridPane.setRowIndex(i1, row2)
            GridPane.setColumnIndex(i1, colu2)
            GridPane.setRowIndex(i2, row1)
            GridPane.setColumnIndex(i2, colu1)
        }
    }

    init {
        imageViews =initImageViews(N.value,imgPath.value)
        initView(N.value, imgPath.value, smallSize,imageViews)
    }

    // nn : 9,16,25
    fun initView(nn: Int, imgPath: String, smallSize: Double,imageViews:Array<ImageView>) {
        n = random(nn)              //自定义的函数，产生逆序数为偶数的不重复数组
        m = findnum(n)  //找出那个不在随机数组里面的数字
        gridPane.clear()
        // nn1 =3,4,5
        val nn1 = sqrt(nn.toDouble()).toInt()
        var i = 0
        var k = 0
        while (i <= nn1 - 1) {
            var j = 0
            while (j <= nn1 - 1) {
                //切割图片
                imageViews[k].viewport = Rectangle2D(smallSize * j, smallSize * i, smallSize, smallSize)
                ++j
                ++k
            }
            ++i
        }

        // nn1-1=2,3,4
        var t = 0
        (0 until nn1).forEach { r ->
            (0 until nn1).forEach { c ->
                if (t < nn - 1) {
                    gridPane.add(imageViews[n[t]], c, r)
                }
                ++t
            }
        }

        smallImage.value = imageViews[m].image
        smallImageView.viewport = imageViews[m].viewport

        imageViews[m].image = Image(imgBlankPath) //2.png为一个透明图，放在空格子中
        gridPane.add(imageViews[m], nn1 - 1, nn1 - 1)
    }

    //读取类路径下的图片
    fun initImageViews(nn: Int, imgPath: String):Array<ImageView>{
        return (1..nn).map {
            imageview(imgPath) {
                onMouseClicked = Myevent()
            }
        }.toTypedArray()
    }
    //读取电脑文件系统中图片文件的路径
    fun initImageViews1(nn: Int, imgPath: String):Array<ImageView>{
        return (1..nn).map {
            imageview(Image(File(imgPath).inputStream())) {
                onMouseClicked = Myevent()
            }
        }.toTypedArray()
    }

    //判断是否拼成功
    fun issucc(imageViews: Array<ImageView>): Boolean {
        val t = imageViews.size
        imageViews.indices.forEach { i ->
            if (i != sqrt(t.toDouble()).toInt() * GridPane.getRowIndex(imageViews[i]) + GridPane.getColumnIndex(imageViews[i])) {
                return false
            }
        }
        return true
    }

    fun findnum(n: IntArray): Int {
        (n.indices).forEach { j ->
            if (j in n) {
            } else {
                return j
            }
        }

        return -1
    }

    //生成nn个不重复的逆序数为偶数的数字
    fun random(nn: Int): IntArray {
        var ran = IntArray(nn)
        while (!iso(ran)) {
            ran = random_num(nn)
        }
        return ran
    }

    //生成nn个不重复数
    fun random_num(nn: Int): IntArray {
        val r = IntArray(nn)
        val random = Random()
        var i = 0
        while (i < nn - 1) {
            r[i] = random.nextInt(nn)
            for (j in 0 until i) {
                while (r[i] == r[j]) {
                    i--
                    break
                }
            }
            ++i
        }
        return r
    }

    //判断逆序数是否为偶数
    fun iso(num: IntArray): Boolean {
        var sum = 0
        val t = num.size
        for (i in 0..t - 2) {
            for (j in i..t - 1) {
                if (num[i] > num[j]) {
                    sum++
                }
            }
        }
        return sum % 2 == 0 && sum != 0
    }
}