API

Zdarzenia

Zdarzenie opisuje coś, co stało się w grze: gracz dołączył, blok został zniszczony, coś otrzymało obrażenia. Nie opisuje, jaki wewnętrzny kod gry się wykonał, dlatego mod, który nasłuchuje join, działa dalej, nawet gdy ten kod się zmienia.

Nasłuchiwanie zdarzenia

events/mining.craftCraftScript

import { give_rubies } from "/lib/rewards"
import { SETTINGS } from "/settings"

on break(e) {
    let p = e.player
    if p == null { return }
    if e.block.type == "minecraft:diamond_ore" and chance(SETTINGS["bonus_chance"]) {
        give_rubies(p, 1)
        p.play_sound("rubies:ruby_chime")
        p.world.spawn_particle("rubies:ruby_spark", e.block.location, 12, 0.4, 0.02)
    }
}

events/MiningEvents.ktKotlin

package com.example.rubies.events

object MiningEvents {
    fun register(config: RubiesConfig) {
        Crafting.events.on<BlockBreakEvent> { e ->
            val player = e.player ?: return@on
            if (e.block.type.path == "diamond_ore" && Math.random() < config.dropChance) {
                player.give(ItemStack.of(Items.RUBY))
                player.playSound(Identifier.parse(Sounds.CHIME))
                player.world.spawnParticle(Identifier.parse(Particles.SPARK), e.block.location, count = 12, spread = 0.4, speed = 0.02)
            }
        }
    }
}

W CraftScript właściwości zdarzenia są dostępne jako zmienne (player, block…) albo przez nazwę, którą mu nadasz (on break(e)). Każdego zdarzenia możesz nasłuchiwać z dowolnej liczby plików: umieść każdą zasadę w pliku jej tematu.

Wszystkie zdarzenia

Wszystkie są wywoływane w prawdziwej grze, po stronie klienta lub serwera, zależnie od przypadku. W CraftScript możesz użyć krótkiej lub długiej nazwy w snake_case (join lub player_join).

CraftScript	Kotlin	Właściwości	Można anulować
`server_starting`	`ServerStartingEvent`	server
`start`	`ServerStartedEvent`	server
`stop`	`ServerStoppingEvent`	server
`tick`	`ServerTickEvent`	server, tick, phase
`client_tick`	`ClientTickEvent`	tick, phase
`world_load`	`WorldLoadEvent`	world
`world_unload`	`WorldUnloadEvent`	world
`join`	`PlayerJoinEvent`	player, join_message
`quit, leave`	`PlayerQuitEvent`	player, quit_message
`chat`	`PlayerChatEvent`	player, message	Tak
`respawn`	`PlayerRespawnEvent`	player, location
`death`	`PlayerDeathEvent`	player, death_message, keep_inventory
`interact`	`PlayerInteractBlockEvent`	player, block, hand, item	Tak
`interact_entity`	`PlayerInteractEntityEvent`	player, entity, hand, item	Tak
`attack`	`PlayerAttackEvent`	player, target	Tak
`key`	`PlayerKeyEvent`	player, key
`use_item`	`PlayerUseItemEvent`	player, item, hand	Tak
`command`	`PlayerCommandEvent`	player, command	Tak
`break`	`BlockBreakEvent`	player (może być null), block, drop_items	Tak
`place`	`BlockPlaceEvent`	player (może być null), block, placed	Tak
`spawn`	`EntitySpawnEvent`	entity	Tak
`damage`	`EntityDamageEvent`	entity, damage_type, amount (modyfikowalne), attacker	Tak
`entity_death`	`EntityDeathEvent`	entity, drops
`hit`	`ProjectileHitEvent`	projectile, shooter, entity or block	Tak
`ready`	`ModsLoadedEvent`	mod_ids
`plugin_reload`	`PluginReloadEvent`	plugin_id

Zmiana tego, co się dzieje

Niektóre właściwości można zmienić, a gra się do nich stosuje:

Zdarzenie	Właściwość	Efekt
`chat`	`message`	Gracz mówi nowy tekst.
`command`	`command`	Wykonuje się nowe polecenie, jako ten gracz.
`join`, `quit`	`join_message`, `quit_message`	Ogłaszane wszystkim, oprócz komunikatu gry.
`respawn`	`location`	Gracz odradza się tam.
`break`	`drop_items = false`	Blok niczego nie upuszcza.
`damage`	`amount`	Otrzymane obrażenia mają nową wartość.
`entity_death`	`drops.add(…)`	Dodane przedmioty wypadają tam, gdzie byt zginął, oprócz jego zwykłego łupu.

events/hunting.craftCraftScript

on entity_death(e) {
    if e.entity.type == "minecraft:zombie" and chance(0.05) {
        e.drops.add(item("rubies:ruby", 1))
    }
}

interact_entity to kliknięcie prawym przyciskiem na jednostkę: po anulowaniu nic się nie dzieje (bez dojenia, handlu i jazdy). attack to gracz uderzający jednostkę: po anulowaniu nie ma uderzenia. damage podaje attacker, czyli kto stoi za obrażeniami: atakujący albo strzelec z pocisku. key uruchamia się, gdy gracz naciśnie klawisz moda (zob. Interfejs).

events/entities.craftCraftScript

on interact_entity(e) {
    if e.entity.type == "minecraft:cow" { e.player.send("This cow won't be milked"); e.cancel() }
}

on attack(e) {
    if e.target.type == "minecraft:pig" { e.player.action_bar("This pig is protected"); e.cancel() }
}

Jeszcze niestosowane. W death zmiana death_message lub keep_inventory nie ma jeszcze efektu. Crafting ostrzega o tym raz w dzienniku, zamiast po cichu to pomijać.

Priorytet i anulowanie

Kolejność: highest, high, normal, low, lowest i monitor. Gdy nasłuchiwacz anuluje zdarzenie, kolejne się nie wykonują, z wyjątkiem nasłuchiwaczy monitor (a w Kotlinie tych, które przekazują ignoreCancelled = true). Nasłuchiwacz monitor tylko obserwuje: nie może zmieniać zdarzenia.

events/falls.craftCraftScript

on damage(e) priority high {
    if e.damage_type == "minecraft:fall" {
        e.amount = e.amount / 2        // łagodniejsze lądowania
    }
}

events/ChatEvents.ktKotlin

object ChatEvents {
    fun register() {
        Crafting.events.on<PlayerChatEvent>(EventPriority.HIGHEST) { e ->
            if (e.message.startsWith("!")) e.cancel()
        }
        Crafting.events.on<PlayerChatEvent>(EventPriority.MONITOR) { e ->
            if (!e.isCancelled) Crafting.runtime.logger("chat").info("${e.player.name}: ${e.message}")
        }
    }
}

Gdy coś zawiedzie

Nasłuchiwacz, który rzuci błąd, trafia do dziennika z nazwą swojego moda, a pozostałe nasłuchiwacze działają dalej.
/crafting profile (dwa razy: start, potem podgląd) pokazuje, ile czasu każdy mod spędza w swoich zdarzeniach.
Zdarzenie, którego nikt nie nasłuchuje, nie jest nawet tworzone, więc nasłuchiwanie niewielu zdarzeń nic nie kosztuje.