Stworzenia

Własne stworzenie korzysta z ciała stworzenia z gry (jego modelu, animacji, rozmiaru i sposobu poruszania się) z twoją teksturą nałożoną na wierzch, twoimi statystykami, twoim zachowaniem i twoim łupem. Deklarujesz je jak resztę zawartości: jako listę właściwości.

Zadeklaruj stworzenie

creature "ghost" {
    body: "minecraft:zombie"
    texture: "entity/ghost"
    health: 40
    speed: 0.3
    attack: 4
    behaviour: ["swim", "melee_attack", { wander: 0.8 }, { look_at_players: 10 }, "look_around"]
    targets: ["hurt_by", "minecraft:pig"]
    loot: [ { item: "ghostmod:ecto", count: [1, 2] } ]
}

Właściwość	Wartości	Domyślnie
body	id stworzenia z gry: minecraft:zombie, minecraft:wolf, minecraft:cow…	wymagane
texture	ścieżka tekstury nakładanej na model ciała: entity/ghost to textures/entity/ghost.png moda	wygląd ciała
model	własny model 3D: entity/robot to models/entity/robot.json moda (niżej)	model ciała
size	[szerokość, wysokość] w blokach: z czym koliduje i gdzie się je klika (niżej)	rozmiar ciała
health	punkty zdrowia	jak u ciała
speed	prędkość chodzenia (zombie porusza się z prędkością 0.23, wilk 0.3)	jak u ciała
attack	obrażenia ataku wręcz	jak u ciała
follow_range	z ilu bloków wykrywa swoje cele	jak u ciała
behaviour	lista zachowań, od najważniejszego do najmniej ważnego (niżej)	zachowanie ciała
targets	kogo atakuje, według priorytetu (niżej)	nikogo
loot	[{ item, count, chance }, …], tak jak w blokach: każdy przedmiot jest losowany osobno	nic
spawns	biomy, w których pojawia się samo, z wagą i rozmiarem grupy (niżej)	nie pojawia się samo
breed_item	przedmiot, po którym dwa osobniki się rozmnażają (niżej)	nie rozmnaża się
tame_item	przedmiot, który je oswaja (niżej)	nie da się oswoić
rideable	true pozwala graczom na nim jeździć (niżej)	false

Zachowania

Lista to priorytet: gdy dwa zachowania chcą działać naraz, wygrywa wcześniejsze. Zapisz każde jako nazwę, jako { name: number } dla jego głównego ustawienia albo jako mapę ze wszystkimi ustawieniami.

Zachowanie	Co robi	Ustawienia
"swim"	Utrzymuje się na wodzie.
"look_around"	Rozgląda się, gdy nic nie robi.
"wander", { wander: 0.8 }	Wędruje po okolicy.	speed, domyślnie 1
"look_at_players", { look_at_players: 10 }	Patrzy na pobliskich graczy.	range w blokach, domyślnie 8
"melee_attack", { melee_attack: 1.2 }	Goni swój cel i go uderza.	speed, domyślnie 1
"panic", { panic: 1.5 }	Ucieka, gdy otrzyma obrażenia.	speed, domyślnie 1.25
{ avoid: "minecraft:wolf", distance: 8, speed: 1.2 }	Trzyma się z dala od tego stworzenia.	distance w blokach, speed
{ follow: "minecraft:wheat", speed: 1 }	Podąża za tym, kto trzyma ten przedmiot.	speed
{ ranged_attack: "minecraft:snowball", interval: 20, range: 14, damage: 3 }	Strzela pociskiem do swojego celu (niżej).	projectile, interval, range, speed, power, damage
"breed", { breed: 1 }	Rozmnaża się z innym osobnikiem swojego gatunku po nakarmieniu.	speed
"follow_parent", { follow_parent: 1.1 }	Młode trzyma się blisko rodzica.	speed
{ follow_owner: 1.2, distance: 8 }	Oswojone stworzenie podąża za właścicielem.	speed, distance w blokach
{ fly_around: 1 }	Lata dookoła; dla latających ciał (papuga, pszczoła, allay).	speed
{ can_start: …, tick: … }	Twój własny kod (niżej).	can_start, tick, keep_going, moves

Liczby prędkości mnożą prędkość bazową stworzenia: { wander: 0.8 } wędruje nieco wolniej, niż chodzi.

Cele

targets mówi, kogo atakuje, od najwyższego do najniższego priorytetu. "hurt_by" to ten, kto zadaje mu obrażenia; id bytu to najbliższy byt tego rodzaju ("minecraft:player" dla graczy, "minecraft:pig" dla świń). Żeby atak nastąpił, stworzenie potrzebuje zachowania, które go wykonuje, na przykład "melee_attack".

Przywołaj je

command haunt requires "ghostmod.haunt" describe "Przywołuje ducha tam, gdzie stoisz" {
    if player == null { return "Tylko dla graczy" }
    world().spawn("ghostmod:ghost", player.location)
    return "&7Pojawia się duch…"
}

Id należy do twojego moda: ghostmod:ghost. Polecenie gry /summon ghostmod:ghost też działa.

Pojawianie się samoistnie

Dodaj spawns, a stworzenie będzie pojawiać się w świecie samo, jak stworzenia z gry.

creature "ghost" {
    body: "minecraft:zombie"
    spawns: [ { biomes: ["minecraft:dark_forest", "#minecraft:is_forest"], weight: 20, group: [1, 2] } ]
}

Każdy wpis podaje biomes, w których się pojawia (id albo #tag dla całej grupy biomów), weight (waga: jak często, w porównaniu z innymi stworzeniami tego biomu; krowa ma 8, zombie 95) i zakres rozmiaru grupy group.

Stosuje zasady pojawiania się swojego ciała: z ciałem zombie pojawia się w ciemności, z ciałem krowy na trawie, przy świetle. Działa to zarówno przy generowaniu świata, jak i później.

Jajo przywołujące. Każde stworzenie dostaje też jajo przywołujące, jego id plus _spawn_egg (ghost_spawn_egg), w kreatywnej karcie jaj przywołujących. Jego tekstura to textures/item/ghost_spawn_egg.png moda, jeśli istnieje; w przeciwnym razie wygląda jak jajo jego ciała.

W Kotlinie:

content.creature("ghost") {
    body = "minecraft:zombie"
    spawn("minecraft:dark_forest", "#minecraft:is_forest", weight = 20, group = 1..2)
}

Sterowanie stworzeniem z kodu

Stworzenia, które deklarujesz, i każdy inny mob to Creature. Ze zdarzenia, polecenia lub timera możesz wydawać im rozkazy:

Element	Co robi
target	Kogo atakuje. Można odczytać i ustawić.
moveTo(location, speed), move_to	Idzie do podanej lokalizacji. Prędkość mnoży jego zwykłą prędkość.
stop()	Przestaje iść.
isMoving, is_moving	Czy dokądś idzie.
lookAt(location), look_at	Obraca się, by spojrzeć na lokalizację.
canSee(entity), can_see	Czy ma czystą linię widzenia do tego bytu.
isBaby	Czy jest młodym.
ownerId	Id jego właściciela, po oswojeniu.
tame(player)	Czyni tego gracza jego właścicielem.
isSitting	Czy siedzi.
playAnimation(name), play_animation	Odtwarza jedną z animacji jego modelu (zobacz niżej).

Każdy byt ma velocity, czyli Vector w blokach na tick. Odczytaj lub ustaw go, by popchnąć byt: entity.velocity = vector(0, 0.6, 0) wyrzuca go w górę.

W CraftScript typowane let zawęża byt do stworzenia. Sprawdza się to w trakcie działania:

command pup requires "dogmod.pup" describe "Get a pet dog" {
    if player == null { return "Players only" }
    let dog: Creature = world().spawn("dogmod:dog", player.location)
    dog.tame(player)
    dog.look_at(player.location)
    dog.velocity = vector(0, 0.6, 0)      // a little hop
    return "&7Good dog!"
}

Własne zachowania

Gdy gotowe nie wystarczą, napisz własne swoim kodem. Trafia na listę behaviour jak każde inne, więc jego miejsce to jego priorytet.

creature "herder" {
    body: "minecraft:wolf"
    targets: ["minecraft:pig"]
    behaviour: [
        "swim",
        {
            can_start: fun(c) { return c.target != null && c.can_see(c.target) },
            tick: fun(c) {
                if c.target != null {
                    c.look_at(c.target.location)
                    if !c.is_moving { c.move_to(c.target.location, 1.2) }
                }
            }
        },
        { wander: 1 }
    ]
}

• can_start: pytane co kilka ticków; zwróć, czy ma się zacząć.
• tick: wykonuje się co tick, gdy zachowanie jest aktywne.
• keep_going: mówi, czy ma trwać dalej. Jeśli pominięte, działa jak can_start.
• moves: domyślnie true. Zachowanie z ruchem nie działa razem z innym takim; wygrywa to wyżej na liście. Użyj false dla tych, które tylko patrzą lub reagują.

W Kotlinie: Behaviour.Custom(canStart = { … }, tick = { … }, keepGoing = …, moves = true)

Zwierzęta: hodowla, oswajanie, jazda i latanie

Kilka właściwości i zachowań zmienia stworzenie w zwierzę. To rozmnaża się za pomocą jabłek, oswaja się je kością i można na nim jeździć:

creature "mooble" {
    body: "minecraft:cow"
    tame_item: "minecraft:bone"
    breed_item: "minecraft:apple"
    rideable: true
    behaviour: ["swim", { breed: 1 }, { follow_parent: 1.1 }, { follow_owner: 1.2, distance: 8 }, { wander: 0.8 }]
}

• Hodowla. breed_item plus zachowanie "breed": nakarmione tym przedmiotem dwa osobniki tego samego gatunku mają młode tego gatunku. Potrzebne jest ciało zwierzęcia (krowa, wilk, kura…). Młode używają "follow_parent", by trzymać się rodziców.
• Oswajanie. tame_item: każda próba udaje się raz na trzy. Właściciel jest zapamiętywany, a oswojone stworzenie nigdy nie atakuje właściciela. Skradaj się i użyj pustą ręką, by usiadło lub wstało. { follow_owner: 1.2, distance: 8 } sprawia, że podąża za właścicielem.
• Jazda. rideable: true: użyj pustą ręką, by wsiąść (po oswojeniu tylko właściciel). Steruje się klawiszami ruchu i myszą; skradaj się, by zsiąść.
• Latanie. { fly_around: 1 } dla latających ciał (papuga, pszczoła, allay). Stworzenie rideable z latającym ciałem wznosi się, gdy jeździec patrzy w górę, i pikuje, gdy patrzy w dół.

W Kotlinie: breedItem = …, tameItem = …, rideable = true oraz zachowania Behaviour.Breed(), Behaviour.FollowParent(), Behaviour.FollowOwner(speed, distance) i Behaviour.FlyAround().

Własne pociski

Oprócz pocisków z gry mod może zadeklarować własne. Ma własne obrażenia, grawitację i to, co dzieje się po trafieniu:

projectile "frost_bolt" {
    damage: 4
    gravity: false
    on_hit: fun(e) {
        let at = e.entity?.location ?? e.block?.location
        if at != null { e.projectile.world.spawn_particle("minecraft:snowflake", at.add(0.5, 1, 0.5), 12, 0.4, 0.02) }
    }
}

• damage: obrażenia zadawane temu, w co trafi.
• gravity: false sprawia, że leci po prostej.
• on_hit: fun(e), wywoływana po trafieniu, z tym samym e co zdarzenie hit: e.projectile, e.shooter oraz e.entity lub e.block.
• texture: pocisk leci, wyglądając jak jego przedmiot, więc domyślnie używa textures/item/<id>.png; ustaw texture, by użyć innej.

Używaj go jak każdego innego pocisku: world.shoot("mymod:frost_bolt", from, velocity, shooter) albo, w stworzeniu, { ranged_attack: "mymod:frost_bolt" }. W Kotlinie:

content.projectile("frost_bolt") {
    damage = 4.0
    gravity = false
    onHit = { e -> /* … */ }
}

Ataki dystansowe i pociski

Zachowanie ranged_attack sprawia, że stworzenie strzela. Zbliża się, aż cel jest w zasięgu i w polu widzenia, po czym strzela.

creature "frost_spirit" {
    body: "minecraft:snow_golem"
    behaviour: [{ ranged_attack: "minecraft:snowball", interval: 20, range: 14, damage: 3 }, { wander: 0.6 }]
    targets: ["minecraft:zombie", "hurt_by"]
}

on hit(e) {
    if e.shooter?.type == "frostmod:frost_spirit" && e.entity != null {
        e.entity.velocity = vector(0, 0.2, 0)      // knocked up
    }
}

Ustawienie	Znaczenie
ranged_attack	ranged_attack: pocisk (minecraft:arrow, minecraft:snowball, minecraft:small_fireball, minecraft:wind_charge…).
interval	interval: ticki między strzałami.
range	range: odległość w blokach, z której strzela.
speed	speed: prędkość chodzenia podczas zbliżania się.
power	power: jak szybko leci pocisk.
damage	damage: dodatkowe obrażenia przy trafieniu.

Aby strzelać z kodu, stworzeniami lub umiejętnością gracza, użyj world().shoot(projectile, from, velocity, shooter, damage).

W Kotlinie:

creature("frost_spirit") {
    body = "minecraft:snow_golem"
    behaviour(Behaviour.RangedAttack(Identifier.parse("minecraft:snowball"), interval = 20, range = 14.0, damage = 3.0))
    target(TargetRule.Nearest(Identifier.parse("minecraft:zombie")))
}

// From code, e.g. a player's ability:
world.shoot(Identifier.parse("minecraft:small_fireball"), from, Vector(0.0, 0.0, 1.5), shooter = player, damage = 4.0)

Zdarzenie hit (ProjectileHitEvent) zachodzi, gdy pocisk w coś trafi. Ma e.projectile, e.shooter oraz e.entity albo e.block, zależnie od tego, w co trafił. Anuluj je, a pocisk przeleci na wylot. Zobacz Zdarzenia.

Warto wiedzieć

• Każde ciało ma swoje ograniczenia. Niektóre stworzenia z gry nie mają jakiejś statystyki: krowa nie ma obrażeń ataku. Jeśli ją ustawisz, zostanie pominięta, a Crafting ostrzeże w dzienniku.
• Ciała, które nie chodzą. Ciała, które nie potrafią same znaleźć ścieżki, pomijają zachowania związane z chodzeniem (wędrowanie, pościg, panika, podążanie, unikanie); reszta działa.
• Bez behaviour stworzenie zachowuje się jak ciało, którego używa. Gdy tylko napiszesz listę, robi tylko to, co na niej jest.
• Model zmienia tylko wygląd. Ruch i zachowanie zawsze pochodzą z ciała, a rozmiar również, chyba że ustawisz size.
• Własne stworzenie to żywy byt jak każdy inny: otrzymuje zdarzenia spawn, damage i entity_death, ma data, a obsługujesz je tym, co opisano na stronie Świat i gracze.

W Kotlinie

package com.example.rubies.content

object Creatures {
    fun register(content: ContentBuilder) {
        content.creature("ruby_golem") {
            body = "minecraft:zombie"
            texture = "entity/ruby_golem"
            health = 60.0
            speed = 0.25
            attackDamage = 6.0
            behaviour(Behaviour.Swim)
            behaviour(Behaviour.MeleeAttack())
            behaviour(Behaviour.Wander(0.6))
            behaviour(Behaviour.LookAtPlayers(12f))
            behaviour(Behaviour.LookAround)
            target(TargetRule.HurtBy)
            target(TargetRule.Nearest(Identifier.parse("minecraft:player")))
            drop(Items.RUBY, 2..4)
        }
    }
}

Zachowania: Behaviour.Swim, LookAround, Wander(speed), LookAtPlayers(range), MeleeAttack(speed), Panic(speed), Avoid(entity, distance, speed), Follow(item, speed). Cele: TargetRule.HurtBy i TargetRule.Nearest(id). Łup dodajesz przez drop(item, count, chance), tak jak w blokach.

Własny model 3D

Dodaj model, a stworzenie będzie rysowane twoim modelem zamiast modelem ciała. Ciało nadal daje mu rozmiar, ruch i zachowanie; model zmienia tylko to, jak wygląda.

creature "robot" {
    body: "minecraft:pig"
    model: "entity/robot"
    texture: "entity/robot"
    behaviour: ["swim", { wander: 0.8 }, { look_at_players: 10 }]
}

Model to models/entity/robot.json moda, a jego tekstura to textures/entity/robot.png. W Kotlinie: creature("robot") { body = "minecraft:pig"; model = "entity/robot"; texture = "entity/robot" }. Format jest taki sam we wszystkich wersjach gry.

{ "texture_size": [64, 64],
  "bones": [
    { "name": "body", "pivot": [0, 6, 0], "cubes": [ { "origin": [-5, 6, -3], "size": [10, 10, 6], "uv": [0, 0] } ] },
    { "name": "head", "parent": "body", "pivot": [0, 16, 0], "cubes": [ { "origin": [-4, 16, -4], "size": [8, 8, 8], "uv": [0, 16] } ] },
    { "name": "left_leg", "pivot": [2.5, 6, 0], "cubes": [ { "origin": [1, 0, -1.5], "size": [3, 6, 3], "uv": [32, 0] } ] },
    { "name": "right_leg", "pivot": [-2.5, 6, 0], "cubes": [ { "origin": [-4, 0, -1.5], "size": [3, 6, 3], "uv": [32, 16] } ] }
  ],
  "animations": { "head": "look", "left_leg": "walk", "right_leg": "walk_opposite", "body": "idle" } }

Rozmiary są w pikselach (16 to jeden blok), a y rośnie w górę od stóp stworzenia.

• Kość: name, opcjonalne parent (porusza się razem z nim), pivot (punkt, wokół którego się obraca) i cubes.
• Sześcian: origin (jego najniższy róg), size i uv (gdzie na obrazku zaczyna się jego tekstura). Układ jest zwykły dla pudełka: sześcian o szerokości w, wysokości h i głębokości d zajmuje obszar 2(w+d) na (d+h) pikseli.
• Animacje przypisuje się kościom, jako nazwę lub listę nazw:

Animacja	Co robi
look	Obraca w stronę, w którą patrzy stworzenie; dla głów.
walk, walk_opposite	Wymachuje podczas chodzenia; druga w przeciwnej fazie, dla drugiej kończyny.
idle	Lekkie kołysanie.
spin	Obraca się bez przerwy.

Jeśli modelu nie da się narysować, stworzenie wygląda jak jego ciało, a dziennik podaje powód.

Rozmiar

Stworzenie ma rozmiar swojego ciała. Gdy twój model jest mniejszy lub większy, ustaw size: [szerokość, wysokość] w blokach, aby to, z czym koliduje, i miejsce, w które się je klika, zgadzały się z tym, co widzą gracze:

creature "drake" {
    body: "minecraft:bee"
    model: "entity/drake"
    texture: "entity/drake"
    size: [1.4, 1.1]
}

W Kotlinie: size = 1.4 to 1.1.

Animacje klatek kluczowych

Dla ruchów wykraczających poza gotowe animacje dodaj sekcję clips obok bones i animations:

{ "bones": [ … ],
  "animations": { … },
  "clips": {
    "idle": { "length": 2.0, "bones": { "head": { "position": { "0": [0, 0, 0], "1": [0, 0.6, 0], "2": [0, 0, 0] } } } },
    "walk": { "length": 1.0, "bones": { "body": { "rotation": { "0": [0, 0, -6], "0.5": [0, 0, 6], "1": [0, 0, -6] } } } },
    "roar": { "length": 1.5, "bones": {
      "head": { "rotation": { "0": [0, 0, 0], "0.4": [-35, 0, 0], "1.1": [-35, 0, 0], "1.5": [0, 0, 0] },
                "scale": { "0": 1, "0.4": 1.35, "1.1": 1.35, "1.5": 1 } },
      "body": { "position": { "0": [0, 0, 0], "0.3": [0, 4, 0], "0.6": [0, 0, 0] } } } }
  } }

• Każdy klip ma length (długość) w sekundach i, dla każdej kości, do trzech kanałów: rotation w stopniach, position w pikselach (y w górę) i scale (liczba lub [x, y, z]).
• Klucze to czasy w sekundach. Wartości płynnie przechodzą po prostej między kluczami; dodaj do klipu "interpolation": "smooth", a będzie przechodził przez swoje klucze po krzywej. Kanał może też być jedną wartością na cały klip.

Klip	Kiedy się odtwarza
walk	Zapętla się, gdy idzie, w rytmie nóg.
idle	Zapętla się, gdy stoi w miejscu.
attack	Odtwarza się, gdy uderza.
Każda inna nazwa	Odtwarza się, gdy kod o to poprosi: c.play_animation("roar"). Widzą to pobliscy gracze z Crafting.

"idle": { "length": 1.2, "interpolation": "smooth", "bones": {
  "left_wing": { "rotation": { "0": [0, 0, -20], "0.6": [0, 0, 25], "1.2": [0, 0, -20] } } } }

Klip uruchomiony z kodu odtwarza się nad walk, idle i attack zamiast je zastępować, a one się sumują: stworzenie może ryczeć w czasie marszu.

Młode stworzenia z własnym modelem są rysowane w połowie rozmiaru.

Tekstury

Bez modelu tekstura ma taki sam układ jak tekstura wybranego ciała (zombie, wilka…), więc możesz zacząć od szablonu dla tego ciała i malować po nim. Trafia do moda, tak jak tekstury przedmiotów i bloków:

Mod	Gdzie
CraftScript (folder)	mods/ghostmod/textures/entity/ghost.png
Kotlin lub Java	src/main/resources/assets/ghostmod/textures/entity/ghost.png