summaryrefslogtreecommitdiff
path: root/src/main/kotlin/io/dico/parcels2/ParcelsPlugin.kt
blob: 82a6f592eec1a0753077f59a0379b6f15849ec9e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package io.dico.parcels2

import io.dico.dicore.command.EOverridePolicy
import io.dico.dicore.command.ICommandDispatcher
import io.dico.parcels2.command.getParcelCommands
import io.dico.parcels2.storage.Storage
import io.dico.parcels2.storage.yamlObjectMapper
import io.dico.parcels2.util.tryCreate
import org.bukkit.Bukkit
import org.bukkit.plugin.java.JavaPlugin
import org.slf4j.LoggerFactory
import java.io.File

val logger = LoggerFactory.getLogger("ParcelsPlugin")

private inline val plogger get() = logger
const val debugging = true

class ParcelsPlugin : JavaPlugin() {
    lateinit var optionsFile: File
    lateinit var options: Options
    lateinit var worlds: Worlds
    lateinit var storage: Storage
    private var cmdDispatcher: ICommandDispatcher? = null

    override fun onEnable() {
        if (!init()) {
            Bukkit.getPluginManager().disablePlugin(this)
            return
        }

        registerCommands()
    }

    override fun onDisable() {
        cmdDispatcher?.unregisterFromCommandMap()
    }

    private fun init(): Boolean {
        optionsFile = File(dataFolder, "options.yml")
        options = Options()
        worlds = Worlds(this)

        try {
            if (!loadOptions()) return false

            try {
                storage = options.storage.newStorageInstance()
                storage.init()
            } catch (ex: Exception) {
                plogger.error("Failed to connect to database", ex)
                return false
            }

            worlds.loadWorlds(options)
        } catch (ex: Exception) {
            plogger.error("Error loading options", ex)
            return false
        }

        return true
    }

    fun loadOptions(): Boolean {
        if (optionsFile.exists()) {
            yamlObjectMapper.readerForUpdating(options).readValue<Options>(optionsFile)
        } else if (optionsFile.tryCreate()) {
            options.addWorld("plotworld", WorldOptions())
            try {
                yamlObjectMapper.writeValue(optionsFile, options)
            } catch (ex: Throwable) {
                optionsFile.delete()
                throw ex
            }
        } else {
            plogger.error("Failed to save options file ${optionsFile.canonicalPath}")
            return false
        }
        return true
    }

    private fun registerCommands() {
        cmdDispatcher = getParcelCommands(this).apply {
            registerToCommandMap("parcels:", EOverridePolicy.FALLBACK_ONLY)
        }
    }

}