From e63d99bc1f6dedb09f36b70cd0c4cdb579e87cdb Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 26 Jun 2025 00:32:39 -0400 Subject: [PATCH 01/21] Initial Commit --- .../ch/njol/skript/entity/EntityData.java | 8 +- src/main/resources/lang/default.lang | 556 +++++++++--------- 2 files changed, 280 insertions(+), 284 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 414bf1d4461..38c1316511e 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -287,12 +287,8 @@ public EntityData() { @Override public final boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { this.matchedPattern = matchedPattern; - // plural bits (0x3): 0 = singular, 1 = plural, 2 = unknown - int pluralBits = parseResult.mark & 0x3; - this.plural = pluralBits == 1 ? Kleenean.TRUE : pluralBits == 0 ? Kleenean.FALSE : Kleenean.UNKNOWN; - // age bits (0xC): 0 = unknown, 4 = baby, 8 = adult - int ageBits = parseResult.mark & 0xC; - this.baby = ageBits == 4 ? Kleenean.TRUE : ageBits == 8 ? Kleenean.FALSE : Kleenean.UNKNOWN; + this.plural = parseResult.hasTag("unknownplural") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("plural")); + this.baby = parseResult.hasTag("unknownage") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("baby")); return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedPattern, parseResult); } diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index 31c345f297f..3c7ba5bb5cc 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -471,864 +471,864 @@ directions: # the marks (1¦..) are only required in the english file, i.e. you can use (..|..) or [..] for plurals in other languages # the exception to this rule is the 'f' and the corresponding marks (4¦ and 8¦) entities: - age pattern: (|4¦baby|4¦young|8¦adult|8¦grown(-| )up) + age pattern: (unknownage:|baby:(baby|young)|adult:(adult|grown(-| )up)) age adjectives: baby: baby adult: adult entity: name: entit¦y¦ies @an - pattern: entit(y|1¦ies) + pattern: entit(y|plural:ies) living entity: name: living entit¦y¦ies - pattern: living entit(y|1¦ies) + pattern: living entit(y|plural:ies) projectile: name: projectile¦s - pattern: projectile(|1¦s) + pattern: projectile[plural:s] creature: name: creature¦s - pattern: creature(|1¦s) + pattern: creature[plural:s] human: name: human¦s - pattern: human(|1¦s) + pattern: human[plural:s] tipped arrow: name: tipped arrow¦s - pattern: tipped arrow(|1¦s) + pattern: tipped arrow[plural:s] arrow: name: arrow¦s @an - pattern: arrow(|1¦s) + pattern: arrow[plural:s] spectral arrow: name: spectral arrow - pattern: spectral[ ]arrow(|1¦s) + pattern: spectral[ ]arrow[plural:s] bat: name: bat¦s - pattern: bat(|1¦s) + pattern: bat[plural:s] # boats! boat: name: boat¦s - pattern: boat[1:s] + pattern: boat[plural:s] any boat: name: boat¦s - pattern: any boat[1:s] + pattern: any boat[plural:s] oak boat: name: oak boat¦s - pattern: oak boat[1:s] + pattern: oak boat[plural:s] spruce boat: name: spruce boat¦s - pattern: spruce boat[1:s] + pattern: spruce boat[plural:s] birch boat: name: birch boat¦s - pattern: birch boat[1:s] + pattern: birch boat[plural:s] jungle boat: name: jungle boat¦s - pattern: jungle boat[1:s] + pattern: jungle boat[plural:s] acacia boat: name: acacia boat¦s - pattern: acacia boat[1:s] + pattern: acacia boat[plural:s] dark oak boat: name: dark oak boat¦s - pattern: dark oak boat[1:s] + pattern: dark oak boat[plural:s] mangrove boat: name: mangrove boat¦s - pattern: mangrove boat[1:s] + pattern: mangrove boat[plural:s] bamboo raft: name: bamboo raft¦s - pattern: bamboo (boat|raft)[1:s] + pattern: bamboo (boat|raft)[plural:s] cherry boat: name: cherry boat¦s - pattern: cherry [blossom] boat[1:s] + pattern: cherry [blossom] boat[plural:s] pale oak boat: name: pale oak boat¦s - pattern: pale oak boat[1:s] + pattern: pale oak boat[plural:s] blaze: name: blaze¦s - pattern: blaze(|1¦s) + pattern: blaze[plural:s] chicken: name: chicken¦s - pattern: chicken(|1¦s)|(4¦)chick(|1¦s) + pattern: chicken[plural:s]|(baby:)chick[plural:s] cow: name: cow¦s - pattern: cow(|1¦s)|(4¦)cal(f|1¦ves) + pattern: cow[plural:s]|(baby:)cal(f|plural:ves) cave spider: name: cave spider¦s - pattern: cave[ ]spider(|1¦s) + pattern: cave[ ]spider[plural:s] creeper: name: creeper¦s - pattern: creeper(|1¦s) + pattern: creeper[plural:s] unpowered creeper: name: unpowered creeper¦s @an - pattern: un(powered|charged) creeper(|1¦s) + pattern: un(powered|charged) creeper[plural:s] powered creeper: name: powered creeper¦s - pattern: (powered|charged) creeper(|1¦s) + pattern: (powered|charged) creeper[plural:s] egg: name: egg¦s @an - pattern: egg(|1¦s) + pattern: egg[plural:s] enderman: name: ender¦man¦men @an - pattern: enderm(a|1¦e)n [(carrying|holding) %-itemtype%] + pattern: enderm(a|plural:e)n [(carrying|holding) %-itemtype%] format: %1$s holding %2$s ender crystal: name: ender crystal¦s @an - pattern: end[er][ ]crystal(|1¦s) + pattern: end[er][ ]crystal[plural:s] ender dragon: name: ender dragon¦s @an - pattern: ender[ ]dragon(|1¦s) + pattern: ender[ ]dragon[plural:s] ender pearl: name: ender pearl¦s @an - pattern: ender[ ]pearl(|1¦s) + pattern: ender[ ]pearl[plural:s] ender eye: name: ender eye¦s @an - pattern: ender eye(|1¦s)|eye(|1¦s) of ender + pattern: ender eye[plural:s]|eye[plural:s] of ender fireball: name: fireball¦s - pattern: [(ghast|big)] fire[ ]ball(|1¦s) + pattern: [(ghast|big)] fire[ ]ball[plural:s] dragon fireball: name: dragon fireball¦s - pattern: dragon fire[ ]ball(|1¦s) + pattern: dragon fire[ ]ball[plural:s] small fireball: name: small fireball¦s - pattern: (small|blaze) fire[ ]ball(|1¦s) + pattern: (small|blaze) fire[ ]ball[plural:s] large fireball: name: large fireball¦s - pattern: large fire[ ]ball(|1¦s) + pattern: large fire[ ]ball[plural:s] any fireball: name: any fireball¦s - pattern: any fire[ ]ball(|1¦s) + pattern: any fire[ ]ball[plural:s] fish: name: fish¦es - pattern: fish(|1¦es) + pattern: fish[plural:es] tropical fish: name: tropical fish¦es - pattern: [(%-color%[-%-color%]|fully %-color%)] tropical fish(|1¦es) + pattern: [(%-color%[-%-color%]|fully %-color%)] tropical fish[plural:es] kob: name: kob¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] kob(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] kob[plural:s] sunstreak: name: sunstreak¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] sunstreak(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] sunstreak[plural:s] snooper: name: snooper¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] snooper(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] snooper[plural:s] dasher: name: dasher¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] dasher(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] dasher[plural:s] brinely: name: brinely¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] brinely(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] brinely[plural:s] spotty: name: spotty¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] spotty(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] spotty[plural:s] flopper: name: flopper¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] flopper(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] flopper[plural:s] stripey: name: stripey¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] stripey(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] stripey[plural:s] glitter: name: glitter¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] glitter(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] glitter[plural:s] blockfish: name: blockfish¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] blockfish(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] blockfish[plural:s] betty: name: betty¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] betty(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] betty[plural:s] clayfish: name: clayfish¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] clayfish(|1¦s) + pattern: [(%-color%[-%-color%]|fully %-color%)] clayfish[plural:s] ghast: name: ghast¦s - pattern: ghast(|1¦s) + pattern: ghast[plural:s] giant: name: giant¦s - pattern: giant(|1¦s) + pattern: giant[plural:s] iron golem: name: iron golem¦s @an - pattern: iron golem(|1¦s) + pattern: iron golem[plural:s] lightning bolt: name: lightning bolt¦s - pattern: lightning bolt(|1¦s) + pattern: lightning bolt[plural:s] item frame: name: item frame¦s @an - pattern: item[ ]frame(|1¦s) + pattern: item[ ]frame[plural:s] magma cube: name: magma cube¦s - pattern: magma (cube|slime)(|1¦s) + pattern: magma (cube|slime)[plural:s] minecart: name: minecart¦s - pattern: [mine]cart(|1¦s) + pattern: [mine]cart[plural:s] regular minecart: name: regular minecart¦s - pattern: regular [mine]cart(|1¦s) + pattern: regular [mine]cart[plural:s] storage minecart: name: storage minecart¦s - pattern: storage [mine]cart(|1¦s)|[mine]cart(|1¦s) with chest[s] + pattern: storage [mine]cart[plural:s]|[mine]cart[plural:s] with chest[s] powered minecart: name: powered minecart¦s - pattern: powered [mine]cart(|1¦s)|[mine]cart(|1¦s) with furnace[s] + pattern: powered [mine]cart[plural:s]|[mine]cart[plural:s] with furnace[s] hopper minecart: name: hopper minecart¦s - pattern: hopper [mine]cart(|1¦s)|[mine]cart(|1¦s) with hopper[s] + pattern: hopper [mine]cart[plural:s]|[mine]cart[plural:s] with hopper[s] explosive minecart: name: explosive minecart¦s - pattern: explosive [mine]cart(|1¦s)|[mine]cart(|1¦s) with TNT[s] + pattern: explosive [mine]cart[plural:s]|[mine]cart[plural:s] with TNT[s] spawner minecart: name: spawner minecart¦s - pattern: (monster|mob|) spawner [mine]cart(|1¦s)|[mine]cart(|1¦s) with (monster|mob|) spawner[s] + pattern: (monster|mob|) spawner [mine]cart[plural:s]|[mine]cart[plural:s] with (monster|mob|) spawner[s] command minecart: name: command minecart¦s - pattern: command [mine]cart(|1¦s)|[mine]cart(|1¦s) with command block[s] + pattern: command [mine]cart[plural:s]|[mine]cart[plural:s] with command block[s] mooshroom: name: mooshroom¦s - pattern: (mooshroom[ cow]|mushroom cow)(|1¦s) + pattern: (mooshroom[ cow]|mushroom cow)[plural:s] red mooshroom: name: red mooshroom¦s - pattern: red (mooshroom[ cow]|mushroom cow)(|1¦s)|(4¦)mooshroom (kid(|1¦s)|child(|1¦ren)) + pattern: red (mooshroom[ cow]|mushroom cow)[plural:s]|(baby:)mooshroom (kid[plural:s]|child[plural:ren]) brown mooshroom: name: brown mooshroom¦s - pattern: brown (mooshroom[ cow]|mushroom cow)(|1¦s)|(4¦)mooshroom (kid(|1¦s)|child(|1¦ren)) + pattern: brown (mooshroom[ cow]|mushroom cow)[plural:s]|(baby:)mooshroom (kid[plural:s]|child[plural:ren]) ocelot: name: ocelot¦s @an - pattern: ocelot(|1¦s) + pattern: ocelot[plural:s] wild ocelot: name: wild ocelot¦s - pattern: (wild|untamed) ocelot(|1¦s) + pattern: (wild|untamed) ocelot[plural:s] cat: name: cat¦s - pattern: [%-cattype%] cat(|1¦s)|tamed ocelot(|1¦s)|(4¦)[%-cattype%] kitten(|1¦s) + pattern: [%-cattype%] cat[plural:s]|tamed ocelot[plural:s]|(baby:)[%-cattype%] kitten[plural:s] painting: name: painting¦s - pattern: painting(|1¦s) + pattern: painting[plural:s] pig: name: pig¦s - pattern: [%-pigvariant%] pig(|1¦s)|(4¦)piglet(|1¦s) + pattern: [%-pigvariant%] pig[plural:s]|(baby:)piglet[plural:s] saddled pig: name: saddled pig¦s - pattern: saddled [%-pigvariant%] pig(|1¦s) + pattern: saddled [%-pigvariant%] pig[plural:s] unsaddled pig: name: unsaddled pig¦s @an - pattern: unsaddled [%-pigvariant%] pig(|1¦s) + pattern: unsaddled [%-pigvariant%] pig[plural:s] player: name: player¦s - pattern: player(|1¦s) + pattern: player[plural:s] zombie pigman: name: zombie pig¦man¦men|zombified piglin - pattern: (zombie pigm(an|1¦en)|zombified piglin(|1¦s))|(4¦)(zombie pigletboy(|1¦s)|zombified piglin (kid(|1¦s)|child(|1¦ren))) + pattern: (zombie pigm(an|plural:en)|zombified piglin[plural:s])|(baby:)(zombie pigletboy[plural:s]|zombified piglin (kid[plural:s]|child[plural:ren])) sheep: name: sheep # while sheep is ambiguous, sheeps is plural (even though it's wrong) - pattern: [%-colors%] sheep(2¦|1¦s)|(4¦)[%-colors%] lamb(|1¦s) + pattern: [%-colors%] sheep(unknownplural:|plural:s)|(baby:)[%-colors%] lamb[plural:s] unsheared sheep: name: unsheared sheep @an - pattern: unsheared [%-colors%] sheep(2¦|1¦s) + pattern: unsheared [%-colors%] sheep(unknownplural:|plural:s) sheared sheep: name: sheared sheep - pattern: sheared [%-colors%] sheep(2¦|1¦s) + pattern: sheared [%-colors%] sheep(unknownplural:|plural:s) silverfish: name: silverfish¦es - pattern: silverfish(|1¦es) + pattern: silverfish[plural:es] skeleton: name: skeleton¦s - pattern: skeleton(|1¦s) + pattern: skeleton[plural:s] slime: name: slime¦s - pattern: slime(|1¦s) + pattern: slime[plural:s] snowball: name: snowball¦s - pattern: snowball(|1¦s) + pattern: snowball[plural:s] snow golem: name: snow golem¦s - pattern: snow[ ](golem(|1¦s)|m(an|1¦en)) + pattern: snow[ ](golem[plural:s]|m(an|plural:en)) spider: name: spider¦s - pattern: spider(|1¦s) + pattern: spider[plural:s] squid: name: squid¦s - pattern: squid(|1¦s) + pattern: squid[plural:s] bottle of enchanting: name: bottle¦ of enchanting¦s of enchanting - pattern: [thrown] bottle(|1¦s) o(f|') enchanting|[e]xp[erience] bottle(|1¦s) + pattern: [thrown] bottle[plural:s] o(f|') enchanting|[e]xp[erience] bottle[plural:s] tnt: name: TNT - pattern: ([primed] TNT(2¦|1¦s)|TNT entit(y|1¦ies)) + pattern: ([primed] TNT(unknownplural:|plural:s)|TNT entit(y|plural:ies)) villager: name: villager¦s - pattern: villager(|1¦s)|(4¦)[villager] (kid(|1¦s)|child(|1¦ren)) + pattern: villager[plural:s]|(baby:)[villager] (kid[plural:s]|child[plural:ren]) normal: name: villager¦s - pattern: [unemployed] villager(|1¦s)|(4¦)[[unemployed] villager] (kid(|1¦s)|child(|1¦ren)) + pattern: [unemployed] villager[plural:s]|(baby:)[[unemployed] villager] (kid[plural:s]|child[plural:ren]) armorer: name: armorer¦s - pattern: armo[u]rer(|1¦s)|(4¦)armo[u]rer (kid(|1¦s)|child(|1¦ren)) + pattern: armo[u]rer[plural:s]|(baby:)armo[u]rer (kid[plural:s]|child[plural:ren]) cartographer: name: cartographer¦s - pattern: cartographer(|1¦s)|(4¦)cartographer (kid(|1¦s)|child(|1¦ren)) + pattern: cartographer[plural:s]|(baby:)cartographer (kid[plural:s]|child[plural:ren]) cleric: name: cleric¦s - pattern: (priest|cleric)(|1¦s)|(4¦)(priest|cleric) (kid(|1¦s)|child(|1¦ren)) + pattern: (priest|cleric)[plural:s]|(baby:)(priest|cleric) (kid[plural:s]|child[plural:ren]) fisherman: name: fisherman¦s - pattern: fisherman(|1¦s)|(4¦)fisherman (kid(|1¦s)|child(|1¦ren)) + pattern: fisherman[plural:s]|(baby:)fisherman (kid[plural:s]|child[plural:ren]) fletcher: name: fletcher¦s - pattern: fletcher(|1¦s)|(4¦)fletcher (kid(|1¦s)|child(|1¦ren)) + pattern: fletcher[plural:s]|(baby:)fletcher (kid[plural:s]|child[plural:ren]) leatherworker: name: leatherworker¦s - pattern: leatherworker(|1¦s)|(4¦)leatherworker (kid(|1¦s)|child(|1¦ren)) + pattern: leatherworker[plural:s]|(baby:)leatherworker (kid[plural:s]|child[plural:ren]) mason: name: mason¦s - pattern: mason(|1¦s)|(4¦)mason (kid(|1¦s)|child(|1¦ren)) + pattern: mason[plural:s]|(baby:)mason (kid[plural:s]|child[plural:ren]) shepherd: name: shepherd¦s - pattern: shepherd(|1¦s)|(4¦)shepherd (kid(|1¦s)|child(|1¦ren)) + pattern: shepherd[plural:s]|(baby:)shepherd (kid[plural:s]|child[plural:ren]) toolsmith: name: toolsmith¦s - pattern: tool[ ](smith|maker)(|1¦s)|(4¦)tool[ ](smith|maker) (kid(|1¦s)|child(|1¦ren)) + pattern: tool[ ](smith|maker)[plural:s]|(baby:)tool[ ](smith|maker) (kid[plural:s]|child[plural:ren]) weaponsmith: name: weaponsmith¦s - pattern: weapon[ ]smith(|1¦s)|(4¦)weapon[ ]smith (kid(|1¦s)|child(|1¦ren)) + pattern: weapon[ ]smith[plural:s]|(baby:)weapon[ ]smith (kid[plural:s]|child[plural:ren]) farmer: name: farmer¦s - pattern: farmer(|1¦s)|(4¦)farmer (kid(|1¦s)|child(|1¦ren)) + pattern: farmer[plural:s]|(baby:)farmer (kid[plural:s]|child[plural:ren]) librarian: name: librarian¦s - pattern: librarian(|1¦s)|(4¦)librarian (kid(|1¦s)|child(|1¦ren)) + pattern: librarian[plural:s]|(baby:)librarian (kid[plural:s]|child[plural:ren]) priest: name: priest¦s - pattern: (priest|cleric)(|1¦s)|(4¦)(priest|cleric) (kid(|1¦s)|child(|1¦ren)) + pattern: (priest|cleric)[plural:s]|(baby:)(priest|cleric) (kid[plural:s]|child[plural:ren]) blacksmith: name: blacksmith¦s - pattern: [black]smith(|1¦s)|(4¦)[black]smith (kid(|1¦s)|child(|1¦ren)) + pattern: [black]smith[plural:s]|(baby:)[black]smith (kid[plural:s]|child[plural:ren]) butcher: name: butcher¦s - pattern: butcher(|1¦s)|(4¦)butcher (kid(|1¦s)|child(|1¦ren)) + pattern: butcher[plural:s]|(baby:)butcher (kid[plural:s]|child[plural:ren]) nitwit: name: nitwit¦s - pattern: nitwit(|1¦s)|(4¦)nitwit (kid(|1¦s)|child(|1¦ren)) + pattern: nitwit[plural:s]|(baby:)nitwit (kid[plural:s]|child[plural:ren]) witch: name: witch¦es - pattern: witch(|1¦es) + pattern: witch[plural:es] wither: name: wither¦s - pattern: wither(|1¦s) + pattern: wither[plural:s] wither skeleton: name: wither skeleton¦s - pattern: wither skeleton(|1¦s) + pattern: wither skeleton[plural:s] wither skull: name: wither skull¦s - pattern: wither skull((|1¦s)| projectile(|1¦s)) + pattern: wither skull([plural:s]| projectile[plural:s]) wolf: name: wol¦f¦ves - pattern: [%-wolfvariant%] wol(f|1¦ves) [[with collar] colo[u]r[ed] %-color%] + pattern: [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] tamed wolf: name: tamed wol¦f¦ves - pattern: ( [%-wolfvariant%] dog(|1¦s)|tamed [%-wolfvariant%] wol(f|1¦ves)| [%-wolfvariant%] (4¦)pupp(y|1¦ies)) [[with collar] colo[u]r[ed] %-color%] + pattern: ( [%-wolfvariant%] dog[plural:s]|tamed [%-wolfvariant%] wol(f|plural:ves)| [%-wolfvariant%] (baby:)pupp(y|plural:ies)) [[with collar] colo[u]r[ed] %-color%] wild wolf: name: wild wol¦f¦ves - pattern: (wild|untamed) [%-wolfvariant%] wol(f|1¦ves) [[with collar] colo[u]r[ed] %-color%] + pattern: (wild|untamed) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] angry wolf: name: angry wol¦f¦ves @an - pattern: (angry|aggressive) [%-wolfvariant%] wol(f|1¦ves) [[with collar] colo[u]r[ed] %-color%] + pattern: (angry|aggressive) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] peaceful wolf: name: peaceful wol¦f¦ves - pattern: (peaceful|neutral|unaggressive) [%-wolfvariant%] wol(f|1¦ves) [[with collar] colo[u]r[ed] %-color%] + pattern: (peaceful|neutral|unaggressive) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] zombie: name: zombie¦s - pattern: zombie(|1¦s)|(4¦)zombie (kid(|1¦s)|child(|1¦ren)) + pattern: zombie[plural:s]|(baby:)zombie (kid[plural:s]|child[plural:ren]) xp-orb: name: experience orb¦s @an - pattern: ([e]xp|experience)( |-)orb(|1¦s) + pattern: ([e]xp|experience)( |-)orb[plural:s] format: %2$s-%1$s firework: name: firework rocket¦s - pattern: firework(|1¦s) [rocket(|1¦s)] + pattern: firework[plural:s] [rocket[plural:s]] falling block: name: falling block¦s - pattern: falling (block(|1¦s)|(2¦)%-itemtype%) + pattern: falling (block[plural:s]|(unknownplural:)%-itemtype%) adjective: falling not a block error: Falling blocks must be blocks, not items thrown potion: name: thrown potion¦s - pattern: thrown (potion(|1¦s)|(2¦)%-itemtypes%) + pattern: thrown (potion[plural:s]|(unknownplural:)%-itemtypes%) adjective: thrown dropped item: name: dropped item¦s - pattern: dropped (item(|1¦s)|(2¦)%-itemtypes%)|item entit(y|1¦ies) + pattern: dropped (item[plural:s]|(unknownplural:)%-itemtypes%)|item entit(y|plural:ies) adjective: dropped horse: name: horse¦s - pattern: horse(|1¦s)|(4¦)foal(|1¦s) + pattern: horse[plural:s]|(baby:)foal[plural:s] donkey: name: donkey¦s - pattern: donkey(|1¦s) + pattern: donkey[plural:s] mule: name: mule¦s - pattern: mule(|1¦s) + pattern: mule[plural:s] chested horse: name: chested horse¦s - pattern: chested horse(|1¦s) + pattern: chested horse[plural:s] undead horse: name: undead horse¦s @an - pattern: (zombie|undead) horse(|1¦s)|(zombie|undead) horse(|1¦s)|(zombie|undead) (4¦)foal(|1¦s) + pattern: (zombie|undead) horse[plural:s]|(zombie|undead) horse[plural:s]|(zombie|undead) (baby:)foal[plural:s] skeleton horse: name: skeleton horse¦s - pattern: skeleton horse(|1¦s)|skeleton horse(|1¦s)|skeleton (4¦)foal(|1¦s) + pattern: skeleton horse[plural:s]|skeleton horse[plural:s]|skeleton (baby:)foal[plural:s] any horse: name: any horse¦s - pattern: any horse(|1¦s)|(4¦)foal(|1¦s) + pattern: any horse[plural:s]|(baby:)foal[plural:s] llama: name: llama¦s - pattern: llama(|1¦s)| llama (4¦)cria(|1¦s) + pattern: llama[plural:s]| llama (baby:)cria[plural:s] creamy llama: name: creamy llama¦s - pattern: creamy llama(|1¦s)| creamy llama (4¦)cria(|1¦s) + pattern: creamy llama[plural:s]| creamy llama (baby:)cria[plural:s] white llama: name: white llama¦s - pattern: white llama(|1¦s)| white llama (4¦)cria(|1¦s) + pattern: white llama[plural:s]| white llama (baby:)cria[plural:s] brown llama: name: brown llama¦s - pattern: brown llama(|1¦s)| brown llama (4¦)cria(|1¦s) + pattern: brown llama[plural:s]| brown llama (baby:)cria[plural:s] gray llama: name: gray llama¦s - pattern: gray llama(|1¦s)| gray llama (4¦)cria(|1¦s) + pattern: gray llama[plural:s]| gray llama (baby:)cria[plural:s] trader llama: name: trader llama¦s - pattern: trader llama(|1¦s)| trader llama (4¦)cria(|1¦s) + pattern: trader llama[plural:s]| trader llama (baby:)cria[plural:s] creamy trader llama: name: creamy trader llama¦s - pattern: creamy trader llama(|1¦s)| creamy trader llama (4¦)cria(|1¦s) + pattern: creamy trader llama[plural:s]| creamy trader llama (baby:)cria[plural:s] white trader llama: name: white trader llama¦s - pattern: white trader llama(|1¦s)| white trader llama (4¦)cria(|1¦s) + pattern: white trader llama[plural:s]| white trader llama (baby:)cria[plural:s] brown trader llama: name: brown trader llama¦s - pattern: brown trader llama(|1¦s)| brown trader llama (4¦)cria(|1¦s) + pattern: brown trader llama[plural:s]| brown trader llama (baby:)cria[plural:s] gray trader llama: name: gray trader llama¦s - pattern: gray trader llama(|1¦s)| gray trader llama (4¦)cria(|1¦s) + pattern: gray trader llama[plural:s]| gray trader llama (baby:)cria[plural:s] llama spit: name: llama spit¦s - pattern: llama spit(|1¦s) + pattern: llama spit[plural:s] elder guardian: name: elder guardian¦s - pattern: elder guardian(|1¦s) + pattern: elder guardian[plural:s] guardian: name: guardian¦s - pattern: guardian(|1¦s) + pattern: guardian[plural:s] normal guardian: name: normal guardian¦s - pattern: normal guardian(|1¦s) + pattern: normal guardian[plural:s] rabbit: name: rabbit¦s - pattern: rabbit(|1¦s)|rabbit (|1¦s) + pattern: rabbit[plural:s]|rabbit [plural:s] brown rabbit: name: brown rabbit¦s - pattern: brown rabbit(|1¦s)|brown rabbit (|1¦s) + pattern: brown rabbit[plural:s]|brown rabbit [plural:s] black and white rabbit: name: black and white rabbit¦s - pattern: black [and] white rabbit(|1¦s)|black [and] white rabbit (|1¦s) + pattern: black [and] white rabbit[plural:s]|black [and] white rabbit [plural:s] white rabbit: name: white rabbit¦s - pattern: white rabbit(|1¦s)|white rabbit (|1¦s) + pattern: white rabbit[plural:s]|white rabbit [plural:s] black rabbit: name: black rabbit¦s - pattern: black rabbit(|1¦s)|black rabbit (|1¦s) + pattern: black rabbit[plural:s]|black rabbit [plural:s] gold rabbit: name: gold rabbit¦s - pattern: gold rabbit(|1¦s)|gold rabbit (|1¦s) + pattern: gold rabbit[plural:s]|gold rabbit [plural:s] salt and pepper rabbit: name: salt and pepper rabbit¦s - pattern: salt [and] pepper rabbit(|1¦s)|salt [and] pepper rabbit (|1¦s) + pattern: salt [and] pepper rabbit[plural:s]|salt [and] pepper rabbit [plural:s] killer rabbit: name: killer rabbit¦s - pattern: killer rabbit(|1¦s)|killer rabbit (|1¦s) + pattern: killer rabbit[plural:s]|killer rabbit [plural:s] fish hook: name: fish hook¦s - pattern: fish[ ]hook(|1¦s) + pattern: fish[ ]hook[plural:s] armor stand: name: armor stand¦s - pattern: armo[u]r stand(|1¦s) + pattern: armo[u]r stand[plural:s] endermite: name: endermite¦s - pattern: endermite(|1¦s) + pattern: endermite[plural:s] stray: name: stray¦s - pattern: stray(|1¦s) + pattern: stray[plural:s] golem: name: golem¦s - pattern: golem(|1¦s) + pattern: golem[plural:s] shulker: name: shulker¦s - pattern: shulker(|1¦s) + pattern: shulker[plural:s] shulker bullet: name: shulker bullet¦s - pattern: shulker bullet(|1¦s) + pattern: shulker bullet[plural:s] polar bear: name: polar bear¦s - pattern: polar bear(|1¦s) + pattern: polar bear[plural:s] area effect cloud: name: area effect cloud¦s - pattern: area effect cloud(|1¦s) + pattern: area effect cloud[plural:s] husk: name: husk¦s - pattern: husk(|1¦s) + pattern: husk[plural:s] zombie villager: name: zombie villager¦s - pattern: zombie villager(|1¦s) + pattern: zombie villager[plural:s] zombie normal: name: zombie villager¦s - pattern: unemployed zombie villager(|1¦s) + pattern: unemployed zombie villager[plural:s] zombie farmer: name: zombie farmer¦s - pattern: zombie farmer(|1¦s) + pattern: zombie farmer[plural:s] zombie librarian: name: zombie librarian¦s - pattern: zombie librarian(|1¦s) + pattern: zombie librarian[plural:s] zombie priest: name: zombie priest¦s - pattern: zombie priest(|1¦s) + pattern: zombie priest[plural:s] zombie blacksmith: name: zombie blacksmith¦s - pattern: zombie blacksmith(|1¦s) + pattern: zombie blacksmith[plural:s] zombie butcher: name: zombie butcher¦s - pattern: zombie butcher(|1¦s) + pattern: zombie butcher[plural:s] zombie nitwit: name: zombie nitwit¦s - pattern: zombie nitwit(|1¦s) + pattern: zombie nitwit[plural:s] zombie armorer: name: zombie armorer¦s - pattern: zombie armo[u]rer(|1¦s) + pattern: zombie armo[u]rer[plural:s] zombie cartographer: name: zombie cartographer¦s - pattern: zombie cartographer(|1¦s) + pattern: zombie cartographer[plural:s] zombie cleric: name: zombie cleric¦s - pattern: zombie cleric(|1¦s) + pattern: zombie cleric[plural:s] zombie fisherman: name: zombie fisher¦man¦men - pattern: zombie fisherm(an|1¦en) + pattern: zombie fisherm(an|plural:en) zombie fletcher: name: zombie fletcher¦s - pattern: zombie fletcher(|1¦s) + pattern: zombie fletcher[plural:s] zombie leatherworker: name: zombie leatherworker¦s - pattern: zombie leatherworker(|1¦s) + pattern: zombie leatherworker[plural:s] zombie mason: name: zombie mason¦s - pattern: zombie mason(|1¦s) + pattern: zombie mason[plural:s] zombie shepherd: name: zombie shepherd¦s - pattern: zombie shepherd(|1¦s) + pattern: zombie shepherd[plural:s] zombie toolsmith: name: zombie toolsmith¦s - pattern: zombie toolsmith(|1¦s) + pattern: zombie toolsmith[plural:s] zombie weaponsmith: name: zombie weaponsmith¦s - pattern: zombie weaponsmith(|1¦s) + pattern: zombie weaponsmith[plural:s] evoker: name: evoker¦s - pattern: evoker(|1¦s) + pattern: evoker[plural:s] evoker fangs: name: evoker fangs pattern: evoker fangs illusioner: name: illusioner¦s - pattern: illusioner(|1¦s) + pattern: illusioner[plural:s] vex: name: vex¦es - pattern: vex(|1¦es) + pattern: vex[plural:es] vindicator: name: vindicator¦s - pattern: vindicator(|1¦s) + pattern: vindicator[plural:s] illager: name: illager¦s - pattern: illager(|1¦s) + pattern: illager[plural:s] spellcaster: name: spellcaster¦s - pattern: spellcaster(|1¦s) + pattern: spellcaster[plural:s] parrot: name: parrot¦s - pattern: parrot(|1¦s) + pattern: parrot[plural:s] red parrot: name: red parrot¦s - pattern: red parrot(|1¦s) + pattern: red parrot[plural:s] blue parrot: name: blue parrot¦s - pattern: blue parrot(|1¦s) + pattern: blue parrot[plural:s] green parrot: name: green parrot¦s - pattern: green parrot(|1¦s) + pattern: green parrot[plural:s] cyan parrot: name: cyan parrot¦s - pattern: cyan parrot(|1¦s) + pattern: cyan parrot[plural:s] gray parrot: name: gray parrot¦s - pattern: gray parrot(|1¦s) + pattern: gray parrot[plural:s] monster: name: monster¦s - pattern: monster(|1¦s) + pattern: monster[plural:s] mob: name: mob¦s - pattern: mob(|1¦s) + pattern: mob[plural:s] animal: name: animal¦s - pattern: animal(|1¦s) + pattern: animal[plural:s] damageable: name: damageable mob¦s - pattern: damageable mob(|1¦s) + pattern: damageable mob[plural:s] water mob: name: water mob¦s - pattern: water mob(|1¦s) + pattern: water mob[plural:s] cod: name: cod¦s - pattern: cod(|1¦s) + pattern: cod[plural:s] salmon: name: salmon¦s - pattern: salmon(|1¦s) + pattern: salmon[plural:s] puffer fish: name: puffer fish¦es - pattern: puffer[ ]fish(|1¦es) + pattern: puffer[ ]fish[plural:es] tropical fish: name: tropical fish¦es - pattern: tropical fish(|1¦es) + pattern: tropical fish[plural:es] drowned: name: drowned¦s - pattern: drowned(|1¦s)|(4¦)drowned (kid(|1¦s)|child(|1¦ren)) + pattern: drowned[plural:s]|(baby:)drowned (kid[plural:s]|child[plural:ren]) dolphin: name: dolphin¦s - pattern: dolphin(|1¦s) + pattern: dolphin[plural:s] phantom: name: phantom¦s - pattern: phantom(|1¦s) + pattern: phantom[plural:s] turtle: name: turtle¦s - pattern: turtle(|1¦s)|(4¦)turtle (kid(|1¦s)|child(|1¦ren)) + pattern: turtle[plural:s]|(baby:)turtle (kid[plural:s]|child[plural:ren]) trident: name: trident¦s - pattern: trident(|1¦s) + pattern: trident[plural:s] leash hitch: name: leash hitch¦es - pattern: leash hitch(|1¦es) + pattern: leash hitch[plural:es] #1.14 entities fox: name: fox¦es - pattern: fox(|1¦es)|(4¦)fox (kid(|1¦s)|child(|1¦ren)) + pattern: fox[plural:es]|(baby:)fox (kid[plural:s]|child[plural:ren]) red fox: name: red fox¦es - pattern: red fox(|1¦es)|(4¦)fox (kid(|1¦s)|child(|1¦ren)) + pattern: red fox[plural:es]|(baby:)fox (kid[plural:s]|child[plural:ren]) snow fox: name: snow fox¦es - pattern: snow fox(|1¦es)|(4¦)fox (kid(|1¦s)|child(|1¦ren)) + pattern: snow fox[plural:es]|(baby:)fox (kid[plural:s]|child[plural:ren]) pillager: name: pillager¦s - pattern: pillager(|1¦s) + pattern: pillager[plural:s] ravager: name: ravager¦s - pattern: ravager(|1¦s) + pattern: ravager[plural:s] wandering trader: name: wandering trader¦s - pattern: wandering trader(|1¦s)|(4¦)wandering trader (kid(|1¦s)|child(|1¦ren)) //supposed to be ageable, but not working, spigot bug? + pattern: wandering trader[plural:s]|(baby:)wandering trader (kid[plural:s]|child[plural:ren]) //supposed to be ageable, but not working, spigot bug? raider: name: raider¦s - pattern: raider(|1¦s) + pattern: raider[plural:s] panda: name: panda¦s - pattern: [%-gene%[%-gene%]] panda(|1¦s) + pattern: [%-gene%[%-gene%]] panda[plural:s] #1.15 entity no nectar bee: name: no nectar bee¦s - pattern: bee(|1¦s) without nectar + pattern: bee[plural:s] without nectar happy bee: name: happy bee¦s - pattern: happy bee(|1¦s) + pattern: happy bee[plural:s] bee: name: bee¦s - pattern: bee(|1¦s) + pattern: bee[plural:s] nectar bee: name: nectar bee¦s - pattern: bee(|1¦s) with nectar + pattern: bee[plural:s] with nectar angry bee: name: angry bee¦s - pattern: angry bee(|1¦s) + pattern: angry bee[plural:s] angry nectar bee: name: angry nectar bee¦s - pattern: angry bee(|1¦s) with nectar + pattern: angry bee[plural:s] with nectar #1.16 entities piglin: name: piglin¦s - pattern: piglin(|1¦s)|(4¦)piglin (kid(|1¦s)|child(|1¦ren)) + pattern: piglin[plural:s]|(baby:)piglin (kid[plural:s]|child[plural:ren]) hoglin: name: hoglin¦s - pattern: hoglin(|1¦s)|(4¦)hoglin (kid(|1¦s)|child(|1¦ren)) + pattern: hoglin[plural:s]|(baby:)hoglin (kid[plural:s]|child[plural:ren]) zoglin: name: zoglin¦s - pattern: zoglin(|1¦s)|(4¦)zoglin (kid(|1¦s)|child(|1¦ren)) + pattern: zoglin[plural:s]|(baby:)zoglin (kid[plural:s]|child[plural:ren]) strider: name: strider¦s - pattern: strider(|1¦s)|(4¦)strider (kid(|1¦s)|child(|1¦ren)) + pattern: strider[plural:s]|(baby:)strider (kid[plural:s]|child[plural:ren]) warm strider: name: warm strider¦s - pattern: warm strider(|1¦s)|(4¦)warm strider (kid(|1¦s)|child(|1¦ren)) + pattern: warm strider[plural:s]|(baby:)warm strider (kid[plural:s]|child[plural:ren]) shivering strider: name: shivering strider¦s, cold strider¦s - pattern: (cold|shivering) strider(|1¦s)|(4¦)(cold|shivering) strider (kid(|1¦s)|child(|1¦ren)) + pattern: (cold|shivering) strider[plural:s]|(baby:)(cold|shivering) strider (kid[plural:s]|child[plural:ren]) #1.16.2 entity piglin brute: name: piglin brute¦s - pattern: piglin brute(|1¦s)|(4¦)piglin brute (kid(|1¦s)|child(|1¦ren)) + pattern: piglin brute[plural:s]|(baby:)piglin brute (kid[plural:s]|child[plural:ren]) #1.17 entities goat: name: goat¦s - pattern: goat(|1¦s)|(4¦)goat (kid(|1¦s)|child(|1¦ren)) + pattern: goat[plural:s]|(baby:)goat (kid[plural:s]|child[plural:ren]) screaming goat: name: goat¦s - pattern: screaming goat(|1¦s)|(4¦)screaming goat (kid(|1¦s)|child(|1¦ren)) + pattern: screaming goat[plural:s]|(baby:)screaming goat (kid[plural:s]|child[plural:ren]) quiet goat: name: goat¦s - pattern: quiet goat(|1¦s)|(4¦)quiet goat (kid(|1¦s)|child(|1¦ren)) + pattern: quiet goat[plural:s]|(baby:)quiet goat (kid[plural:s]|child[plural:ren]) glow squid: name: glow squid¦s - pattern: glow squid(|1¦s) + pattern: glow squid[plural:s] axolotl: name: axolotl¦s @an - pattern: axolotl(|1¦s)|(4¦)axolotl (kid(|1¦s)|child(|1¦ren)) + pattern: axolotl[plural:s]|(baby:)axolotl (kid[plural:s]|child[plural:ren]) lucy axolotl: name: axolotl¦s - pattern: lucy axolotl(|1¦s)|(4¦)lucy axolotl (kid(|1¦s)|child(|1¦ren)) + pattern: lucy axolotl[plural:s]|(baby:)lucy axolotl (kid[plural:s]|child[plural:ren]) wild axolotl: name: axolotl¦s - pattern: wild axolotl(|1¦s)|(4¦)wild axolotl (kid(|1¦s)|child(|1¦ren)) + pattern: wild axolotl[plural:s]|(baby:)wild axolotl (kid[plural:s]|child[plural:ren]) gold axolotl: name: axolotl¦s - pattern: gold axolotl(|1¦s)|(4¦)gold axolotl (kid(|1¦s)|child(|1¦ren)) + pattern: gold axolotl[plural:s]|(baby:)gold axolotl (kid[plural:s]|child[plural:ren]) cyan axolotl: name: axolotl¦s - pattern: cyan axolotl(|1¦s)|(4¦)cyan axolotl (kid(|1¦s)|child(|1¦ren)) + pattern: cyan axolotl[plural:s]|(baby:)cyan axolotl (kid[plural:s]|child[plural:ren]) blue axolotl: name: axolotl¦s - pattern: blue axolotl(|1¦s)|(4¦)blue axolotl (kid(|1¦s)|child(|1¦ren)) + pattern: blue axolotl[plural:s]|(baby:)blue axolotl (kid[plural:s]|child[plural:ren]) marker: name: marker¦s - pattern: marker(|1¦s) + pattern: marker[plural:s] glow item frame: name: glow item frame¦s - pattern: glow item[ ]frame(|1¦s) + pattern: glow item[ ]frame[plural:s] # 1.19 Entities chest boat: name: chest boat¦s - pattern: chest boat[1:s] + pattern: chest boat[plural:s] any chest boat: name: chest boat¦s - pattern: any chest boat[1:s] + pattern: any chest boat[plural:s] oak chest boat: name: oak chest boat¦s - pattern: oak chest boat[1:s] + pattern: oak chest boat[plural:s] spruce chest boat: name: spruce chest boat¦s - pattern: spruce chest boat[1:s] + pattern: spruce chest boat[plural:s] birch chest boat: name: birch chest boat¦s - pattern: birch chest boat[1:s] + pattern: birch chest boat[plural:s] jungle chest boat: name: jungle chest boat¦s - pattern: jungle chest boat[1:s] + pattern: jungle chest boat[plural:s] acacia chest boat: name: acacia chest boat¦s - pattern: acacia chest boat[1:s] + pattern: acacia chest boat[plural:s] dark oak chest boat: name: dark oak chest boat¦s - pattern: dark oak chest boat[1:s] + pattern: dark oak chest boat[plural:s] cherry chest boat: name: cherry chest boat¦s - pattern: cherry chest boat[1:s] + pattern: cherry chest boat[plural:s] mangrove chest boat: name: mangrove chest boat¦s - pattern: mangrove chest boat[1:s] + pattern: mangrove chest boat[plural:s] bamboo chest raft: name: bamboo chest raft¦s - pattern: bamboo chest (raft|boat)[1:s] + pattern: bamboo chest (raft|boat)[plural:s] pale oak chest boat: name: pale oak chest boat¦s - pattern: pale oak chest boat[1:s] + pattern: pale oak chest boat[plural:s] frog: name: frog¦s - pattern: frog(|1¦s)|(4¦)frog (kid(|1¦s)|child(|1¦ren)) + pattern: frog[plural:s]|(baby:)frog (kid[plural:s]|child[plural:ren]) temperate frog: name: temperate frog¦s - pattern: temperate frog(|1¦s)|(4¦)temperate frog (kid(|1¦s)|child(|1¦ren)) + pattern: temperate frog[plural:s]|(baby:)temperate frog (kid[plural:s]|child[plural:ren]) warm frog: name: warm frog¦s - pattern: warm frog(|1¦s)|(4¦)warm frog (kid(|1¦s)|child(|1¦ren)) + pattern: warm frog[plural:s]|(baby:)warm frog (kid[plural:s]|child[plural:ren]) cold frog: name: cold frog¦s - pattern: cold frog(|1¦s)|(4¦)cold frog (kid(|1¦s)|child(|1¦ren)) + pattern: cold frog[plural:s]|(baby:)cold frog (kid[plural:s]|child[plural:ren]) allay: name: allay¦s - pattern: allay(|1¦s) + pattern: allay[plural:s] tadpole: name: tadpole¦s - pattern: tadpole(|1¦s) + pattern: tadpole[plural:s] warden: name: warden¦s - pattern: warden(|1¦s) + pattern: warden[plural:s] # 1.19.3 Entities enemy: name: enem¦y¦ies @an - pattern: enem(y|1¦ies) + pattern: enem(y|plural:ies) camel: name: camel¦s - pattern: camel(|1¦s) + pattern: camel[plural:s] # 1.19.4 Entities sniffer: name: sniffer¦s - pattern: sniffer(|1¦s) + pattern: sniffer[plural:s] interaction: name: interaction¦s - pattern: interaction(|1¦s) + pattern: interaction[plural:s] display: name: display¦s - pattern: display(1:s| [entit(y|1:ies)]) + pattern: display(plural:s| [entit(y|plural:ies)]) block display: name: block display¦s - pattern: (block display(1:s| [entit(y|1:ies)]) [of %-blockdata/itemtype%]|alt:%-blockdata/itemtype% block display(1:s| [entit(y|1:ies)])) + pattern: (block display(plural:s| [entit(y|plural:ies)]) [of %-blockdata/itemtype%]|alt:%-blockdata/itemtype% block display(plural:s| [entit(y|plural:ies)])) item display: name: item display¦s - pattern: (item display(1:s| [entit(y|1:ies)]) [of %-itemtype%]|alt:%-itemtype% item display(1:s| [entit(y|1:ies)])) + pattern: (item display(plural:s| [entit(y|plural:ies)]) [of %-itemtype%]|alt:%-itemtype% item display(plural:s| [entit(y|plural:ies)])) text display: name: text display¦s - pattern: text display(1:s| [entit(y|1:ies)]) + pattern: text display(plural:s| [entit(y|plural:ies)]) # 1.20.3 Entities breeze: name: breeze¦s - pattern: breeze(|1¦s) + pattern: breeze[plural:s] wind charge: name: wind charge¦s - pattern: wind charge(|1¦s) + pattern: wind charge[plural:s] # 1.20.5 Entities armadillo: name: armadillo¦s @an - pattern: armadillo(|1¦s)|(4¦)armadillo (kid(|1¦s)|child(|1¦ren)) + pattern: armadillo[plural:s]|(baby:)armadillo (kid[plural:s]|child[plural:ren]) bogged: name: bogged¦s - pattern: bogged[1:s] + pattern: bogged[plural:s] # 1.21.2 Entities any salmon: name: salmon¦s - pattern: any salmon[1:s] + pattern: any salmon[plural:s] large salmon: name: large salmon¦s - pattern: large salmon[1:s] + pattern: large salmon[plural:s] medium salmon: name: medium salmon¦s - pattern: medium salmon[1:s] + pattern: medium salmon[plural:s] small salmon: name: small salmon¦s - pattern: small salmon[1:s] + pattern: small salmon[plural:s] # 1.21.3 Entities creaking: name: creaking¦s - pattern: creaking[1:s] + pattern: creaking[plural:s] # -- Heal Reasons -- heal reasons: From 389dc5a978c959d1706e9c75247d983ea19ad645 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 26 Jun 2025 00:58:05 -0400 Subject: [PATCH 02/21] Additional Cleanup --- .../ch/njol/skript/entity/EntityData.java | 5 ++-- src/main/resources/lang/default.lang | 24 ++++++++++--------- 2 files changed, 15 insertions(+), 14 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 38c1316511e..4bc4ce99976 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -283,12 +283,11 @@ public EntityData() { throw new IllegalStateException(); } - @SuppressWarnings("null") @Override public final boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { this.matchedPattern = matchedPattern; - this.plural = parseResult.hasTag("unknownplural") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("plural")); - this.baby = parseResult.hasTag("unknownage") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("baby")); + this.plural = parseResult.hasTag("unknown_plural") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("plural")); + this.baby = parseResult.hasTag("unknown_age") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("baby")); return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedPattern, parseResult); } diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index 3c7ba5bb5cc..7034b74b96e 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -468,10 +468,12 @@ directions: # -- Entities -- # about patterns: -# the marks (1¦..) are only required in the english file, i.e. you can use (..|..) or [..] for plurals in other languages -# the exception to this rule is the 'f' and the corresponding marks (4¦ and 8¦) +# the tag "plural" is to indicate the pattern is referencing multiple +# the tag "unknown_plural" is to indicate the pattern is grammatically correct for both singular and plural +# without a suffix, such as "sheep" +# the tag "baby" is to indicate the pattern is referencing the baby state of an entity entities: - age pattern: (unknownage:|baby:(baby|young)|adult:(adult|grown(-| )up)) + age pattern: (unknown_age:|baby:(baby|young)|adult:(adult|grown(-| )up)) age adjectives: baby: baby adult: adult @@ -674,7 +676,7 @@ entities: pattern: explosive [mine]cart[plural:s]|[mine]cart[plural:s] with TNT[s] spawner minecart: name: spawner minecart¦s - pattern: (monster|mob|) spawner [mine]cart[plural:s]|[mine]cart[plural:s] with (monster|mob|) spawner[s] + pattern: [monster|mob] spawner [mine]cart[plural:s]|[mine]cart[plural:s] with [monster|mob] spawner[s] command minecart: name: command minecart¦s pattern: command [mine]cart[plural:s]|[mine]cart[plural:s] with command block[s] @@ -717,13 +719,13 @@ entities: sheep: name: sheep # while sheep is ambiguous, sheeps is plural (even though it's wrong) - pattern: [%-colors%] sheep(unknownplural:|plural:s)|(baby:)[%-colors%] lamb[plural:s] + pattern: [%-colors%] sheep(unknown_plural:|plural:s)|(baby:)[%-colors%] lamb[plural:s] unsheared sheep: name: unsheared sheep @an - pattern: unsheared [%-colors%] sheep(unknownplural:|plural:s) + pattern: unsheared [%-colors%] sheep(unknown_plural:|plural:s) sheared sheep: name: sheared sheep - pattern: sheared [%-colors%] sheep(unknownplural:|plural:s) + pattern: sheared [%-colors%] sheep(unknown_plural:|plural:s) silverfish: name: silverfish¦es pattern: silverfish[plural:es] @@ -750,7 +752,7 @@ entities: pattern: [thrown] bottle[plural:s] o(f|') enchanting|[e]xp[erience] bottle[plural:s] tnt: name: TNT - pattern: ([primed] TNT(unknownplural:|plural:s)|TNT entit(y|plural:ies)) + pattern: ([primed] TNT(unknown_plural:|plural:s)|TNT entit(y|plural:ies)) villager: name: villager¦s pattern: villager[plural:s]|(baby:)[villager] (kid[plural:s]|child[plural:ren]) @@ -844,16 +846,16 @@ entities: pattern: firework[plural:s] [rocket[plural:s]] falling block: name: falling block¦s - pattern: falling (block[plural:s]|(unknownplural:)%-itemtype%) + pattern: falling (block[plural:s]|(unknown_plural:)%-itemtype%) adjective: falling not a block error: Falling blocks must be blocks, not items thrown potion: name: thrown potion¦s - pattern: thrown (potion[plural:s]|(unknownplural:)%-itemtypes%) + pattern: thrown (potion[plural:s]|(unknown_plural:)%-itemtypes%) adjective: thrown dropped item: name: dropped item¦s - pattern: dropped (item[plural:s]|(unknownplural:)%-itemtypes%)|item entit(y|plural:ies) + pattern: dropped (item[plural:s]|(unknown_plural:)%-itemtypes%)|item entit(y|plural:ies) adjective: dropped horse: name: horse¦s From 71457972a91c8a78cf697d5bd7e278f8dde27459 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 26 Jun 2025 16:36:24 -0400 Subject: [PATCH 03/21] Update default.lang --- src/main/resources/lang/default.lang | 120 +++++++++++++-------------- 1 file changed, 60 insertions(+), 60 deletions(-) diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index 7034b74b96e..0427a5cdde0 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -546,10 +546,10 @@ entities: pattern: blaze[plural:s] chicken: name: chicken¦s - pattern: chicken[plural:s]|(baby:)chick[plural:s] + pattern: chicken[plural:s]|baby:chick[plural:s] cow: name: cow¦s - pattern: cow[plural:s]|(baby:)cal(f|plural:ves) + pattern: cow[plural:s]|baby:cal(f|plural:ves) cave spider: name: cave spider¦s pattern: cave[ ]spider[plural:s] @@ -685,10 +685,10 @@ entities: pattern: (mooshroom[ cow]|mushroom cow)[plural:s] red mooshroom: name: red mooshroom¦s - pattern: red (mooshroom[ cow]|mushroom cow)[plural:s]|(baby:)mooshroom (kid[plural:s]|child[plural:ren]) + pattern: red (mooshroom[ cow]|mushroom cow)[plural:s]|baby:mooshroom (kid[plural:s]|child[plural:ren]) brown mooshroom: name: brown mooshroom¦s - pattern: brown (mooshroom[ cow]|mushroom cow)[plural:s]|(baby:)mooshroom (kid[plural:s]|child[plural:ren]) + pattern: brown (mooshroom[ cow]|mushroom cow)[plural:s]|baby:mooshroom (kid[plural:s]|child[plural:ren]) ocelot: name: ocelot¦s @an pattern: ocelot[plural:s] @@ -697,13 +697,13 @@ entities: pattern: (wild|untamed) ocelot[plural:s] cat: name: cat¦s - pattern: [%-cattype%] cat[plural:s]|tamed ocelot[plural:s]|(baby:)[%-cattype%] kitten[plural:s] + pattern: [%-cattype%] cat[plural:s]|tamed ocelot[plural:s]|baby:[%-cattype%] kitten[plural:s] painting: name: painting¦s pattern: painting[plural:s] pig: name: pig¦s - pattern: [%-pigvariant%] pig[plural:s]|(baby:)piglet[plural:s] + pattern: [%-pigvariant%] pig[plural:s]|baby:piglet[plural:s] saddled pig: name: saddled pig¦s pattern: saddled [%-pigvariant%] pig[plural:s] @@ -715,11 +715,11 @@ entities: pattern: player[plural:s] zombie pigman: name: zombie pig¦man¦men|zombified piglin - pattern: (zombie pigm(an|plural:en)|zombified piglin[plural:s])|(baby:)(zombie pigletboy[plural:s]|zombified piglin (kid[plural:s]|child[plural:ren])) + pattern: (zombie pigm(an|plural:en)|zombified piglin[plural:s])|baby:(zombie pigletboy[plural:s]|zombified piglin (kid[plural:s]|child[plural:ren])) sheep: name: sheep # while sheep is ambiguous, sheeps is plural (even though it's wrong) - pattern: [%-colors%] sheep(unknown_plural:|plural:s)|(baby:)[%-colors%] lamb[plural:s] + pattern: [%-colors%] sheep(unknown_plural:|plural:s)|baby:[%-colors%] lamb[plural:s] unsheared sheep: name: unsheared sheep @an pattern: unsheared [%-colors%] sheep(unknown_plural:|plural:s) @@ -728,7 +728,7 @@ entities: pattern: sheared [%-colors%] sheep(unknown_plural:|plural:s) silverfish: name: silverfish¦es - pattern: silverfish[plural:es] + pattern: silverfish[unknown_plural:|plural:es] skeleton: name: skeleton¦s pattern: skeleton[plural:s] @@ -755,58 +755,58 @@ entities: pattern: ([primed] TNT(unknown_plural:|plural:s)|TNT entit(y|plural:ies)) villager: name: villager¦s - pattern: villager[plural:s]|(baby:)[villager] (kid[plural:s]|child[plural:ren]) + pattern: villager[plural:s]|baby:[villager] (kid[plural:s]|child[plural:ren]) normal: name: villager¦s - pattern: [unemployed] villager[plural:s]|(baby:)[[unemployed] villager] (kid[plural:s]|child[plural:ren]) + pattern: [unemployed] villager[plural:s]|baby:[[unemployed] villager] (kid[plural:s]|child[plural:ren]) armorer: name: armorer¦s - pattern: armo[u]rer[plural:s]|(baby:)armo[u]rer (kid[plural:s]|child[plural:ren]) + pattern: armo[u]rer[plural:s]|baby:armo[u]rer (kid[plural:s]|child[plural:ren]) cartographer: name: cartographer¦s - pattern: cartographer[plural:s]|(baby:)cartographer (kid[plural:s]|child[plural:ren]) + pattern: cartographer[plural:s]|baby:cartographer (kid[plural:s]|child[plural:ren]) cleric: name: cleric¦s - pattern: (priest|cleric)[plural:s]|(baby:)(priest|cleric) (kid[plural:s]|child[plural:ren]) + pattern: (priest|cleric)[plural:s]|baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) fisherman: name: fisherman¦s - pattern: fisherman[plural:s]|(baby:)fisherman (kid[plural:s]|child[plural:ren]) + pattern: fisherman[plural:s]|baby:fisherman (kid[plural:s]|child[plural:ren]) fletcher: name: fletcher¦s - pattern: fletcher[plural:s]|(baby:)fletcher (kid[plural:s]|child[plural:ren]) + pattern: fletcher[plural:s]|baby:fletcher (kid[plural:s]|child[plural:ren]) leatherworker: name: leatherworker¦s - pattern: leatherworker[plural:s]|(baby:)leatherworker (kid[plural:s]|child[plural:ren]) + pattern: leatherworker[plural:s]|baby:leatherworker (kid[plural:s]|child[plural:ren]) mason: name: mason¦s - pattern: mason[plural:s]|(baby:)mason (kid[plural:s]|child[plural:ren]) + pattern: mason[plural:s]|baby:mason (kid[plural:s]|child[plural:ren]) shepherd: name: shepherd¦s - pattern: shepherd[plural:s]|(baby:)shepherd (kid[plural:s]|child[plural:ren]) + pattern: shepherd[plural:s]|baby:shepherd (kid[plural:s]|child[plural:ren]) toolsmith: name: toolsmith¦s - pattern: tool[ ](smith|maker)[plural:s]|(baby:)tool[ ](smith|maker) (kid[plural:s]|child[plural:ren]) + pattern: tool[ ](smith|maker)[plural:s]|baby:tool[ ](smith|maker) (kid[plural:s]|child[plural:ren]) weaponsmith: name: weaponsmith¦s - pattern: weapon[ ]smith[plural:s]|(baby:)weapon[ ]smith (kid[plural:s]|child[plural:ren]) + pattern: weapon[ ]smith[plural:s]|baby:weapon[ ]smith (kid[plural:s]|child[plural:ren]) farmer: name: farmer¦s - pattern: farmer[plural:s]|(baby:)farmer (kid[plural:s]|child[plural:ren]) + pattern: farmer[plural:s]|baby:farmer (kid[plural:s]|child[plural:ren]) librarian: name: librarian¦s - pattern: librarian[plural:s]|(baby:)librarian (kid[plural:s]|child[plural:ren]) + pattern: librarian[plural:s]|baby:librarian (kid[plural:s]|child[plural:ren]) priest: name: priest¦s - pattern: (priest|cleric)[plural:s]|(baby:)(priest|cleric) (kid[plural:s]|child[plural:ren]) + pattern: (priest|cleric)[plural:s]|baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) blacksmith: name: blacksmith¦s - pattern: [black]smith[plural:s]|(baby:)[black]smith (kid[plural:s]|child[plural:ren]) + pattern: [black]smith[plural:s]|baby:[black]smith (kid[plural:s]|child[plural:ren]) butcher: name: butcher¦s - pattern: butcher[plural:s]|(baby:)butcher (kid[plural:s]|child[plural:ren]) + pattern: butcher[plural:s]|baby:butcher (kid[plural:s]|child[plural:ren]) nitwit: name: nitwit¦s - pattern: nitwit[plural:s]|(baby:)nitwit (kid[plural:s]|child[plural:ren]) + pattern: nitwit[plural:s]|baby:nitwit (kid[plural:s]|child[plural:ren]) witch: name: witch¦es pattern: witch[plural:es] @@ -824,7 +824,7 @@ entities: pattern: [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] tamed wolf: name: tamed wol¦f¦ves - pattern: ( [%-wolfvariant%] dog[plural:s]|tamed [%-wolfvariant%] wol(f|plural:ves)| [%-wolfvariant%] (baby:)pupp(y|plural:ies)) [[with collar] colo[u]r[ed] %-color%] + pattern: ( [%-wolfvariant%] dog[plural:s]|tamed [%-wolfvariant%] wol(f|plural:ves)|baby:[%-wolfvariant%] [wolf] pup[py|plural:pies]) [[with collar] colo[u]r[ed] %-color%] wild wolf: name: wild wol¦f¦ves pattern: (wild|untamed) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] @@ -836,7 +836,7 @@ entities: pattern: (peaceful|neutral|unaggressive) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] zombie: name: zombie¦s - pattern: zombie[plural:s]|(baby:)zombie (kid[plural:s]|child[plural:ren]) + pattern: zombie[plural:s]|baby:zombie (kid[plural:s]|child[plural:ren]) xp-orb: name: experience orb¦s @an pattern: ([e]xp|experience)( |-)orb[plural:s] @@ -859,7 +859,7 @@ entities: adjective: dropped horse: name: horse¦s - pattern: horse[plural:s]|(baby:)foal[plural:s] + pattern: horse[plural:s]|baby:foal[plural:s] donkey: name: donkey¦s pattern: donkey[plural:s] @@ -871,13 +871,13 @@ entities: pattern: chested horse[plural:s] undead horse: name: undead horse¦s @an - pattern: (zombie|undead) horse[plural:s]|(zombie|undead) horse[plural:s]|(zombie|undead) (baby:)foal[plural:s] + pattern: (zombie|undead) horse[plural:s]|(zombie|undead) horse[plural:s]|baby:(zombie|undead) foal[plural:s] skeleton horse: name: skeleton horse¦s - pattern: skeleton horse[plural:s]|skeleton horse[plural:s]|skeleton (baby:)foal[plural:s] + pattern: skeleton horse[plural:s]|skeleton horse[plural:s]|baby:skeleton foal[plural:s] any horse: name: any horse¦s - pattern: any horse[plural:s]|(baby:)foal[plural:s] + pattern: any horse[plural:s]|baby:foal[plural:s] llama: name: llama¦s pattern: llama[plural:s]| llama (baby:)cria[plural:s] @@ -1096,7 +1096,7 @@ entities: pattern: tropical fish[plural:es] drowned: name: drowned¦s - pattern: drowned[plural:s]|(baby:)drowned (kid[plural:s]|child[plural:ren]) + pattern: drowned[plural:s]|baby:drowned (kid[plural:s]|child[plural:ren]) dolphin: name: dolphin¦s pattern: dolphin[plural:s] @@ -1105,7 +1105,7 @@ entities: pattern: phantom[plural:s] turtle: name: turtle¦s - pattern: turtle[plural:s]|(baby:)turtle (kid[plural:s]|child[plural:ren]) + pattern: turtle[plural:s]|baby:turtle (kid[plural:s]|child[plural:ren]) trident: name: trident¦s pattern: trident[plural:s] @@ -1115,13 +1115,13 @@ entities: #1.14 entities fox: name: fox¦es - pattern: fox[plural:es]|(baby:)fox (kid[plural:s]|child[plural:ren]) + pattern: fox[plural:es]|baby:fox (kid[plural:s]|child[plural:ren]) red fox: name: red fox¦es - pattern: red fox[plural:es]|(baby:)fox (kid[plural:s]|child[plural:ren]) + pattern: red fox[plural:es]|baby:fox (kid[plural:s]|child[plural:ren]) snow fox: name: snow fox¦es - pattern: snow fox[plural:es]|(baby:)fox (kid[plural:s]|child[plural:ren]) + pattern: snow fox[plural:es]|baby:fox (kid[plural:s]|child[plural:ren]) pillager: name: pillager¦s pattern: pillager[plural:s] @@ -1130,7 +1130,7 @@ entities: pattern: ravager[plural:s] wandering trader: name: wandering trader¦s - pattern: wandering trader[plural:s]|(baby:)wandering trader (kid[plural:s]|child[plural:ren]) //supposed to be ageable, but not working, spigot bug? + pattern: wandering trader[plural:s]|baby:wandering trader (kid[plural:s]|child[plural:ren]) //supposed to be ageable, but not working, spigot bug? raider: name: raider¦s pattern: raider[plural:s] @@ -1159,57 +1159,57 @@ entities: #1.16 entities piglin: name: piglin¦s - pattern: piglin[plural:s]|(baby:)piglin (kid[plural:s]|child[plural:ren]) + pattern: piglin[plural:s]|baby:piglin (kid[plural:s]|child[plural:ren]) hoglin: name: hoglin¦s - pattern: hoglin[plural:s]|(baby:)hoglin (kid[plural:s]|child[plural:ren]) + pattern: hoglin[plural:s]|baby:hoglin (kid[plural:s]|child[plural:ren]) zoglin: name: zoglin¦s - pattern: zoglin[plural:s]|(baby:)zoglin (kid[plural:s]|child[plural:ren]) + pattern: zoglin[plural:s]|baby:zoglin (kid[plural:s]|child[plural:ren]) strider: name: strider¦s - pattern: strider[plural:s]|(baby:)strider (kid[plural:s]|child[plural:ren]) + pattern: strider[plural:s]|baby:strider (kid[plural:s]|child[plural:ren]) warm strider: name: warm strider¦s - pattern: warm strider[plural:s]|(baby:)warm strider (kid[plural:s]|child[plural:ren]) + pattern: warm strider[plural:s]|baby:warm strider (kid[plural:s]|child[plural:ren]) shivering strider: name: shivering strider¦s, cold strider¦s - pattern: (cold|shivering) strider[plural:s]|(baby:)(cold|shivering) strider (kid[plural:s]|child[plural:ren]) + pattern: (cold|shivering) strider[plural:s]|baby:(cold|shivering) strider (kid[plural:s]|child[plural:ren]) #1.16.2 entity piglin brute: name: piglin brute¦s - pattern: piglin brute[plural:s]|(baby:)piglin brute (kid[plural:s]|child[plural:ren]) + pattern: piglin brute[plural:s]|baby:piglin brute (kid[plural:s]|child[plural:ren]) #1.17 entities goat: name: goat¦s - pattern: goat[plural:s]|(baby:)goat (kid[plural:s]|child[plural:ren]) + pattern: goat[plural:s]|baby:goat (kid[plural:s]|child[plural:ren]) screaming goat: name: goat¦s - pattern: screaming goat[plural:s]|(baby:)screaming goat (kid[plural:s]|child[plural:ren]) + pattern: screaming goat[plural:s]|baby:screaming goat (kid[plural:s]|child[plural:ren]) quiet goat: name: goat¦s - pattern: quiet goat[plural:s]|(baby:)quiet goat (kid[plural:s]|child[plural:ren]) + pattern: quiet goat[plural:s]|baby:quiet goat (kid[plural:s]|child[plural:ren]) glow squid: name: glow squid¦s pattern: glow squid[plural:s] axolotl: name: axolotl¦s @an - pattern: axolotl[plural:s]|(baby:)axolotl (kid[plural:s]|child[plural:ren]) + pattern: axolotl[plural:s]|baby:axolotl (kid[plural:s]|child[plural:ren]) lucy axolotl: name: axolotl¦s - pattern: lucy axolotl[plural:s]|(baby:)lucy axolotl (kid[plural:s]|child[plural:ren]) + pattern: lucy axolotl[plural:s]|baby:lucy axolotl (kid[plural:s]|child[plural:ren]) wild axolotl: name: axolotl¦s - pattern: wild axolotl[plural:s]|(baby:)wild axolotl (kid[plural:s]|child[plural:ren]) + pattern: wild axolotl[plural:s]|baby:wild axolotl (kid[plural:s]|child[plural:ren]) gold axolotl: name: axolotl¦s - pattern: gold axolotl[plural:s]|(baby:)gold axolotl (kid[plural:s]|child[plural:ren]) + pattern: gold axolotl[plural:s]|baby:gold axolotl (kid[plural:s]|child[plural:ren]) cyan axolotl: name: axolotl¦s - pattern: cyan axolotl[plural:s]|(baby:)cyan axolotl (kid[plural:s]|child[plural:ren]) + pattern: cyan axolotl[plural:s]|baby:cyan axolotl (kid[plural:s]|child[plural:ren]) blue axolotl: name: axolotl¦s - pattern: blue axolotl[plural:s]|(baby:)blue axolotl (kid[plural:s]|child[plural:ren]) + pattern: blue axolotl[plural:s]|baby:blue axolotl (kid[plural:s]|child[plural:ren]) marker: name: marker¦s pattern: marker[plural:s] @@ -1255,16 +1255,16 @@ entities: pattern: pale oak chest boat[plural:s] frog: name: frog¦s - pattern: frog[plural:s]|(baby:)frog (kid[plural:s]|child[plural:ren]) + pattern: frog[plural:s]|baby:frog (kid[plural:s]|child[plural:ren]) temperate frog: name: temperate frog¦s - pattern: temperate frog[plural:s]|(baby:)temperate frog (kid[plural:s]|child[plural:ren]) + pattern: temperate frog[plural:s]|baby:temperate frog (kid[plural:s]|child[plural:ren]) warm frog: name: warm frog¦s - pattern: warm frog[plural:s]|(baby:)warm frog (kid[plural:s]|child[plural:ren]) + pattern: warm frog[plural:s]|baby:warm frog (kid[plural:s]|child[plural:ren]) cold frog: name: cold frog¦s - pattern: cold frog[plural:s]|(baby:)cold frog (kid[plural:s]|child[plural:ren]) + pattern: cold frog[plural:s]|baby:cold frog (kid[plural:s]|child[plural:ren]) allay: name: allay¦s pattern: allay[plural:s] @@ -1310,7 +1310,7 @@ entities: # 1.20.5 Entities armadillo: name: armadillo¦s @an - pattern: armadillo[plural:s]|(baby:)armadillo (kid[plural:s]|child[plural:ren]) + pattern: armadillo[plural:s]|baby:armadillo (kid[plural:s]|child[plural:ren]) bogged: name: bogged¦s pattern: bogged[plural:s] From 7439f0ed7291229e6b76ba62b6892155ae0343bd Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 26 Jun 2025 17:18:37 -0400 Subject: [PATCH 04/21] Initial Commit --- .../ch/njol/skript/entity/EntityData.java | 34 +++++++++++++++++-- .../ch/njol/skript/lang/SkriptParser.java | 5 ++- .../njol/skript/lang/SyntaxElementInfo.java | 8 +++++ 3 files changed, 44 insertions(+), 3 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 414bf1d4461..a8146e8d910 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -180,6 +180,8 @@ private final static class EntityDataInfo> extends Synta final @Nullable EntityType entityType; final Class entityClass; final Noun[] names; + private final Map codeNamePlacements = new HashMap<>(); + private final Map multiPatternCorrelation = new HashMap<>(); public EntityDataInfo(Class dataClass, String codeName, String[] codeNames, int defaultName, Class entityClass) { this(dataClass, codeName, codeNames, defaultName, EntityUtils.toBukkitEntityType(entityClass), entityClass); @@ -211,8 +213,36 @@ public EntityDataInfo( @Override public void onLanguageChange() { - for (int i = 0; i < codeNames.length; i++) - patterns[i] = Language.get(LANGUAGE_NODE + "." + codeNames[i] + ".pattern").replace("", m_age_pattern.toString()); + codeNamePlacements.clear(); + int patternCount = 0; + for (int i = 0; i < codeNames.length; i++) { + String codeName = codeNames[i]; + codeNamePlacements.put(codeName, i); + if (Language.keyExists(LANGUAGE_NODE + "." + codeName + ".pattern")) { + String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".pattern").replace("", m_age_pattern.toString()); + multiPatternCorrelation.put(pattern, codeName); + patterns[patternCount++] = pattern; + } + if (Language.keyExists(LANGUAGE_NODE + "." + codeName + ".patterns")) { + int multiCount = 0; + while (Language.keyExists(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount)) { + String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount).replace("", m_age_pattern.toString()); + multiCount++; + multiPatternCorrelation.put(pattern, codeName); + patterns[patternCount++] = pattern; + } + } + } + } + + @Override + public boolean hasMultiLinedPatterns() { + return true; + } + + @Override + public int getPatternIndex(String pattern) { + return codeNamePlacements.get(multiPatternCorrelation.get(pattern)); } @Override diff --git a/src/main/java/ch/njol/skript/lang/SkriptParser.java b/src/main/java/ch/njol/skript/lang/SkriptParser.java index 4fa8c2c832c..0874a2238f0 100644 --- a/src/main/java/ch/njol/skript/lang/SkriptParser.java +++ b/src/main/java/ch/njol/skript/lang/SkriptParser.java @@ -243,7 +243,10 @@ public boolean hasTag(String tag) { if (!checkExperimentalSyntax(element)) continue; - boolean success = element.preInit() && element.init(parseResult.exprs, patternIndex, getParser().getHasDelayBefore(), parseResult); + int multiPatternIndex = patternIndex; + if (info.hasMultiLinedPatterns()) + multiPatternIndex = info.getPatternIndex(pattern); + boolean success = element.preInit() && element.init(parseResult.exprs, multiPatternIndex, getParser().getHasDelayBefore(), parseResult); if (success) { log.printLog(); return element; diff --git a/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java b/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java index 2724451d23d..d872fbfb748 100644 --- a/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java +++ b/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java @@ -63,6 +63,14 @@ public String getOriginClassPath() { return originClassPath; } + public boolean hasMultiLinedPatterns() { + return false; + } + + public int getPatternIndex(String pattern) { + throw new SkriptAPIException("Method should be overridden by extended class."); + } + @Contract("_ -> new") @ApiStatus.Experimental @SuppressWarnings("unchecked") From 5a43b48ba17140ecbcb4764b9c6876093b39efdb Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Fri, 27 Jun 2025 02:46:39 -0400 Subject: [PATCH 05/21] Follow Up Commit --- .../ch/njol/skript/doc/Documentation.java | 4 +- .../ch/njol/skript/doc/HTMLGenerator.java | 4 +- .../ch/njol/skript/entity/EntityData.java | 75 ++-- .../skript/lang/MultiPatternedSyntaxInfo.java | 143 +++++++ .../ch/njol/skript/lang/SkriptParser.java | 14 +- .../njol/skript/lang/SyntaxElementInfo.java | 8 - .../skript/bukkit/displays/DisplayData.java | 7 +- src/main/resources/lang/default.lang | 370 +++++++++++++----- 8 files changed, 459 insertions(+), 166 deletions(-) create mode 100644 src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java diff --git a/src/main/java/ch/njol/skript/doc/Documentation.java b/src/main/java/ch/njol/skript/doc/Documentation.java index 026981e85a5..12eed64b494 100644 --- a/src/main/java/ch/njol/skript/doc/Documentation.java +++ b/src/main/java/ch/njol/skript/doc/Documentation.java @@ -309,7 +309,7 @@ private static void insertSyntaxElement(final PrintWriter pw, final SyntaxElemen Skript.warning("" + elementClass.getSimpleName() + "'s description or 'since' is invalid"); return; } - final String patterns = cleanPatterns(StringUtils.join(info.patterns, "\n", 0, elementClass == CondCompare.class ? 8 : info.patterns.length)); + final String patterns = cleanPatterns(StringUtils.join(info.patterns, "\n", 0, elementClass == CondCompare.class ? 8 : info.getPatterns().length)); insertOnDuplicateKeyUpdate(pw, "syntax_elements", "id, name, type, patterns, description, examples, since", "patterns = TRIM(LEADING '\n' FROM CONCAT(patterns, '\n', '" + escapeSQL(patterns) + "'))", @@ -341,7 +341,7 @@ private static void insertEvent(final PrintWriter pw, final SkriptEventInfo i Skript.warning("description or 'since' of " + info.getName() + " (" + info.getElementClass().getSimpleName() + ") is invalid"); return; } - final String patterns = cleanPatterns(info.getName().startsWith("On ") ? "[on] " + StringUtils.join(info.patterns, "\n[on] ") : StringUtils.join(info.patterns, "\n")); + final String patterns = cleanPatterns(info.getName().startsWith("On ") ? "[on] " + StringUtils.join(info.getPatterns(), "\n[on] ") : StringUtils.join(info.patterns, "\n")); insertOnDuplicateKeyUpdate(pw, "syntax_elements", "id, name, type, patterns, description, examples, since", "patterns = '" + escapeSQL(patterns) + "'", diff --git a/src/main/java/ch/njol/skript/doc/HTMLGenerator.java b/src/main/java/ch/njol/skript/doc/HTMLGenerator.java index 15a179a2594..52d3eeaf930 100644 --- a/src/main/java/ch/njol/skript/doc/HTMLGenerator.java +++ b/src/main/java/ch/njol/skript/doc/HTMLGenerator.java @@ -528,7 +528,7 @@ private String generateAnnotated(String descTemp, SyntaxElementInfo info, @Nu String[] split = data.split(" "); String pattern = readFile(new File(templateDir + "/templates/" + split[1])); StringBuilder patterns = new StringBuilder(); - for (String line : getDefaultIfNullOrEmpty(info.patterns, "Missing patterns.")) { + for (String line : getDefaultIfNullOrEmpty(info.getPatterns(), "Missing patterns.")) { assert line != null; line = cleanPatterns(line); String parsed = pattern.replace("${element.pattern}", line); @@ -667,7 +667,7 @@ private String generateEvent(String descTemp, SkriptEventInfo info, @Nullable String[] split = data.split(" "); String pattern = readFile(new File(templateDir + "/templates/" + split[1])); StringBuilder patterns = new StringBuilder(); - for (String line : getDefaultIfNullOrEmpty(info.patterns, "Missing patterns.")) { + for (String line : getDefaultIfNullOrEmpty(info.getPatterns(), "Missing patterns.")) { assert line != null; line = "[on] " + cleanPatterns(line); String parsed = pattern.replace("${element.pattern}", line); diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 74fb8961c7d..1d0ac0e8b6a 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -6,18 +6,29 @@ import ch.njol.skript.classes.ClassInfo; import ch.njol.skript.classes.Parser; import ch.njol.skript.classes.Serializer; -import ch.njol.skript.lang.*; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.MultiPatternedSyntaxInfo; +import ch.njol.skript.lang.ParseContext; +import ch.njol.skript.lang.SkriptParser; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.SyntaxElement; import ch.njol.skript.lang.util.SimpleLiteral; -import ch.njol.skript.localization.*; +import ch.njol.skript.localization.Adjective; import ch.njol.skript.localization.Language.LanguageListenerPriority; +import ch.njol.skript.localization.Message; +import ch.njol.skript.localization.Noun; import ch.njol.skript.registrations.Classes; import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import ch.njol.util.coll.iterator.SingleItemIterator; import ch.njol.yggdrasil.Fields; import ch.njol.yggdrasil.YggdrasilSerializable.YggdrasilExtendedSerializable; -import org.bukkit.*; +import org.bukkit.Bukkit; +import org.bukkit.Chunk; +import org.bukkit.Location; +import org.bukkit.RegionAccessor; +import org.bukkit.World; import org.bukkit.entity.Entity; import org.bukkit.entity.EntityType; import org.bukkit.entity.Player; @@ -29,7 +40,10 @@ import java.lang.reflect.Array; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; import java.util.function.Consumer; import java.util.stream.Collectors; @@ -171,8 +185,7 @@ public static void onRegistrationStop() { }); } - private final static class EntityDataInfo> extends SyntaxElementInfo - implements LanguageChangeListener { + private final static class EntityDataInfo> extends MultiPatternedSyntaxInfo { final String codeName; final String[] codeNames; @@ -180,8 +193,6 @@ private final static class EntityDataInfo> extends Synta final @Nullable EntityType entityType; final Class entityClass; final Noun[] names; - private final Map codeNamePlacements = new HashMap<>(); - private final Map multiPatternCorrelation = new HashMap<>(); public EntityDataInfo(Class dataClass, String codeName, String[] codeNames, int defaultName, Class entityClass) { this(dataClass, codeName, codeNames, defaultName, EntityUtils.toBukkitEntityType(entityClass), entityClass); @@ -195,7 +206,7 @@ public EntityDataInfo( @Nullable EntityType entityType, Class entityClass ) { - super(new String[codeNames.length], dataClass, dataClass.getName()); + super(dataClass, codeNames, LANGUAGE_NODE, LanguageListenerPriority.LATEST); assert codeName != null && entityClass != null && codeNames.length > 0; this.codeName = codeName; this.codeNames = codeNames; @@ -207,56 +218,16 @@ public EntityDataInfo( assert codeNames[i] != null; names[i] = new Noun(LANGUAGE_NODE + "." + codeNames[i] + ".name"); } - - Language.addListener(this, LanguageListenerPriority.LATEST); // will initialise patterns, LATEST to make sure that m_age_pattern is updated before this - } - - @Override - public void onLanguageChange() { - codeNamePlacements.clear(); - int patternCount = 0; - for (int i = 0; i < codeNames.length; i++) { - String codeName = codeNames[i]; - codeNamePlacements.put(codeName, i); - if (Language.keyExists(LANGUAGE_NODE + "." + codeName + ".pattern")) { - String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".pattern").replace("", m_age_pattern.toString()); - multiPatternCorrelation.put(pattern, codeName); - patterns[patternCount++] = pattern; - } - if (Language.keyExists(LANGUAGE_NODE + "." + codeName + ".patterns")) { - int multiCount = 0; - while (Language.keyExists(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount)) { - String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount).replace("", m_age_pattern.toString()); - multiCount++; - multiPatternCorrelation.put(pattern, codeName); - patterns[patternCount++] = pattern; - } - } - } } @Override - public boolean hasMultiLinedPatterns() { - return true; - } - - @Override - public int getPatternIndex(String pattern) { - return codeNamePlacements.get(multiPatternCorrelation.get(pattern)); - } - - @Override - public int hashCode() { - return Objects.hashCode(codeName); + public String patternChanger(String pattern) { + return pattern.replace("", m_age_pattern.toString()); } @Override public boolean equals(@Nullable Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (!(obj instanceof EntityDataInfo other)) + if (!(obj instanceof EntityDataInfo other)) return false; if (!codeName.equals(other.codeName)) return false; diff --git a/src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java b/src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java new file mode 100644 index 00000000000..412c7e1537e --- /dev/null +++ b/src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java @@ -0,0 +1,143 @@ +package ch.njol.skript.lang; + +import ch.njol.skript.localization.Language; +import ch.njol.skript.localization.Language.LanguageListenerPriority; +import ch.njol.skript.localization.LanguageChangeListener; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * A typed {@link SyntaxElementInfo} used to allow multi-lined patterns in the lang file and still reference the actual matched pattern + */ +public abstract class MultiPatternedSyntaxInfo extends SyntaxElementInfo implements LanguageChangeListener { + + private final Class dataClass; + private final String[] codeNames; + private final String languageNode; + private String[] patterns; + private final Map codeNamePlacements = new HashMap<>(); + private final Map multiPatternCorrelation = new HashMap<>(); + + /** + * Creates a new {@link MultiPatternedSyntaxInfo} that handles {@link #onLanguageChange()} and grabbing/indexing patterns. + * Defaults to {@link LanguageListenerPriority#NORMAL} priority. + * @param dataClass The {@link SyntaxElement} class + * @param codeNames The codeNames to look for in the lang file + * @param languageNode The language node to look inside in the lang file + */ + public MultiPatternedSyntaxInfo( + Class dataClass, + String[] codeNames, + String languageNode + ) { + this(dataClass, codeNames, languageNode, LanguageListenerPriority.NORMAL); + } + + /** + * Creates a new {@link MultiPatternedSyntaxInfo} that handles {@link #onLanguageChange()} and grabbing/indexing patterns. + * @param dataClass The {@link SyntaxElement} class + * @param codeNames The codeNames to look for in the lang file + * @param languageNode The language node to look inside in the lang file + * @param priority The priority for registering a new language listener + */ + public MultiPatternedSyntaxInfo( + Class dataClass, + String[] codeNames, + String languageNode, + LanguageListenerPriority priority + ) { + super(new String[codeNames.length], dataClass, dataClass.getName()); + this.dataClass = dataClass; + this.codeNames = codeNames; + this.languageNode = languageNode; + + for (int i = 0; i < codeNames.length; i++) { + codeNamePlacements.put(codeNames[i], i); + } + + Language.addListener(this, priority); + } + + @Override + public void onLanguageChange() { + List allPatterns = new ArrayList<>(); + for (String codeName : codeNames) { + if (Language.keyExistsDefault(languageNode + "." + codeName + ".pattern")) { + String pattern = patternChanger(Language.get(languageNode + "." + codeName + ".pattern")); + multiPatternCorrelation.put(pattern, codeName); + allPatterns.add(pattern); + } + if (Language.keyExistsDefault(languageNode + "." + codeName + ".patterns.0")) { + int multiCount = 0; + while (Language.keyExistsDefault(languageNode + "." + codeName + ".patterns." + multiCount)) { + String pattern = patternChanger(Language.get(languageNode + "." + codeName + ".patterns." + multiCount)); + multiCount++; + multiPatternCorrelation.put(pattern, codeName); + allPatterns.add(pattern); + } + } + } + patterns = allPatterns.toArray(String[]::new); + } + + /** + * Make any changes to the pattern when being grabbed from the lang file. + * @param pattern The grabbed pattern from the lang file. + * @return The new pattern. + */ + public String patternChanger(String pattern) { + return pattern; + } + + /** + * Returns the {@link SyntaxElement} class used for this {@link MultiPatternedSyntaxInfo}. + */ + public Class getDataClass() { + return dataClass; + } + + /** + * Returns the code names to look for in the lang file. + */ + public String[] getCodeNames() { + return Arrays.copyOf(codeNames, codeNames.length); + } + + /** + * Returns all patterns grabbed using {@link #languageNode} and {@link #codeNames}. + */ + @Override + public String[] getPatterns() { + return Arrays.copyOf(patterns, patterns.length); + } + + /** + * Returns the language node to look inside in the lang file. + */ + public String getLanguageNode() { + return languageNode; + } + + /** + * Uses the given {@code pattern} to grab the actual pattern index. + * @param pattern The pattern used. + * @return The actual pattern number. + */ + public int getPatternIndex(String pattern) { + return codeNamePlacements.get(multiPatternCorrelation.get(pattern)); + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof MultiPatternedSyntaxInfo other)) + return false; + return dataClass == other.dataClass + && languageNode.equals(other.languageNode) + && Arrays.equals(codeNames, other.codeNames); + } + +} diff --git a/src/main/java/ch/njol/skript/lang/SkriptParser.java b/src/main/java/ch/njol/skript/lang/SkriptParser.java index 0874a2238f0..2cfe127ac9c 100644 --- a/src/main/java/ch/njol/skript/lang/SkriptParser.java +++ b/src/main/java/ch/njol/skript/lang/SkriptParser.java @@ -193,10 +193,10 @@ public boolean hasTag(String tag) { try (ParseLogHandler log = SkriptLogger.startParseLogHandler()) { while (source.hasNext()) { SyntaxElementInfo info = source.next(); - patternsLoop: for (int patternIndex = 0; patternIndex < info.patterns.length; patternIndex++) { + patternsLoop: for (int patternIndex = 0; patternIndex < info.getPatterns().length; patternIndex++) { log.clear(); try { - String pattern = info.patterns[patternIndex]; + String pattern = info.getPatterns()[patternIndex]; assert pattern != null; ParseResult parseResult; try { @@ -228,7 +228,7 @@ public boolean hasTag(String tag) { types = parseResult.source.getElements(TypePatternElement.class);; ExprInfo exprInfo = types.get(i).getExprInfo(); if (!exprInfo.isOptional) { - DefaultExpression expr = getDefaultExpression(exprInfo, info.patterns[patternIndex]); + DefaultExpression expr = getDefaultExpression(exprInfo, info.getPatterns()[patternIndex]); if (!expr.init()) continue patternsLoop; parseResult.exprs[i] = expr; @@ -243,10 +243,10 @@ public boolean hasTag(String tag) { if (!checkExperimentalSyntax(element)) continue; - int multiPatternIndex = patternIndex; - if (info.hasMultiLinedPatterns()) - multiPatternIndex = info.getPatternIndex(pattern); - boolean success = element.preInit() && element.init(parseResult.exprs, multiPatternIndex, getParser().getHasDelayBefore(), parseResult); + int actualPatternIndex = patternIndex; + if (info instanceof MultiPatternedSyntaxInfo multiInfo) + actualPatternIndex = multiInfo.getPatternIndex(pattern); + boolean success = element.preInit() && element.init(parseResult.exprs, actualPatternIndex, getParser().getHasDelayBefore(), parseResult); if (success) { log.printLog(); return element; diff --git a/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java b/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java index d872fbfb748..2724451d23d 100644 --- a/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java +++ b/src/main/java/ch/njol/skript/lang/SyntaxElementInfo.java @@ -63,14 +63,6 @@ public String getOriginClassPath() { return originClassPath; } - public boolean hasMultiLinedPatterns() { - return false; - } - - public int getPatternIndex(String pattern) { - throw new SkriptAPIException("Method should be overridden by extended class."); - } - @Contract("_ -> new") @ApiStatus.Experimental @SuppressWarnings("unchecked") diff --git a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java index dda662cf256..f5b30c75443 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java +++ b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java @@ -88,12 +88,11 @@ public DisplayData(DisplayType type) { protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { type = DisplayType.values()[matchedPattern]; // default to 0, use 1 for alternate pattern: %x% display instead of display of %x% - int exprIndex = parseResult.hasTag("alt") ? 1 : 0; - if (exprs.length == 0 || exprs[exprIndex] == null) + if (exprs.length == 0 || exprs[0] == null) return true; if (type == DisplayType.BLOCK) { - Object object = ((Literal) exprs[exprIndex]).getSingle(); + Object object = ((Literal) exprs[0]).getSingle(); if (object instanceof ItemType itemType) { if (!itemType.hasBlock()) { Skript.error("A block display must be of a block item. " + Classes.toString(itemType.getMaterial()) + " is not a block. If you want to display an item, use an 'item display'."); @@ -104,7 +103,7 @@ protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parse blockData = (BlockData) object; } } else if (type == DisplayType.ITEM) { - ItemType itemType = ((Literal) exprs[exprIndex]).getSingle(); + ItemType itemType = ((Literal) exprs[0]).getSingle(); if (!itemType.hasItem()) { Skript.error("An item display must be of a valid item. " + Classes.toString(itemType.getMaterial()) + " is not a valid item. If you want to display a block, use a 'block display'."); return false; diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index 0427a5cdde0..234041ae071 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -546,10 +546,14 @@ entities: pattern: blaze[plural:s] chicken: name: chicken¦s - pattern: chicken[plural:s]|baby:chick[plural:s] + patterns: + 0: chicken[plural:s] + 1: baby:chick[plural:s] cow: name: cow¦s - pattern: cow[plural:s]|baby:cal(f|plural:ves) + patterns: + 0: cow[plural:s] + 1: baby:cal(f|plural:ves) cave spider: name: cave spider¦s pattern: cave[ ]spider[plural:s] @@ -664,31 +668,47 @@ entities: pattern: regular [mine]cart[plural:s] storage minecart: name: storage minecart¦s - pattern: storage [mine]cart[plural:s]|[mine]cart[plural:s] with chest[s] + patterns: + 0: storage [mine]cart[plural:s] + 1: [mine]cart[plural:s] with chest[s] powered minecart: name: powered minecart¦s - pattern: powered [mine]cart[plural:s]|[mine]cart[plural:s] with furnace[s] + patterns: + 0: powered [mine]cart[plural:s] + 1: [mine]cart[plural:s] with furnace[s] hopper minecart: name: hopper minecart¦s - pattern: hopper [mine]cart[plural:s]|[mine]cart[plural:s] with hopper[s] + patterns: + 0: hopper [mine]cart[plural:s] + 1: [mine]cart[plural:s] with hopper[s] explosive minecart: name: explosive minecart¦s - pattern: explosive [mine]cart[plural:s]|[mine]cart[plural:s] with TNT[s] + patterns: + 0: explosive [mine]cart[plural:s] + 1: [mine]cart[plural:s] with TNT[s] spawner minecart: name: spawner minecart¦s - pattern: [monster|mob] spawner [mine]cart[plural:s]|[mine]cart[plural:s] with [monster|mob] spawner[s] + patterns: + 0: [monster|mob] spawner [mine]cart[plural:s] + 1: [mine]cart[plural:s] with [monster|mob] spawner[s] command minecart: name: command minecart¦s - pattern: command [mine]cart[plural:s]|[mine]cart[plural:s] with command block[s] + patterns: + 0: command [block] [mine]cart[plural:s] + 1: [mine]cart[plural:s] with command block[s] mooshroom: name: mooshroom¦s pattern: (mooshroom[ cow]|mushroom cow)[plural:s] red mooshroom: name: red mooshroom¦s - pattern: red (mooshroom[ cow]|mushroom cow)[plural:s]|baby:mooshroom (kid[plural:s]|child[plural:ren]) + patterns: + 0: red (mooshroom[ cow]|mushroom cow)[plural:s] + 1: baby:mooshroom (kid[plural:s]|child[plural:ren]) brown mooshroom: name: brown mooshroom¦s - pattern: brown (mooshroom[ cow]|mushroom cow)[plural:s]|baby:mooshroom (kid[plural:s]|child[plural:ren]) + patterns: + 0: brown (mooshroom[ cow]|mushroom cow)[plural:s] + 1: baby:mooshroom (kid[plural:s]|child[plural:ren]) ocelot: name: ocelot¦s @an pattern: ocelot[plural:s] @@ -697,13 +717,18 @@ entities: pattern: (wild|untamed) ocelot[plural:s] cat: name: cat¦s - pattern: [%-cattype%] cat[plural:s]|tamed ocelot[plural:s]|baby:[%-cattype%] kitten[plural:s] + patterns: + 0: [%-cattype%] cat[plural:s] + 1: tamed ocelot[plural:s] + 2: baby:[%-cattype%] kitten[plural:s] painting: name: painting¦s pattern: painting[plural:s] pig: name: pig¦s - pattern: [%-pigvariant%] pig[plural:s]|baby:piglet[plural:s] + patterns: + 0: [%-pigvariant%] pig[plural:s] + 1: baby:[%-pigvariant%] piglet[plural:s] saddled pig: name: saddled pig¦s pattern: saddled [%-pigvariant%] pig[plural:s] @@ -715,11 +740,18 @@ entities: pattern: player[plural:s] zombie pigman: name: zombie pig¦man¦men|zombified piglin - pattern: (zombie pigm(an|plural:en)|zombified piglin[plural:s])|baby:(zombie pigletboy[plural:s]|zombified piglin (kid[plural:s]|child[plural:ren])) + patterns: + 0: zombie pigm(an|plural:en) + 1: zombified piglin[plural:s] + 2: baby:zombie pigletboy[plural:s] + 3: baby:zombified piglin (kid[plural:s]|child[plural:ren]) sheep: name: sheep # while sheep is ambiguous, sheeps is plural (even though it's wrong) - pattern: [%-colors%] sheep(unknown_plural:|plural:s)|baby:[%-colors%] lamb[plural:s] + patterns: + 0: [%-colors%] sheep(unknown_plural:|plural:s) + 1: [%-colors%] sheep(unknown_plural:|plural:s) + 2: baby:[%-colors%] lamb[plural:s] unsheared sheep: name: unsheared sheep @an pattern: unsheared [%-colors%] sheep(unknown_plural:|plural:s) @@ -755,58 +787,94 @@ entities: pattern: ([primed] TNT(unknown_plural:|plural:s)|TNT entit(y|plural:ies)) villager: name: villager¦s - pattern: villager[plural:s]|baby:[villager] (kid[plural:s]|child[plural:ren]) + patterns: + 0: villager[plural:s] + 1: baby:[villager] (kid[plural:s]|child[plural:ren]) normal: name: villager¦s - pattern: [unemployed] villager[plural:s]|baby:[[unemployed] villager] (kid[plural:s]|child[plural:ren]) + patterns: + 0: [unemployed] villager[plural:s] + 1: baby:[[unemployed] villager] (kid[plural:s]|child[plural:ren]) armorer: name: armorer¦s - pattern: armo[u]rer[plural:s]|baby:armo[u]rer (kid[plural:s]|child[plural:ren]) + patterns: + 0: armo[u]rer[plural:s] + 1: baby:armo[u]rer (kid[plural:s]|child[plural:ren]) cartographer: name: cartographer¦s - pattern: cartographer[plural:s]|baby:cartographer (kid[plural:s]|child[plural:ren]) + patterns: + 0: cartographer[plural:s] + 1: baby:cartographer (kid[plural:s]|child[plural:ren]) cleric: name: cleric¦s - pattern: (priest|cleric)[plural:s]|baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) + patterns: + 0: (priest|cleric)[plural:s] + 1: baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) fisherman: name: fisherman¦s - pattern: fisherman[plural:s]|baby:fisherman (kid[plural:s]|child[plural:ren]) + patterns: + 0: fisherman[plural:s] + 1: baby:fisherman (kid[plural:s]|child[plural:ren]) fletcher: name: fletcher¦s - pattern: fletcher[plural:s]|baby:fletcher (kid[plural:s]|child[plural:ren]) + patterns: + 0: fletcher[plural:s] + 1: baby:fletcher (kid[plural:s]|child[plural:ren]) leatherworker: name: leatherworker¦s - pattern: leatherworker[plural:s]|baby:leatherworker (kid[plural:s]|child[plural:ren]) + patterns: + 0: leatherworker[plural:s] + 1: baby:leatherworker (kid[plural:s]|child[plural:ren]) mason: name: mason¦s - pattern: mason[plural:s]|baby:mason (kid[plural:s]|child[plural:ren]) + patterns: + 0: mason[plural:s] + 1: baby:mason (kid[plural:s]|child[plural:ren]) shepherd: name: shepherd¦s - pattern: shepherd[plural:s]|baby:shepherd (kid[plural:s]|child[plural:ren]) + patterns: + 0: shepherd[plural:s] + 1: baby:shepherd (kid[plural:s]|child[plural:ren]) toolsmith: name: toolsmith¦s - pattern: tool[ ](smith|maker)[plural:s]|baby:tool[ ](smith|maker) (kid[plural:s]|child[plural:ren]) + patterns: + 0: tool[ ](smith|maker)[plural:s] + 1: baby:tool[ ](smith|maker) (kid[plural:s]|child[plural:ren]) weaponsmith: name: weaponsmith¦s - pattern: weapon[ ]smith[plural:s]|baby:weapon[ ]smith (kid[plural:s]|child[plural:ren]) + patterns: + 0: weapon[ ]smith[plural:s] + 1: baby:weapon[ ]smith (kid[plural:s]|child[plural:ren]) farmer: name: farmer¦s - pattern: farmer[plural:s]|baby:farmer (kid[plural:s]|child[plural:ren]) + patterns: + 0: farmer[plural:s] + 1: baby:farmer (kid[plural:s]|child[plural:ren]) librarian: name: librarian¦s - pattern: librarian[plural:s]|baby:librarian (kid[plural:s]|child[plural:ren]) + patterns: + 0: librarian[plural:s] + 1: baby:librarian (kid[plural:s]|child[plural:ren]) priest: name: priest¦s - pattern: (priest|cleric)[plural:s]|baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) + patterns: + 0: (priest|cleric)[plural:s] + 1: baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) blacksmith: name: blacksmith¦s - pattern: [black]smith[plural:s]|baby:[black]smith (kid[plural:s]|child[plural:ren]) + patterns: + 0: [black]smith[plural:s] + 1: baby:[black]smith (kid[plural:s]|child[plural:ren]) butcher: name: butcher¦s - pattern: butcher[plural:s]|baby:butcher (kid[plural:s]|child[plural:ren]) + patterns: + 0: butcher[plural:s] + 1: baby:butcher (kid[plural:s]|child[plural:ren]) nitwit: name: nitwit¦s - pattern: nitwit[plural:s]|baby:nitwit (kid[plural:s]|child[plural:ren]) + patterns: + 0: nitwit[plural:s] + 1: baby:nitwit (kid[plural:s]|child[plural:ren]) witch: name: witch¦es pattern: witch[plural:es] @@ -818,13 +886,16 @@ entities: pattern: wither skeleton[plural:s] wither skull: name: wither skull¦s - pattern: wither skull([plural:s]| projectile[plural:s]) + pattern: wither skull[ projectile][plural:s] wolf: name: wol¦f¦ves pattern: [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] tamed wolf: name: tamed wol¦f¦ves - pattern: ( [%-wolfvariant%] dog[plural:s]|tamed [%-wolfvariant%] wol(f|plural:ves)|baby:[%-wolfvariant%] [wolf] pup[py|plural:pies]) [[with collar] colo[u]r[ed] %-color%] + patterns: + 0: [%-wolfvariant%] dog[plural:s] [[with collar] colo[u]r[ed] %-color%] + 1: tamed [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] + 2: baby:[%-wolfvariant%] [wolf] pup[py|plural:pies] [[with collar] colo[u]r[ed] %-color%] wild wolf: name: wild wol¦f¦ves pattern: (wild|untamed) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] @@ -836,26 +907,33 @@ entities: pattern: (peaceful|neutral|unaggressive) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] zombie: name: zombie¦s - pattern: zombie[plural:s]|baby:zombie (kid[plural:s]|child[plural:ren]) + patterns: + 0: zombie[plural:s] + 1: baby:zombie (kid[plural:s]|child[plural:ren]) xp-orb: name: experience orb¦s @an pattern: ([e]xp|experience)( |-)orb[plural:s] format: %2$s-%1$s firework: name: firework rocket¦s - pattern: firework[plural:s] [rocket[plural:s]] + pattern: firework[ rocket][plural:s] falling block: name: falling block¦s - pattern: falling (block[plural:s]|(unknown_plural:)%-itemtype%) + patterns: + 0: falling block[plural:s] + 1: unknown_plural:falling %-itemtype% adjective: falling not a block error: Falling blocks must be blocks, not items thrown potion: name: thrown potion¦s - pattern: thrown (potion[plural:s]|(unknown_plural:)%-itemtypes%) + pattern: thrown (potion[plural:s]|unknown_plural:%-itemtypes%) adjective: thrown dropped item: name: dropped item¦s - pattern: dropped (item[plural:s]|(unknown_plural:)%-itemtypes%)|item entit(y|plural:ies) + patterns: + 0: dropped item[plural:s] + 1: unknown_plural:dropped %-itemtypes% + 2: dropped item entit(y|plural:ies) adjective: dropped horse: name: horse¦s @@ -871,43 +949,71 @@ entities: pattern: chested horse[plural:s] undead horse: name: undead horse¦s @an - pattern: (zombie|undead) horse[plural:s]|(zombie|undead) horse[plural:s]|baby:(zombie|undead) foal[plural:s] + patterns: + 0: (zombie|undead) horse[plural:s] + 1: (zombie|undead) horse[plural:s] + 2: baby:(zombie|undead) foal[plural:s] skeleton horse: name: skeleton horse¦s - pattern: skeleton horse[plural:s]|skeleton horse[plural:s]|baby:skeleton foal[plural:s] + patterns: + 0: skeleton horse[plural:s] + 1: skeleton horse[plural:s] + 2: baby:skeleton foal[plural:s] any horse: name: any horse¦s - pattern: any horse[plural:s]|baby:foal[plural:s] + patterns: + 0: any horse[plural:s] + 1: baby:foal[plural:s] llama: name: llama¦s - pattern: llama[plural:s]| llama (baby:)cria[plural:s] + patterns: + 0: llama[plural:s] + 1: baby:llama cria[plural:s] creamy llama: name: creamy llama¦s - pattern: creamy llama[plural:s]| creamy llama (baby:)cria[plural:s] + patterns: + 0: creamy llama[plural:s] + 1: baby:creamy llama cria[plural:s] white llama: name: white llama¦s - pattern: white llama[plural:s]| white llama (baby:)cria[plural:s] + patterns: + 0: white llama[plural:s] + 1: baby:white llama cria[plural:s] brown llama: name: brown llama¦s - pattern: brown llama[plural:s]| brown llama (baby:)cria[plural:s] + patterns: + 0: brown llama[plural:s] + 1: baby:brown llama cria[plural:s] gray llama: name: gray llama¦s - pattern: gray llama[plural:s]| gray llama (baby:)cria[plural:s] + patterns: + 0: gray llama[plural:s] + 1: baby:gray llama cria[plural:s] trader llama: name: trader llama¦s - pattern: trader llama[plural:s]| trader llama (baby:)cria[plural:s] + patterns: + 0: trader llama[plural:s] + 1: baby:trader llama cria[plural:s] creamy trader llama: name: creamy trader llama¦s - pattern: creamy trader llama[plural:s]| creamy trader llama (baby:)cria[plural:s] + patterns: + 0: creamy trader llama[plural:s] + 1: baby:creamy trader llama cria[plural:s] white trader llama: name: white trader llama¦s - pattern: white trader llama[plural:s]| white trader llama (baby:)cria[plural:s] + patterns: + 0: white trader llama[plural:s] + 1: baby:white trader llama cria[plural:s] brown trader llama: name: brown trader llama¦s - pattern: brown trader llama[plural:s]| brown trader llama (baby:)cria[plural:s] + patterns: + 0: brown trader llama[plural:s] + 1: baby:brown trader llama cria[plural:s] gray trader llama: name: gray trader llama¦s - pattern: gray trader llama[plural:s]| gray trader llama (baby:)cria[plural:s] + patterns: + 0: gray trader llama[plural:s] + 1: baby:gray trader llama cria[plural:s] llama spit: name: llama spit¦s pattern: llama spit[plural:s] @@ -922,28 +1028,44 @@ entities: pattern: normal guardian[plural:s] rabbit: name: rabbit¦s - pattern: rabbit[plural:s]|rabbit [plural:s] + patterns: + 0: rabbit[plural:s] + 1: rabbit [plural:s] brown rabbit: name: brown rabbit¦s - pattern: brown rabbit[plural:s]|brown rabbit [plural:s] + patterns: + 0: brown rabbit[plural:s] + 1: brown rabbit [plural:s] black and white rabbit: name: black and white rabbit¦s - pattern: black [and] white rabbit[plural:s]|black [and] white rabbit [plural:s] + patterns: + 0: black [and] white rabbit[plural:s] + 1: black [and] white rabbit [plural:s] white rabbit: name: white rabbit¦s - pattern: white rabbit[plural:s]|white rabbit [plural:s] + patterns: + 0: white rabbit[plural:s] + 1: white rabbit [plural:s] black rabbit: name: black rabbit¦s - pattern: black rabbit[plural:s]|black rabbit [plural:s] + patterns: + 0: black rabbit[plural:s] + 1: black rabbit [plural:s] gold rabbit: name: gold rabbit¦s - pattern: gold rabbit[plural:s]|gold rabbit [plural:s] + patterns: + 0: gold rabbit[plural:s] + 1: gold rabbit [plural:s] salt and pepper rabbit: name: salt and pepper rabbit¦s - pattern: salt [and] pepper rabbit[plural:s]|salt [and] pepper rabbit [plural:s] + patterns: + 0: salt [and] pepper rabbit[plural:s] + 1: salt [and] pepper rabbit [plural:s] killer rabbit: name: killer rabbit¦s - pattern: killer rabbit[plural:s]|killer rabbit [plural:s] + patterns: + 0: killer rabbit[plural:s] + 1: killer rabbit [plural:s] fish hook: name: fish hook¦s pattern: fish[ ]hook[plural:s] @@ -1096,7 +1218,9 @@ entities: pattern: tropical fish[plural:es] drowned: name: drowned¦s - pattern: drowned[plural:s]|baby:drowned (kid[plural:s]|child[plural:ren]) + patterns: + 0: drowned[plural:s] + 1: baby:drowned (kid[plural:s]|child[plural:ren]) dolphin: name: dolphin¦s pattern: dolphin[plural:s] @@ -1105,7 +1229,9 @@ entities: pattern: phantom[plural:s] turtle: name: turtle¦s - pattern: turtle[plural:s]|baby:turtle (kid[plural:s]|child[plural:ren]) + patterns: + 0: turtle[plural:s] + 1: baby:turtle (kid[plural:s]|child[plural:ren]) trident: name: trident¦s pattern: trident[plural:s] @@ -1115,13 +1241,19 @@ entities: #1.14 entities fox: name: fox¦es - pattern: fox[plural:es]|baby:fox (kid[plural:s]|child[plural:ren]) + patterns: + 0: fox[plural:es] + 1: baby:fox (kid[plural:s]|child[plural:ren]) red fox: name: red fox¦es - pattern: red fox[plural:es]|baby:fox (kid[plural:s]|child[plural:ren]) + patterns: + 0: red fox[plural:es] + 1: baby:red fox (kid[plural:s]|child[plural:ren]) snow fox: name: snow fox¦es - pattern: snow fox[plural:es]|baby:fox (kid[plural:s]|child[plural:ren]) + patterns: + 0: snow fox[plural:es] + 1: baby:snow fox (kid[plural:s]|child[plural:ren]) pillager: name: pillager¦s pattern: pillager[plural:s] @@ -1130,7 +1262,9 @@ entities: pattern: ravager[plural:s] wandering trader: name: wandering trader¦s - pattern: wandering trader[plural:s]|baby:wandering trader (kid[plural:s]|child[plural:ren]) //supposed to be ageable, but not working, spigot bug? + patterns: + 0: wandering trader[plural:s] + 1: baby:wandering trader (kid[plural:s]|child[plural:ren]) raider: name: raider¦s pattern: raider[plural:s] @@ -1159,57 +1293,89 @@ entities: #1.16 entities piglin: name: piglin¦s - pattern: piglin[plural:s]|baby:piglin (kid[plural:s]|child[plural:ren]) + patterns: + 0: piglin[plural:s] + 1: baby:piglin (kid[plural:s]|child[plural:ren]) hoglin: name: hoglin¦s - pattern: hoglin[plural:s]|baby:hoglin (kid[plural:s]|child[plural:ren]) + patterns: + 0: hoglin[plural:s] + 1: baby:hoglin (kid[plural:s]|child[plural:ren]) zoglin: name: zoglin¦s - pattern: zoglin[plural:s]|baby:zoglin (kid[plural:s]|child[plural:ren]) + patterns: + 0: zoglin[plural:s] + 1: baby:zoglin (kid[plural:s]|child[plural:ren]) strider: name: strider¦s - pattern: strider[plural:s]|baby:strider (kid[plural:s]|child[plural:ren]) + patterns: + 0: strider[plural:s] + 1: baby:strider (kid[plural:s]|child[plural:ren]) warm strider: name: warm strider¦s - pattern: warm strider[plural:s]|baby:warm strider (kid[plural:s]|child[plural:ren]) + patterns: + 0: warm strider[plural:s] + 1: baby:warm strider (kid[plural:s]|child[plural:ren]) shivering strider: name: shivering strider¦s, cold strider¦s - pattern: (cold|shivering) strider[plural:s]|baby:(cold|shivering) strider (kid[plural:s]|child[plural:ren]) + patterns: + 0: (cold|shivering) strider[plural:s] + 1: baby:(cold|shivering) strider (kid[plural:s]|child[plural:ren]) #1.16.2 entity piglin brute: name: piglin brute¦s - pattern: piglin brute[plural:s]|baby:piglin brute (kid[plural:s]|child[plural:ren]) + patterns: + 0: piglin brute[plural:s] + 1: baby:piglin brute (kid[plural:s]|child[plural:ren]) #1.17 entities goat: name: goat¦s - pattern: goat[plural:s]|baby:goat (kid[plural:s]|child[plural:ren]) + patterns: + 0: goat[plural:s] + 1: baby:goat (kid[plural:s]|child[plural:ren]) screaming goat: name: goat¦s - pattern: screaming goat[plural:s]|baby:screaming goat (kid[plural:s]|child[plural:ren]) + patterns: + 0: screaming goat[plural:s] + 1: baby:screaming goat (kid[plural:s]|child[plural:ren]) quiet goat: name: goat¦s - pattern: quiet goat[plural:s]|baby:quiet goat (kid[plural:s]|child[plural:ren]) + patterns: + 0: quiet goat[plural:s] + 1: baby:quiet goat (kid[plural:s]|child[plural:ren]) glow squid: name: glow squid¦s pattern: glow squid[plural:s] axolotl: name: axolotl¦s @an - pattern: axolotl[plural:s]|baby:axolotl (kid[plural:s]|child[plural:ren]) + patterns: + 0: axolotl[plural:s] + 1: baby:axolotl (kid[plural:s]|child[plural:ren]) lucy axolotl: name: axolotl¦s - pattern: lucy axolotl[plural:s]|baby:lucy axolotl (kid[plural:s]|child[plural:ren]) + patterns: + 0: lucy axolotl[plural:s] + 1: baby:lucy axolotl (kid[plural:s]|child[plural:ren]) wild axolotl: name: axolotl¦s - pattern: wild axolotl[plural:s]|baby:wild axolotl (kid[plural:s]|child[plural:ren]) + patterns: + 0: wild axolotl[plural:s] + 1: baby:wild axolotl (kid[plural:s]|child[plural:ren]) gold axolotl: name: axolotl¦s - pattern: gold axolotl[plural:s]|baby:gold axolotl (kid[plural:s]|child[plural:ren]) + patterns: + 0: gold axolotl[plural:s] + 1: baby:gold axolotl (kid[plural:s]|child[plural:ren]) cyan axolotl: name: axolotl¦s - pattern: cyan axolotl[plural:s]|baby:cyan axolotl (kid[plural:s]|child[plural:ren]) + patterns: + 0: cyan axolotl[plural:s] + 1: baby:cyan axolotl (kid[plural:s]|child[plural:ren]) blue axolotl: name: axolotl¦s - pattern: blue axolotl[plural:s]|baby:blue axolotl (kid[plural:s]|child[plural:ren]) + patterns: + 0: blue axolotl[plural:s] + 1: baby:blue axolotl (kid[plural:s]|child[plural:ren]) marker: name: marker¦s pattern: marker[plural:s] @@ -1255,16 +1421,24 @@ entities: pattern: pale oak chest boat[plural:s] frog: name: frog¦s - pattern: frog[plural:s]|baby:frog (kid[plural:s]|child[plural:ren]) + patterns: + 0: frog[plural:s] + 1: baby:frog (kid[plural:s]|child[plural:ren]) temperate frog: name: temperate frog¦s - pattern: temperate frog[plural:s]|baby:temperate frog (kid[plural:s]|child[plural:ren]) + patterns: + 0: temperate frog[plural:s] + 1: baby:temperate frog (kid[plural:s]|child[plural:ren]) warm frog: name: warm frog¦s - pattern: warm frog[plural:s]|baby:warm frog (kid[plural:s]|child[plural:ren]) + patterns: + 0: warm frog[plural:s] + 1: baby:warm frog (kid[plural:s]|child[plural:ren]) cold frog: name: cold frog¦s - pattern: cold frog[plural:s]|baby:cold frog (kid[plural:s]|child[plural:ren]) + patterns: + 0: cold frog[plural:s] + 1: baby:cold frog (kid[plural:s]|child[plural:ren]) allay: name: allay¦s pattern: allay[plural:s] @@ -1290,16 +1464,28 @@ entities: pattern: interaction[plural:s] display: name: display¦s - pattern: display(plural:s| [entit(y|plural:ies)]) + patterns: + 0: display[plural:s] + 1: display entit(y|plural:ies) block display: name: block display¦s - pattern: (block display(plural:s| [entit(y|plural:ies)]) [of %-blockdata/itemtype%]|alt:%-blockdata/itemtype% block display(plural:s| [entit(y|plural:ies)])) + patterns: + 0: block display[plural:s] [of %-blockdata/itemtype%] + 1: block display entit(y|plural:ies) [of %-blockdata/itemtype%] + 2: %-blockdata/itemtype% block display[plural:s] + 3: %-blockdata/itemtype% block display entit(y|plural:ies) item display: name: item display¦s - pattern: (item display(plural:s| [entit(y|plural:ies)]) [of %-itemtype%]|alt:%-itemtype% item display(plural:s| [entit(y|plural:ies)])) + patterns: + 0: item display[plural:s] [of %-itemtype%] + 1: item display entit(y|plural:ies) [of %-itemtype%] + 2: %-itemtype% item display[plural:s] + 3: %-itemtype% item display entit(y|plural:ies) text display: name: text display¦s - pattern: text display(plural:s| [entit(y|plural:ies)]) + patterns: + 0: text display[plural:s] + 1: text display entit(y|plural:ies) # 1.20.3 Entities breeze: name: breeze¦s @@ -1310,7 +1496,9 @@ entities: # 1.20.5 Entities armadillo: name: armadillo¦s @an - pattern: armadillo[plural:s]|baby:armadillo (kid[plural:s]|child[plural:ren]) + patterns: + 0: armadillo[plural:s] + 1: baby:armadillo (kid[plural:s]|child[plural:ren]) bogged: name: bogged¦s pattern: bogged[plural:s] From ad87cc1308efc32df4db71aad5065b403d855435 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Fri, 27 Jun 2025 23:10:12 -0400 Subject: [PATCH 06/21] Language Map Update --- .../java/ch/njol/skript/config/Config.java | 4 ++ .../ch/njol/skript/config/SectionNode.java | 13 ++++ .../ch/njol/skript/localization/Language.java | 62 ++++++++++++------- 3 files changed, 58 insertions(+), 21 deletions(-) diff --git a/src/main/java/ch/njol/skript/config/Config.java b/src/main/java/ch/njol/skript/config/Config.java index bdb891b98b9..5c290193821 100644 --- a/src/main/java/ch/njol/skript/config/Config.java +++ b/src/main/java/ch/njol/skript/config/Config.java @@ -379,6 +379,10 @@ public Map toMap(String separator) { return main.toMap("", separator); } + public Map toKeyNodeMap(String separator) { + return main.toKeyNodeMap("", separator); + } + public boolean validate(SectionValidator validator) { return validator.validate(getMainNode()); } diff --git a/src/main/java/ch/njol/skript/config/SectionNode.java b/src/main/java/ch/njol/skript/config/SectionNode.java index 3cdd0fadfe8..f782b414d3d 100644 --- a/src/main/java/ch/njol/skript/config/SectionNode.java +++ b/src/main/java/ch/njol/skript/config/SectionNode.java @@ -455,6 +455,19 @@ Map toMap(final String prefix, final String separator) { return r; } + Map toKeyNodeMap(String prefix, String separator) { + Map map = new HashMap<>(); + for (Node node : this) { + if (node instanceof EntryNode entryNode) { + map.put(prefix + node.getKey(), entryNode); + } else if (node instanceof SectionNode sectionNode) { + map.put(prefix + node.getKey(), sectionNode); + map.putAll(sectionNode.toKeyNodeMap(prefix + node.getKey() + separator, separator)); + } + } + return map; + } + /** * @return True if this section and all children are valid, i.e. they contain no invalid nodes. */ diff --git a/src/main/java/ch/njol/skript/localization/Language.java b/src/main/java/ch/njol/skript/localization/Language.java index aa61d532ea5..34bbd22e5d7 100644 --- a/src/main/java/ch/njol/skript/localization/Language.java +++ b/src/main/java/ch/njol/skript/localization/Language.java @@ -2,13 +2,14 @@ import ch.njol.skript.Skript; import ch.njol.skript.config.Config; +import ch.njol.skript.config.EntryNode; +import ch.njol.skript.config.Node; import ch.njol.skript.util.ExceptionUtils; import ch.njol.skript.util.FileUtils; import ch.njol.skript.util.Version; +import org.jetbrains.annotations.Nullable; import org.skriptlang.skript.addon.SkriptAddon; import org.skriptlang.skript.localization.Localizer; -import org.bukkit.plugin.Plugin; -import org.jetbrains.annotations.Nullable; import java.io.File; import java.io.FileInputStream; @@ -42,10 +43,9 @@ public class Language { */ private static String name = "english"; - private static final HashMap defaultLanguage = new HashMap<>(); + private static final Map defaultLanguage = new HashMap<>(); - @Nullable - private static HashMap localizedLanguage = null; + private static @Nullable Map localizedLanguage = null; private static final HashMap langVersion = new HashMap<>(); @@ -53,14 +53,22 @@ public static String getName() { return name; } - @Nullable - private static String get_i(String key) { + private static @Nullable String getEntryNodeValue(Map map, String key) { + if (!map.containsKey(key)) + return null; + Node node = map.get(key); + if (node instanceof EntryNode entryNode) + return entryNode.getValue(); + return null; + } + + private static @Nullable String get_i(String key) { String value; - if ((value = defaultLanguage.get(key)) != null) { + if ((value = getEntryNodeValue(defaultLanguage, key)) != null) { return value; } - if (localizedLanguage != null && (value = localizedLanguage.get(key)) != null) { + if (localizedLanguage != null && (value = getEntryNodeValue(localizedLanguage, key)) != null) { return value; } @@ -69,6 +77,15 @@ private static String get_i(String key) { return null; } + private static @Nullable Node getNode_i(String key) { + if (defaultLanguage.containsKey(key)) { + return defaultLanguage.get(key); + } else if (localizedLanguage != null && localizedLanguage.containsKey(key)) { + return localizedLanguage.get(key); + } + return null; + } + /** * Gets a string from the language file with the given key, or the key itself if the key does * not exist. @@ -87,11 +104,14 @@ public static String get(String key) { * @param key The message's key (case-insensitive) * @return The requested message or null if it doesn't exist */ - @Nullable - public static String get_(String key) { + public static @Nullable String get_(String key) { return get_i("" + key.toLowerCase(Locale.ENGLISH)); } + public static @Nullable Node getNode(String key) { + return getNode_i(key); + } + public static void missingEntryError(String key) { Skript.error("Missing entry '" + key.toLowerCase(Locale.ENGLISH) + "' in the default/english language file"); } @@ -211,10 +231,10 @@ public static void loadDefault(SkriptAddon addon) { } } - Map def = load(defaultLangIs, "default", false); - Map en = load(englishLangIs, "english", addon instanceof org.skriptlang.skript.Skript); + Map def = load(defaultLangIs, "default", false); + Map en = load(englishLangIs, "english", addon instanceof org.skriptlang.skript.Skript); - String v = def.get("version"); + String v = ((EntryNode) def.get("version")).getValue(); if (v == null) Skript.warning("Missing version in default.lang"); @@ -278,7 +298,7 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { } } - Map l; + Map l; try (InputStream is = source.getResourceAsStream("/" + languageFileDirectory + "/" + name + ".lang")) { l = load(is, name, tryUpdate); } catch (IOException e) { @@ -302,7 +322,7 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { Skript.error(addon + "'s language file " + name + ".lang does not provide a version number!"); } else { try { - Version v = new Version("" + l.get("version")); + Version v = new Version("" + getEntryNodeValue(l, "version")); Version lv = langVersion.get(addon.name()); assert lv != null; // set in loadDefault() if (v.isSmallerThan(lv)) @@ -313,14 +333,14 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { } l.remove("version"); if (localizedLanguage != null) { - for (Map.Entry entry : l.entrySet()) { + for (Map.Entry entry : l.entrySet()) { String key = entry.getKey(); - String value = entry.getValue(); + Node node = entry.getValue(); if (defaultLanguage.containsKey(key)) { Skript.warning("'" + key + "' is part of the default language file, " + "and can therefore not be modified in a localized language file."); } else { - localizedLanguage.put(key, value); + localizedLanguage.put(key, node); } } } else { @@ -329,7 +349,7 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { return true; } - private static Map load(@Nullable InputStream in, String name, boolean tryUpdate) { + private static Map load(@Nullable InputStream in, String name, boolean tryUpdate) { if (in == null) return new HashMap<>(); @@ -361,7 +381,7 @@ private static Map load(@Nullable InputStream in, String name, b } } - return langConfig.toMap("."); + return langConfig.toKeyNodeMap("."); } catch (IOException e) { //noinspection ThrowableNotThrown Skript.exception(e, "Could not load the language file '" + name + ".lang': " + ExceptionUtils.toString(e)); From 123bf4de67d6a455ab74f38eef19c3cfaafae0a4 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Sun, 29 Jun 2025 20:04:35 -0400 Subject: [PATCH 07/21] EntityDataInfo and EnitityData Update --- .../java/ch/njol/skript/config/Config.java | 4 - .../ch/njol/skript/config/SectionNode.java | 13 -- .../ch/njol/skript/entity/AxolotlData.java | 8 +- .../java/ch/njol/skript/entity/BeeData.java | 21 +-- .../ch/njol/skript/entity/BoatChestData.java | 28 ++-- .../java/ch/njol/skript/entity/BoatData.java | 26 ++-- .../java/ch/njol/skript/entity/CatData.java | 3 +- .../ch/njol/skript/entity/CreeperData.java | 4 +- .../njol/skript/entity/DroppedItemData.java | 25 ++- .../ch/njol/skript/entity/EndermanData.java | 2 +- .../ch/njol/skript/entity/EntityData.java | 121 +++++++++++++-- .../njol/skript/entity/FallingBlockData.java | 2 +- .../java/ch/njol/skript/entity/FoxData.java | 8 +- .../java/ch/njol/skript/entity/FrogData.java | 14 +- .../java/ch/njol/skript/entity/GoatData.java | 12 +- .../java/ch/njol/skript/entity/LlamaData.java | 14 +- .../ch/njol/skript/entity/MinecartData.java | 20 ++- .../ch/njol/skript/entity/MooshroomData.java | 8 +- .../ch/njol/skript/entity/OcelotData.java | 4 +- .../java/ch/njol/skript/entity/PandaData.java | 2 +- .../ch/njol/skript/entity/ParrotData.java | 17 +-- .../java/ch/njol/skript/entity/PigData.java | 4 +- .../ch/njol/skript/entity/RabbitData.java | 6 +- .../ch/njol/skript/entity/SalmonData.java | 14 +- .../java/ch/njol/skript/entity/SheepData.java | 13 +- .../njol/skript/entity/SimpleEntityData.java | 12 +- .../ch/njol/skript/entity/StriderData.java | 4 +- .../njol/skript/entity/ThrownPotionData.java | 26 ++-- .../njol/skript/entity/TropicalFishData.java | 44 +++--- .../ch/njol/skript/entity/VillagerData.java | 8 +- .../java/ch/njol/skript/entity/WolfData.java | 21 ++- .../java/ch/njol/skript/entity/XpOrbData.java | 2 +- .../skript/entity/ZombieVillagerData.java | 8 +- .../skript/lang/MultiPatternedSyntaxInfo.java | 143 ------------------ .../ch/njol/skript/lang/SkriptParser.java | 5 +- .../ch/njol/skript/localization/Language.java | 59 +++----- .../skript/bukkit/displays/DisplayData.java | 6 +- src/main/resources/lang/default.lang | 52 +++++-- 38 files changed, 355 insertions(+), 428 deletions(-) delete mode 100644 src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java diff --git a/src/main/java/ch/njol/skript/config/Config.java b/src/main/java/ch/njol/skript/config/Config.java index 5c290193821..bdb891b98b9 100644 --- a/src/main/java/ch/njol/skript/config/Config.java +++ b/src/main/java/ch/njol/skript/config/Config.java @@ -379,10 +379,6 @@ public Map toMap(String separator) { return main.toMap("", separator); } - public Map toKeyNodeMap(String separator) { - return main.toKeyNodeMap("", separator); - } - public boolean validate(SectionValidator validator) { return validator.validate(getMainNode()); } diff --git a/src/main/java/ch/njol/skript/config/SectionNode.java b/src/main/java/ch/njol/skript/config/SectionNode.java index f782b414d3d..3cdd0fadfe8 100644 --- a/src/main/java/ch/njol/skript/config/SectionNode.java +++ b/src/main/java/ch/njol/skript/config/SectionNode.java @@ -455,19 +455,6 @@ Map toMap(final String prefix, final String separator) { return r; } - Map toKeyNodeMap(String prefix, String separator) { - Map map = new HashMap<>(); - for (Node node : this) { - if (node instanceof EntryNode entryNode) { - map.put(prefix + node.getKey(), entryNode); - } else if (node instanceof SectionNode sectionNode) { - map.put(prefix + node.getKey(), sectionNode); - map.putAll(sectionNode.toKeyNodeMap(prefix + node.getKey() + separator, separator)); - } - } - return map; - } - /** * @return True if this section and all children are valid, i.e. they contain no invalid nodes. */ diff --git a/src/main/java/ch/njol/skript/entity/AxolotlData.java b/src/main/java/ch/njol/skript/entity/AxolotlData.java index 0fe0ae9d877..218e8494e62 100644 --- a/src/main/java/ch/njol/skript/entity/AxolotlData.java +++ b/src/main/java/ch/njol/skript/entity/AxolotlData.java @@ -23,13 +23,13 @@ public AxolotlData() {} public AxolotlData(@Nullable Variant variant) { this.variant = variant; - matchedPattern = variant != null ? variant.ordinal() + 1 : 0; + matchedCodeName = variant != null ? variant.ordinal() + 1 : 0; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern > 0) - variant = Variant.values()[matchedPattern - 1]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName > 0) + variant = Variant.values()[matchedCodeName - 1]; return true; } diff --git a/src/main/java/ch/njol/skript/entity/BeeData.java b/src/main/java/ch/njol/skript/entity/BeeData.java index 90c34f700af..b7994f437ee 100644 --- a/src/main/java/ch/njol/skript/entity/BeeData.java +++ b/src/main/java/ch/njol/skript/entity/BeeData.java @@ -1,13 +1,12 @@ package ch.njol.skript.entity; -import java.util.Random; - -import org.bukkit.entity.Bee; -import org.jetbrains.annotations.Nullable; - import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import org.bukkit.entity.Bee; +import org.jetbrains.annotations.Nullable; + +import java.util.Random; public class BeeData extends EntityData { @@ -22,15 +21,17 @@ public class BeeData extends EntityData { private int angry = 0; @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern > 3) + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName > 3) { angry = 1; - else if (matchedPattern < 2) + } else if (matchedCodeName < 2) { angry = -1; - if (matchedPattern == 3 || matchedPattern == 5) + } + if (matchedCodeName == 3 || matchedCodeName == 5) { nectar = 1; - else if (matchedPattern < 2) + } else if (matchedCodeName < 2) { nectar = -1; + } return true; } diff --git a/src/main/java/ch/njol/skript/entity/BoatChestData.java b/src/main/java/ch/njol/skript/entity/BoatChestData.java index c4918af95b6..3499c82efb6 100644 --- a/src/main/java/ch/njol/skript/entity/BoatChestData.java +++ b/src/main/java/ch/njol/skript/entity/BoatChestData.java @@ -4,7 +4,7 @@ import ch.njol.skript.aliases.ItemData; import ch.njol.skript.aliases.ItemType; import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import org.bukkit.Material; import org.bukkit.entity.Boat; import org.bukkit.entity.ChestBoat; @@ -50,32 +50,32 @@ public BoatChestData(@Nullable Boat.Type type) { } private BoatChestData(int type) { - matchedPattern = type; + matchedCodeName = type; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, SkriptParser.ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { return true; } @Override protected boolean init(@Nullable Class clazz, @Nullable ChestBoat entity) { if (entity != null) - matchedPattern = 2 + entity.getBoatType().ordinal(); + matchedCodeName = 2 + entity.getBoatType().ordinal(); return true; } @Override public void set(ChestBoat entity) { - if (matchedPattern == 1) // If the type is 'any boat'. - matchedPattern += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. - if (matchedPattern > 1) // 0 and 1 are excluded - entity.setBoatType(types[matchedPattern - 2]); // Removes 2 to fix the index. + if (matchedCodeName == 1) // If the type is 'any boat'. + matchedCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. + if (matchedCodeName > 1) // 0 and 1 are excluded + entity.setBoatType(types[matchedCodeName - 2]); // Removes 2 to fix the index. } @Override protected boolean match(ChestBoat entity) { - return matchedPattern <= 1 || entity.getBoatType().ordinal() == matchedPattern - 2; + return matchedCodeName <= 1 || entity.getBoatType().ordinal() == matchedCodeName - 2; } @Override @@ -85,25 +85,25 @@ public Class getType() { @Override public EntityData getSuperType() { - return new BoatChestData(matchedPattern); + return new BoatChestData(matchedCodeName); } @Override protected int hashCode_i() { - return matchedPattern <= 1 ? 0 : matchedPattern; + return matchedCodeName <= 1 ? 0 : matchedCodeName; } @Override protected boolean equals_i(EntityData obj) { if (obj instanceof BoatChestData boatChestData) - return matchedPattern == boatChestData.matchedPattern; + return matchedCodeName == boatChestData.matchedCodeName; return false; } @Override public boolean isSupertypeOf(EntityData entity) { if (entity instanceof BoatChestData boatChestData) - return matchedPattern <= 1 || matchedPattern == boatChestData.matchedPattern; + return matchedCodeName <= 1 || matchedCodeName == boatChestData.matchedCodeName; return false; } @@ -129,7 +129,7 @@ public boolean isOfItemType(ItemType itemType) { // material is a boat AND (data matches any boat OR material and data are same) if (type != null) { ordinal = type.ordinal(); - if (matchedPattern <= 1 || matchedPattern == ordinal + 2) + if (matchedCodeName <= 1 || matchedCodeName == ordinal + 2) return true; } } diff --git a/src/main/java/ch/njol/skript/entity/BoatData.java b/src/main/java/ch/njol/skript/entity/BoatData.java index e6c9535f2be..9025514b729 100644 --- a/src/main/java/ch/njol/skript/entity/BoatData.java +++ b/src/main/java/ch/njol/skript/entity/BoatData.java @@ -48,32 +48,32 @@ public BoatData(@Nullable Boat.Type type){ } private BoatData(int type) { - matchedPattern = type; + matchedCodeName = type; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { return true; } @Override protected boolean init(@Nullable Class clazz, @Nullable Boat entity) { if (entity != null) - matchedPattern = 2 + entity.getBoatType().ordinal(); + matchedCodeName = 2 + entity.getBoatType().ordinal(); return true; } @Override public void set(Boat entity) { - if (matchedPattern == 1) // If the type is 'any boat'. - matchedPattern += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. - if (matchedPattern > 1) // 0 and 1 are excluded - entity.setBoatType(types[matchedPattern - 2]); // Removes 2 to fix the index. + if (matchedCodeName == 1) // If the type is 'any boat'. + matchedCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. + if (matchedCodeName > 1) // 0 and 1 are excluded + entity.setBoatType(types[matchedCodeName - 2]); // Removes 2 to fix the index. } @Override protected boolean match(Boat entity) { - return matchedPattern <= 1 || entity.getBoatType().ordinal() == matchedPattern - 2; + return matchedCodeName <= 1 || entity.getBoatType().ordinal() == matchedCodeName - 2; } @Override @@ -83,25 +83,25 @@ public Class getType() { @Override public EntityData getSuperType() { - return new BoatData(matchedPattern); + return new BoatData(matchedCodeName); } @Override protected int hashCode_i() { - return matchedPattern <= 1 ? 0 : matchedPattern; + return matchedCodeName <= 1 ? 0 : matchedCodeName; } @Override protected boolean equals_i(EntityData obj) { if (obj instanceof BoatData boatData) - return matchedPattern == boatData.matchedPattern; + return matchedCodeName == boatData.matchedCodeName; return false; } @Override public boolean isSupertypeOf(EntityData entity) { if (entity instanceof BoatData boatData) - return matchedPattern <= 1 || matchedPattern == boatData.matchedPattern; + return matchedCodeName <= 1 || matchedCodeName == boatData.matchedCodeName; return false; } @@ -136,7 +136,7 @@ public boolean isOfItemType(ItemType itemType) { // material is a boat AND (data matches any boat OR material and data are same) if (type != null) { ordinal = type.ordinal(); - if (matchedPattern <= 1 || matchedPattern == ordinal + 2) + if (matchedCodeName <= 1 || matchedCodeName == ordinal + 2) return true; } } diff --git a/src/main/java/ch/njol/skript/entity/CatData.java b/src/main/java/ch/njol/skript/entity/CatData.java index aa186aeaf1e..85298cbb0af 100644 --- a/src/main/java/ch/njol/skript/entity/CatData.java +++ b/src/main/java/ch/njol/skript/entity/CatData.java @@ -21,14 +21,13 @@ public class CatData extends EntityData { } } - @SuppressWarnings("NotNullFieldNotInitialized") private static Cat.Type[] types; private Cat.@Nullable Type race = null; @SuppressWarnings("unchecked") @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs.length > 0 && exprs[0] != null) race = ((Literal) exprs[0]).getSingle(); return true; diff --git a/src/main/java/ch/njol/skript/entity/CreeperData.java b/src/main/java/ch/njol/skript/entity/CreeperData.java index 25aecb6d948..c20e9d3b1be 100644 --- a/src/main/java/ch/njol/skript/entity/CreeperData.java +++ b/src/main/java/ch/njol/skript/entity/CreeperData.java @@ -17,8 +17,8 @@ public class CreeperData extends EntityData { private int powered = 0; @Override - protected boolean init(final Literal[] exprs, final int matchedPattern, final ParseResult parseResult) { - powered = matchedPattern - 1; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + powered = matchedCodeName - 1; return true; } diff --git a/src/main/java/ch/njol/skript/entity/DroppedItemData.java b/src/main/java/ch/njol/skript/entity/DroppedItemData.java index fe160aba5e5..bfcc3585484 100644 --- a/src/main/java/ch/njol/skript/entity/DroppedItemData.java +++ b/src/main/java/ch/njol/skript/entity/DroppedItemData.java @@ -1,16 +1,6 @@ package ch.njol.skript.entity; -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Method; -import java.util.Arrays; -import java.util.function.Consumer; - import ch.njol.skript.Skript; -import org.bukkit.Location; -import org.bukkit.World; -import org.bukkit.entity.Item; -import org.bukkit.inventory.ItemStack; - import ch.njol.skript.aliases.ItemType; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; @@ -19,8 +9,17 @@ import ch.njol.skript.localization.Noun; import ch.njol.skript.registrations.Classes; import ch.njol.util.coll.CollectionUtils; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.entity.Item; +import org.bukkit.inventory.ItemStack; import org.jetbrains.annotations.Nullable; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Arrays; +import java.util.function.Consumer; + public class DroppedItemData extends EntityData { private static final boolean HAS_JAVA_CONSUMER_DROP = Skript.methodExists(World.class, "dropItem", Location.class, ItemStack.class, Consumer.class); @@ -45,9 +44,9 @@ public DroppedItemData(ItemType @Nullable [] types) { } @Override - protected boolean init(Literal[] expressions, int matchedPattern, ParseResult parseResult) { - if (expressions.length > 0 && expressions[0] != null) { - types = (ItemType[]) expressions[0].getAll(); + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (exprs.length > 0 && exprs[0] != null) { + types = (ItemType[]) exprs[0].getAll(); for (ItemType type : types) { if (!type.getMaterial().isItem()) { Skript.error("'" + type + "' cannot represent a dropped item"); diff --git a/src/main/java/ch/njol/skript/entity/EndermanData.java b/src/main/java/ch/njol/skript/entity/EndermanData.java index ffc91677062..d247a64b9ec 100644 --- a/src/main/java/ch/njol/skript/entity/EndermanData.java +++ b/src/main/java/ch/njol/skript/entity/EndermanData.java @@ -35,7 +35,7 @@ public EndermanData(@Nullable ItemType[] hand) { @SuppressWarnings("unchecked") @Override - protected boolean init(final Literal[] exprs, final int matchedPattern, final ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs[0] != null) hand = ((Literal) exprs[0]).getAll(); return true; diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 1d0ac0e8b6a..c9727a85525 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -8,14 +8,16 @@ import ch.njol.skript.classes.Serializer; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.MultiPatternedSyntaxInfo; import ch.njol.skript.lang.ParseContext; import ch.njol.skript.lang.SkriptParser; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.SyntaxElement; +import ch.njol.skript.lang.SyntaxElementInfo; import ch.njol.skript.lang.util.SimpleLiteral; import ch.njol.skript.localization.Adjective; +import ch.njol.skript.localization.Language; import ch.njol.skript.localization.Language.LanguageListenerPriority; +import ch.njol.skript.localization.LanguageChangeListener; import ch.njol.skript.localization.Message; import ch.njol.skript.localization.Noun; import ch.njol.skript.registrations.Classes; @@ -42,8 +44,10 @@ import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Arrays; +import java.util.HashMap; import java.util.Iterator; import java.util.List; +import java.util.Map; import java.util.function.Consumer; import java.util.stream.Collectors; @@ -185,7 +189,7 @@ public static void onRegistrationStop() { }); } - private final static class EntityDataInfo> extends MultiPatternedSyntaxInfo { + private final static class EntityDataInfo> extends SyntaxElementInfo implements LanguageChangeListener { final String codeName; final String[] codeNames; @@ -193,6 +197,10 @@ private final static class EntityDataInfo> extends Multi final @Nullable EntityType entityType; final Class entityClass; final Noun[] names; + private String[] patterns; + private final Map codeNamePlacements = new HashMap<>(); + private final Map matchedPatternToCodeName = new HashMap<>(); + private final Map matchedPatternToActualPattern = new HashMap<>(); public EntityDataInfo(Class dataClass, String codeName, String[] codeNames, int defaultName, Class entityClass) { this(dataClass, codeName, codeNames, defaultName, EntityUtils.toBukkitEntityType(entityClass), entityClass); @@ -206,7 +214,7 @@ public EntityDataInfo( @Nullable EntityType entityType, Class entityClass ) { - super(dataClass, codeNames, LANGUAGE_NODE, LanguageListenerPriority.LATEST); + super(new String[codeNames.length], dataClass, dataClass.getName()); assert codeName != null && entityClass != null && codeNames.length > 0; this.codeName = codeName; this.codeNames = codeNames; @@ -217,12 +225,72 @@ public EntityDataInfo( for (int i = 0; i < codeNames.length; i++) { assert codeNames[i] != null; names[i] = new Noun(LANGUAGE_NODE + "." + codeNames[i] + ".name"); + codeNamePlacements.put(codeNames[i], i); } + + Language.addListener(this, LanguageListenerPriority.LATEST); } @Override - public String patternChanger(String pattern) { - return pattern.replace("", m_age_pattern.toString()); + public void onLanguageChange() { + List allPatterns = new ArrayList<>(); + matchedPatternToCodeName.clear(); + matchedPatternToActualPattern.clear(); + for (String codeName : codeNames) { + if (Language.keyExistsDefault(LANGUAGE_NODE + "." + codeName + ".pattern")) { + String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".pattern") + .replace("", m_age_pattern.toString()); + matchedPatternToCodeName.put(allPatterns.size(), codeName); + matchedPatternToActualPattern.put(allPatterns.size(), 0); + allPatterns.add(pattern); + } + if (Language.keyExistsDefault(LANGUAGE_NODE + "." + codeName + ".patterns.0")) { + int multiCount = 0; + while (Language.keyExistsDefault(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount)) { + String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount) + .replace("", m_age_pattern.toString()); + // correlates '#init.matchedPattern' to 'codeName' + matchedPatternToCodeName.put(allPatterns.size(), codeName); + // correlates '#init.matchedPattern' to actual pattern + matchedPatternToActualPattern.put(allPatterns.size(), multiCount); + allPatterns.add(pattern); + multiCount++; + } + } + } + patterns = allPatterns.toArray(String[]::new); + } + + @Override + public String[] getPatterns() { + return Arrays.copyOf(patterns, patterns.length); + } + + /** + * Gets the {@code codeName} corresponding to the {@code matchedPattern} in {@link #init(Expression[], int, Kleenean, ParseResult)}. + * @param matchedPattern The placement of the pattern used. + * @return The corresponding {@code codeName}. + */ + public String getCodeNameFromPattern(int matchedPattern) { + return matchedPatternToCodeName.get(matchedPattern); + } + + /** + * Gets the corresponding placement of {@code codeName}. + * @param codeName The code name. + * @return The placement. + */ + public int getCodeNamePlacement(String codeName) { + return codeNamePlacements.get(codeName); + } + + /** + * Gets the actual matched pattern from {@code matchedPattern} in {@link #init(Expression[], int, Kleenean, ParseResult)}. + * @param matchedPattern The placement of the pattern used + * @return The actual placement. + */ + public int getActualMatchedPattern(int matchedPattern) { + return matchedPatternToActualPattern.get(matchedPattern); } @Override @@ -269,7 +337,7 @@ public static > void register( } transient EntityDataInfo info; - protected int matchedPattern = 0; + protected int matchedCodeName = 0; private Kleenean plural = Kleenean.UNKNOWN; private Kleenean baby = Kleenean.UNKNOWN; @@ -277,7 +345,7 @@ public EntityData() { for (EntityDataInfo info : infos) { if (getClass() == info.getElementClass()) { this.info = info; - matchedPattern = info.defaultName; + matchedCodeName = info.defaultName; return; } } @@ -286,13 +354,38 @@ public EntityData() { @Override public final boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { - this.matchedPattern = matchedPattern; this.plural = parseResult.hasTag("unknown_plural") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("plural")); this.baby = parseResult.hasTag("unknown_age") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("baby")); - return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedPattern, parseResult); + String codeName = info.getCodeNameFromPattern(matchedPattern); + int matchedCodeName = info.getCodeNamePlacement(codeName); + int actualPattern = info.getActualMatchedPattern(matchedPattern); + this.matchedCodeName = matchedCodeName; + return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedCodeName, actualPattern, parseResult); } - protected abstract boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult); + /** + * Initializes this {@link EntityData}. + *

+ * As of Skript INSERT VERSION, code names can have multiple patterns registered in the default.lang file. + * {@code matchedCodeName} will be the index of the code name the matched pattern is linked to. + * (e.g. {@link PigData} "unsaddled pig' = 0, "pig" = 1, "saddled pig" = 2) + * {@code matchedPattern} will be the index of the pattern used from the patterns of the code name in the lang file. + *

+ * + * @param exprs An arraay of {@link Literal} expressions from the matched pattern, in the order they appear. + * If an optional value was omitted by the user, it will still be present in the array + * with a value of {@code null}. + * @param matchedCodeName The index of the code name which matched. + * @param matchedPattern The index of the pattern of the code name which matched. + * @param parseResult Additional information from the parser. + * @return {@code true} if initialization was successful, otherwise {@code false}. + */ + protected abstract boolean init( + Literal[] exprs, + int matchedCodeName, + int matchedPattern, + ParseResult parseResult + ); /** * @param entityClass An entity's class, e.g. Player @@ -321,7 +414,7 @@ public final String toString() { @SuppressWarnings("null") protected Noun getName() { - return info.names[matchedPattern]; + return info.names[matchedCodeName]; } protected @Nullable Adjective getAgeAdjective() { @@ -330,7 +423,7 @@ protected Noun getName() { @SuppressWarnings("null") public String toString(int flags) { - Noun name = info.names[matchedPattern]; + Noun name = info.names[matchedCodeName]; return baby.isTrue() ? m_baby.toString(name, flags) : baby.isFalse() ? m_adult.toString(name, flags) : name.toString(flags); } @@ -350,7 +443,7 @@ public final int hashCode() { int result = 1; result = prime * result + baby.hashCode(); result = prime * result + plural.hashCode(); - result = prime * result + matchedPattern; + result = prime * result + matchedCodeName; result = prime * result + info.hashCode(); result = prime * result + hashCode_i(); return result; @@ -370,7 +463,7 @@ public final boolean equals(@Nullable Object obj) { return false; if (plural != other.plural) return false; - if (matchedPattern != other.matchedPattern) + if (matchedCodeName != other.matchedCodeName) return false; if (!info.equals(other.info)) return false; diff --git a/src/main/java/ch/njol/skript/entity/FallingBlockData.java b/src/main/java/ch/njol/skript/entity/FallingBlockData.java index e3856e6c1be..8c785f6749c 100644 --- a/src/main/java/ch/njol/skript/entity/FallingBlockData.java +++ b/src/main/java/ch/njol/skript/entity/FallingBlockData.java @@ -44,7 +44,7 @@ public FallingBlockData(@Nullable ItemType[] types) { @SuppressWarnings("unchecked") @Override - protected boolean init(final Literal[] exprs, final int matchedPattern, final ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs.length > 0 && exprs[0] != null) { if ((types = Converters.convert(((Literal) exprs[0]).getAll(), ItemType.class, new Converter() { @Override diff --git a/src/main/java/ch/njol/skript/entity/FoxData.java b/src/main/java/ch/njol/skript/entity/FoxData.java index ea2328b3dd4..50625ebe5a5 100644 --- a/src/main/java/ch/njol/skript/entity/FoxData.java +++ b/src/main/java/ch/njol/skript/entity/FoxData.java @@ -23,13 +23,13 @@ public FoxData() {} public FoxData(@Nullable Type type) { this.type = type; - super.matchedPattern = type == Type.SNOW ? 2 : 1; + super.matchedCodeName = type == Type.SNOW ? 2 : 1; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern > 0) - type = Type.values()[matchedPattern - 1]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName > 0) + type = Type.values()[matchedCodeName - 1]; return true; } diff --git a/src/main/java/ch/njol/skript/entity/FrogData.java b/src/main/java/ch/njol/skript/entity/FrogData.java index 7eb9ace9858..d2895b8cf34 100644 --- a/src/main/java/ch/njol/skript/entity/FrogData.java +++ b/src/main/java/ch/njol/skript/entity/FrogData.java @@ -2,7 +2,7 @@ import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser; +import ch.njol.skript.lang.SkriptParser.ParseResult; import org.bukkit.entity.Frog; import org.bukkit.entity.Frog.Variant; import org.jetbrains.annotations.Nullable; @@ -26,18 +26,18 @@ public FrogData() { public FrogData(@Nullable Variant variant) { this.variant = variant; - matchedPattern = 0; + matchedCodeName = 0; if (variant == Variant.TEMPERATE) - matchedPattern = 1; + matchedCodeName = 1; if (variant == Variant.WARM) - matchedPattern = 2; + matchedCodeName = 2; if (variant == Variant.COLD) - matchedPattern = 3; + matchedCodeName = 3; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, SkriptParser.ParseResult parseResult) { - switch (matchedPattern) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + switch (matchedCodeName) { case 1: variant = Variant.TEMPERATE; break; diff --git a/src/main/java/ch/njol/skript/entity/GoatData.java b/src/main/java/ch/njol/skript/entity/GoatData.java index 44140d40340..b3b08303ac1 100644 --- a/src/main/java/ch/njol/skript/entity/GoatData.java +++ b/src/main/java/ch/njol/skript/entity/GoatData.java @@ -23,27 +23,27 @@ public GoatData(int screaming) { } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - screaming = matchedPattern; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + screaming = matchedCodeName; return true; } @Override protected boolean init(@Nullable Class c, @Nullable Goat goat) { - if (goat != null && matchedPattern > 0) - goat.setScreaming(matchedPattern == 1); + if (goat != null && matchedCodeName > 0) + goat.setScreaming(matchedCodeName == 1); return true; } @Override public void set(Goat entity) { - if (matchedPattern > 0) + if (matchedCodeName > 0) entity.setScreaming(screaming == 1); } @Override protected boolean match(Goat entity) { - if (matchedPattern > 0) + if (matchedCodeName > 0) return entity.isScreaming() ? screaming == 1 : screaming == 2; return true; } diff --git a/src/main/java/ch/njol/skript/entity/LlamaData.java b/src/main/java/ch/njol/skript/entity/LlamaData.java index 85bdea2f2fb..fcd194ba2d5 100644 --- a/src/main/java/ch/njol/skript/entity/LlamaData.java +++ b/src/main/java/ch/njol/skript/entity/LlamaData.java @@ -33,16 +33,16 @@ public LlamaData() {} public LlamaData(@Nullable Color color, boolean isTrader) { this.color = color; this.isTrader = isTrader; - super.matchedPattern = (color != null ? (color.ordinal() + 1) : 0) + (isTrader ? 5 : 0); + super.matchedCodeName = (color != null ? (color.ordinal() + 1) : 0) + (isTrader ? 5 : 0); } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - isTrader = TRADER_SUPPORT && matchedPattern > 4; - if (TRADER_SUPPORT && matchedPattern > 5) { - color = Color.values()[matchedPattern - 6]; - } else if (matchedPattern > 0 && matchedPattern < 5) { - color = Color.values()[matchedPattern - 1]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + isTrader = TRADER_SUPPORT && matchedCodeName > 4; + if (TRADER_SUPPORT && matchedCodeName > 5) { + color = Color.values()[matchedCodeName - 6]; + } else if (matchedCodeName > 0 && matchedCodeName < 5) { + color = Color.values()[matchedCodeName - 1]; } return true; diff --git a/src/main/java/ch/njol/skript/entity/MinecartData.java b/src/main/java/ch/njol/skript/entity/MinecartData.java index 377c2a4be3b..2e3e0d4057e 100644 --- a/src/main/java/ch/njol/skript/entity/MinecartData.java +++ b/src/main/java/ch/njol/skript/entity/MinecartData.java @@ -1,7 +1,9 @@ package ch.njol.skript.entity; -import java.util.ArrayList; - +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Utils; +import ch.njol.skript.variables.Variables; import org.bukkit.entity.Minecart; import org.bukkit.entity.minecart.CommandMinecart; import org.bukkit.entity.minecart.ExplosiveMinecart; @@ -12,10 +14,7 @@ import org.bukkit.entity.minecart.StorageMinecart; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.skript.util.Utils; -import ch.njol.skript.variables.Variables; +import java.util.ArrayList; /** * @author Peter Güttinger @@ -70,13 +69,12 @@ public MinecartData() {} public MinecartData(final MinecartType type) { this.type = type; - this.matchedPattern = type.ordinal(); + this.matchedCodeName = type.ordinal(); } - - @SuppressWarnings("null") + @Override - protected boolean init(final Literal[] exprs, final int matchedPattern, final ParseResult parseResult) { - type = MinecartType.values()[matchedPattern]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + type = MinecartType.values()[matchedCodeName]; return true; } diff --git a/src/main/java/ch/njol/skript/entity/MooshroomData.java b/src/main/java/ch/njol/skript/entity/MooshroomData.java index 79d2958fdca..cff3f07eb09 100644 --- a/src/main/java/ch/njol/skript/entity/MooshroomData.java +++ b/src/main/java/ch/njol/skript/entity/MooshroomData.java @@ -24,13 +24,13 @@ public MooshroomData() {} public MooshroomData(@Nullable Variant variant) { this.variant = variant; - super.matchedPattern = variant == Variant.BROWN ? 2 : 1; + super.matchedCodeName = variant == Variant.BROWN ? 2 : 1; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern > 0) - variant = Variant.values()[matchedPattern - 1]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName > 0) + variant = Variant.values()[matchedCodeName - 1]; return true; } diff --git a/src/main/java/ch/njol/skript/entity/OcelotData.java b/src/main/java/ch/njol/skript/entity/OcelotData.java index c845fefffcb..fc5741f77ab 100644 --- a/src/main/java/ch/njol/skript/entity/OcelotData.java +++ b/src/main/java/ch/njol/skript/entity/OcelotData.java @@ -26,8 +26,8 @@ public class OcelotData extends EntityData { int tamed = 0; @Override - protected boolean init(final Literal[] exprs, final int matchedPattern, final ParseResult parseResult) { - tamed = TAMEABLE ? matchedPattern - 1 : 0; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + tamed = TAMEABLE ? matchedCodeName - 1 : 0; return true; } diff --git a/src/main/java/ch/njol/skript/entity/PandaData.java b/src/main/java/ch/njol/skript/entity/PandaData.java index bc704b045ce..bc39af6278b 100644 --- a/src/main/java/ch/njol/skript/entity/PandaData.java +++ b/src/main/java/ch/njol/skript/entity/PandaData.java @@ -29,7 +29,7 @@ public PandaData(@Nullable Gene mainGene, @Nullable Gene hiddenGene) { } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs[0] != null) mainGene = (Gene) exprs[0].getSingle(); if (exprs[1] != null) diff --git a/src/main/java/ch/njol/skript/entity/ParrotData.java b/src/main/java/ch/njol/skript/entity/ParrotData.java index 7a151c2512f..bba337b9f54 100644 --- a/src/main/java/ch/njol/skript/entity/ParrotData.java +++ b/src/main/java/ch/njol/skript/entity/ParrotData.java @@ -1,14 +1,13 @@ package ch.njol.skript.entity; -import java.util.concurrent.ThreadLocalRandom; - +import ch.njol.skript.Skript; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; import org.bukkit.entity.Parrot; import org.bukkit.entity.Parrot.Variant; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.Skript; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; +import java.util.concurrent.ThreadLocalRandom; public class ParrotData extends EntityData { @@ -34,15 +33,15 @@ public ParrotData() {} public ParrotData(int variant) { this.variant = variant; - super.matchedPattern = variant + 1; + super.matchedCodeName = variant + 1; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern == 0) { // Just a parrot, variant -1 to request random variant on spawn + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName == 0) { // Just a parrot, variant -1 to request random variant on spawn variant = -1; } else { // Specific variant was given - variant = matchedPattern - 1; // Patterns begin from 1, enum elements from 0 + variant = matchedCodeName - 1; // Patterns begin from 1, enum elements from 0 } return true; } diff --git a/src/main/java/ch/njol/skript/entity/PigData.java b/src/main/java/ch/njol/skript/entity/PigData.java index ffb710fc2be..a2a85721a2f 100644 --- a/src/main/java/ch/njol/skript/entity/PigData.java +++ b/src/main/java/ch/njol/skript/entity/PigData.java @@ -41,8 +41,8 @@ public PigData(SaddleState saddled, @Nullable Object variant) { } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - saddled = SADDLE_STATES[matchedPattern]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + saddled = SADDLE_STATES[matchedCodeName]; if (exprs[0] != null && variantsEnabled) //noinspection unchecked variant = ((Literal) exprs[0]).getSingle(); diff --git a/src/main/java/ch/njol/skript/entity/RabbitData.java b/src/main/java/ch/njol/skript/entity/RabbitData.java index 3db721d73cf..d91d9806e13 100644 --- a/src/main/java/ch/njol/skript/entity/RabbitData.java +++ b/src/main/java/ch/njol/skript/entity/RabbitData.java @@ -22,12 +22,12 @@ public RabbitData() {} public RabbitData(int type) { this.type = type; - super.matchedPattern = type; + super.matchedCodeName = type; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - type = matchedPattern; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + type = matchedCodeName; return true; } diff --git a/src/main/java/ch/njol/skript/entity/SalmonData.java b/src/main/java/ch/njol/skript/entity/SalmonData.java index 0151f31556e..4845960f977 100644 --- a/src/main/java/ch/njol/skript/entity/SalmonData.java +++ b/src/main/java/ch/njol/skript/entity/SalmonData.java @@ -34,9 +34,9 @@ public class SalmonData extends EntityData { private @Nullable Object variant; @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern > 1) - variant = variants[matchedPattern - 2]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName > 1) + variant = variants[matchedCodeName - 2]; return true; } @@ -57,7 +57,7 @@ public void set(Salmon entity) { @Override protected boolean match(Salmon entity) { - return matchedPattern <= 1 || variant == entity.getVariant(); + return matchedCodeName <= 1 || variant == entity.getVariant(); } @Override @@ -72,14 +72,14 @@ public EntityData getSuperType() { @Override protected int hashCode_i() { - return matchedPattern <= 1 ? 0 : matchedPattern; + return matchedCodeName <= 1 ? 0 : matchedCodeName; } @Override protected boolean equals_i(EntityData obj) { if (!(obj instanceof SalmonData salmonData)) return false; - if (matchedPattern > 1 && variant != salmonData.variant) + if (matchedCodeName > 1 && variant != salmonData.variant) return false; return true; } @@ -87,7 +87,7 @@ protected boolean equals_i(EntityData obj) { @Override public boolean isSupertypeOf(EntityData entity) { if (entity instanceof SalmonData salmonData) - return matchedPattern <= 1 || variant == salmonData.variant; + return matchedCodeName <= 1 || variant == salmonData.variant; return false; } diff --git a/src/main/java/ch/njol/skript/entity/SheepData.java b/src/main/java/ch/njol/skript/entity/SheepData.java index 26e6e351204..aa9503984db 100644 --- a/src/main/java/ch/njol/skript/entity/SheepData.java +++ b/src/main/java/ch/njol/skript/entity/SheepData.java @@ -1,10 +1,5 @@ package ch.njol.skript.entity; -import java.util.Arrays; - -import org.bukkit.entity.Sheep; -import org.jetbrains.annotations.Nullable; - import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.util.SimpleExpression; @@ -14,6 +9,10 @@ import ch.njol.skript.util.Color; import ch.njol.skript.util.SkriptColor; import ch.njol.util.coll.CollectionUtils; +import org.bukkit.entity.Sheep; +import org.jetbrains.annotations.Nullable; + +import java.util.Arrays; /** * @author Peter Güttinger @@ -29,8 +28,8 @@ public class SheepData extends EntityData { @SuppressWarnings("unchecked") @Override - protected boolean init(final Literal[] exprs, final int matchedPattern, final ParseResult parseResult) { - sheared = matchedPattern - 1; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + sheared = matchedCodeName - 1; if (exprs[0] != null) colors = ((Literal) exprs[0]).getAll(); return true; diff --git a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java index 0fbb0ee4605..ee1087885b3 100644 --- a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java +++ b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java @@ -274,7 +274,7 @@ public SimpleEntityData() { private SimpleEntityData(SimpleEntityDataInfo info) { assert info != null; this.info = info; - matchedPattern = types.indexOf(info); + matchedCodeName = types.indexOf(info); } public SimpleEntityData(Class entityClass) { @@ -293,7 +293,7 @@ public SimpleEntityData(Class entityClass) { } if (closestInfo != null) { this.info = closestInfo; - this.matchedPattern = closestPattern; + this.matchedCodeName = closestPattern; return; } throw new IllegalStateException(); @@ -314,16 +314,16 @@ public SimpleEntityData(Entity entity) { } if (closestInfo != null) { this.info = closestInfo; - this.matchedPattern = closestPattern; + this.matchedCodeName = closestPattern; return; } throw new IllegalStateException(); } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - info = types.get(matchedPattern); - assert info != null : matchedPattern; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + info = types.get(matchedCodeName); + assert info != null : matchedCodeName; return true; } diff --git a/src/main/java/ch/njol/skript/entity/StriderData.java b/src/main/java/ch/njol/skript/entity/StriderData.java index 89319a37e2d..72377a328ae 100644 --- a/src/main/java/ch/njol/skript/entity/StriderData.java +++ b/src/main/java/ch/njol/skript/entity/StriderData.java @@ -24,8 +24,8 @@ public StriderData(Kleenean shivering) { } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - shivering = Kleenean.get(matchedPattern - 1); + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + shivering = Kleenean.get(matchedCodeName - 1); return true; } diff --git a/src/main/java/ch/njol/skript/entity/ThrownPotionData.java b/src/main/java/ch/njol/skript/entity/ThrownPotionData.java index 93de408b2da..51c28974839 100644 --- a/src/main/java/ch/njol/skript/entity/ThrownPotionData.java +++ b/src/main/java/ch/njol/skript/entity/ThrownPotionData.java @@ -1,18 +1,6 @@ package ch.njol.skript.entity; -import java.util.Arrays; -import java.util.function.Consumer; - -import org.bukkit.Location; -import org.bukkit.Material; -import org.bukkit.entity.LingeringPotion; -import org.bukkit.entity.ThrownPotion; -import org.bukkit.inventory.ItemStack; -import org.bukkit.inventory.meta.ItemMeta; -import org.jetbrains.annotations.Nullable; - import ch.njol.skript.Skript; -import ch.njol.skript.aliases.Aliases; import ch.njol.skript.aliases.ItemType; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; @@ -20,8 +8,18 @@ import ch.njol.skript.localization.Language; import ch.njol.skript.localization.Noun; import ch.njol.skript.registrations.Classes; -import org.skriptlang.skript.lang.converter.Converters; import ch.njol.util.coll.CollectionUtils; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.entity.LingeringPotion; +import org.bukkit.entity.ThrownPotion; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.lang.converter.Converters; + +import java.util.Arrays; +import java.util.function.Consumer; public class ThrownPotionData extends EntityData { static { @@ -42,7 +40,7 @@ public class ThrownPotionData extends EntityData { private ItemType[] types; @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs.length > 0 && exprs[0] != null) { return (types = Converters.convert((ItemType[]) exprs[0].getAll(), ItemType.class, t -> { // If the itemtype is a potion, lets make it a splash potion (required by Bukkit) diff --git a/src/main/java/ch/njol/skript/entity/TropicalFishData.java b/src/main/java/ch/njol/skript/entity/TropicalFishData.java index 9723901fbde..78010481c28 100644 --- a/src/main/java/ch/njol/skript/entity/TropicalFishData.java +++ b/src/main/java/ch/njol/skript/entity/TropicalFishData.java @@ -27,34 +27,34 @@ public TropicalFishData() { } public TropicalFishData(Pattern pattern) { - matchedPattern = pattern.ordinal(); + matchedCodeName = pattern.ordinal(); } private TropicalFishData(int pattern) { - matchedPattern = pattern; + matchedCodeName = pattern; } private @Nullable DyeColor patternColor; private @Nullable DyeColor bodyColor; @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs.length == 0) return true; // FIXME aliases reloading must work - - if (exprs[2] != null) { - //noinspection unchecked - bodyColor = ((Literal) exprs[2]).getSingle().asDyeColor(); - patternColor = bodyColor; - } - if (exprs[0] != null) { + if (matchedPattern == 0) { + if (exprs[0] != null) { + //noinspection unchecked + bodyColor = ((Literal) exprs[0]).getSingle().asDyeColor(); + } + if (exprs[1] != null) { + //noinspection unchecked + patternColor = ((Literal) exprs[1]).getSingle().asDyeColor(); + } + } else if (exprs[0] != null) { //noinspection unchecked bodyColor = ((Literal) exprs[0]).getSingle().asDyeColor(); - } - if (exprs[1] != null) { - //noinspection unchecked - patternColor = ((Literal) exprs[1]).getSingle().asDyeColor(); + patternColor = bodyColor; } return true; @@ -63,7 +63,7 @@ protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parse @Override protected boolean init(@Nullable Class entityClass, @Nullable TropicalFish tropicalFish) { if (tropicalFish != null) { - matchedPattern = tropicalFish.getPattern().ordinal(); + matchedCodeName = tropicalFish.getPattern().ordinal(); bodyColor = tropicalFish.getBodyColor(); patternColor = tropicalFish.getPatternColor(); } @@ -72,10 +72,10 @@ protected boolean init(@Nullable Class entityClass, @Nul @Override public void set(TropicalFish tropicalFish) { - if (matchedPattern == patterns.length) { + if (matchedCodeName == patterns.length) { tropicalFish.setPattern(patterns[ThreadLocalRandom.current().nextInt(patterns.length)]); } else { - tropicalFish.setPattern(patterns[matchedPattern]); + tropicalFish.setPattern(patterns[matchedCodeName]); } if (bodyColor != null) @@ -86,7 +86,7 @@ public void set(TropicalFish tropicalFish) { @Override protected boolean match(TropicalFish tropicalFish) { - boolean samePattern = matchedPattern == patterns.length || matchedPattern == tropicalFish.getPattern().ordinal(); + boolean samePattern = matchedCodeName == patterns.length || matchedCodeName == tropicalFish.getPattern().ordinal(); boolean sameBody = bodyColor == null || bodyColor == tropicalFish.getBodyColor(); if (patternColor == null) { @@ -106,13 +106,13 @@ protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof TropicalFishData fishData)) return false; - return matchedPattern == fishData.matchedPattern + return matchedCodeName == fishData.matchedCodeName && bodyColor == fishData.bodyColor && patternColor == fishData.patternColor; } @Override protected int hashCode_i() { - return Objects.hash(matchedPattern, bodyColor, patternColor); + return Objects.hash(matchedCodeName, bodyColor, patternColor); } @Override @@ -120,13 +120,13 @@ public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof TropicalFishData fishData)) return false; - return matchedPattern == fishData.matchedPattern + return matchedCodeName == fishData.matchedCodeName && bodyColor == fishData.bodyColor && patternColor == fishData.patternColor; } @Override public EntityData getSuperType() { - return new TropicalFishData(matchedPattern); + return new TropicalFishData(matchedCodeName); } } diff --git a/src/main/java/ch/njol/skript/entity/VillagerData.java b/src/main/java/ch/njol/skript/entity/VillagerData.java index 1541179e2b0..e601852878f 100644 --- a/src/main/java/ch/njol/skript/entity/VillagerData.java +++ b/src/main/java/ch/njol/skript/entity/VillagerData.java @@ -39,13 +39,13 @@ public VillagerData() {} public VillagerData(@Nullable Profession profession) { this.profession = profession; - this.matchedPattern = profession != null ? professions.indexOf(profession) + 1 : 0; + this.matchedCodeName = profession != null ? professions.indexOf(profession) + 1 : 0; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern > 0) - profession = professions.get(matchedPattern - 1); + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName > 0) + profession = professions.get(matchedCodeName - 1); return true; } diff --git a/src/main/java/ch/njol/skript/entity/WolfData.java b/src/main/java/ch/njol/skript/entity/WolfData.java index 6875ee8a113..987acc8795d 100644 --- a/src/main/java/ch/njol/skript/entity/WolfData.java +++ b/src/main/java/ch/njol/skript/entity/WolfData.java @@ -1,18 +1,16 @@ package ch.njol.skript.entity; -import ch.njol.skript.bukkitutil.BukkitUtils; +import ch.njol.skript.Skript; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.registrations.Classes; +import ch.njol.skript.util.Color; import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; import org.bukkit.DyeColor; import org.bukkit.entity.Wolf; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.Skript; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.skript.util.Color; - import java.util.Objects; public class WolfData extends EntityData { @@ -40,11 +38,12 @@ public class WolfData extends EntityData { @SuppressWarnings("unchecked") @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern <= 2) - angry = matchedPattern - 1; - else - tamed = matchedPattern == 3 ? -1 : 1; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName <= 2) { + angry = matchedCodeName - 1; + } else { + tamed = matchedCodeName == 3 ? -1 : 1; + } if (exprs[0] != null && variantsEnabled) variant = ((Literal) exprs[0]).getSingle(); if (exprs[1] != null) diff --git a/src/main/java/ch/njol/skript/entity/XpOrbData.java b/src/main/java/ch/njol/skript/entity/XpOrbData.java index c2e80e7b5ba..edd0b6c5d7f 100644 --- a/src/main/java/ch/njol/skript/entity/XpOrbData.java +++ b/src/main/java/ch/njol/skript/entity/XpOrbData.java @@ -24,7 +24,7 @@ public XpOrbData(final int xp) { } @Override - protected boolean init(final Literal[] exprs, final int matchedPattern, final ParseResult parseResult) { + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { return true; } diff --git a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java index 55d46533ac0..a7c3abef1b7 100644 --- a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java +++ b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java @@ -33,13 +33,13 @@ public ZombieVillagerData() {} public ZombieVillagerData(@Nullable Profession profession) { this.profession = profession; - super.matchedPattern = profession != null ? professions.indexOf(profession) + 1 : 0; + super.matchedCodeName = profession != null ? professions.indexOf(profession) + 1 : 0; } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (matchedPattern > 0) - profession = professions.get(matchedPattern - 1); + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (matchedCodeName > 0) + profession = professions.get(matchedCodeName - 1); return true; } diff --git a/src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java b/src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java deleted file mode 100644 index 412c7e1537e..00000000000 --- a/src/main/java/ch/njol/skript/lang/MultiPatternedSyntaxInfo.java +++ /dev/null @@ -1,143 +0,0 @@ -package ch.njol.skript.lang; - -import ch.njol.skript.localization.Language; -import ch.njol.skript.localization.Language.LanguageListenerPriority; -import ch.njol.skript.localization.LanguageChangeListener; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -/** - * A typed {@link SyntaxElementInfo} used to allow multi-lined patterns in the lang file and still reference the actual matched pattern - */ -public abstract class MultiPatternedSyntaxInfo extends SyntaxElementInfo implements LanguageChangeListener { - - private final Class dataClass; - private final String[] codeNames; - private final String languageNode; - private String[] patterns; - private final Map codeNamePlacements = new HashMap<>(); - private final Map multiPatternCorrelation = new HashMap<>(); - - /** - * Creates a new {@link MultiPatternedSyntaxInfo} that handles {@link #onLanguageChange()} and grabbing/indexing patterns. - * Defaults to {@link LanguageListenerPriority#NORMAL} priority. - * @param dataClass The {@link SyntaxElement} class - * @param codeNames The codeNames to look for in the lang file - * @param languageNode The language node to look inside in the lang file - */ - public MultiPatternedSyntaxInfo( - Class dataClass, - String[] codeNames, - String languageNode - ) { - this(dataClass, codeNames, languageNode, LanguageListenerPriority.NORMAL); - } - - /** - * Creates a new {@link MultiPatternedSyntaxInfo} that handles {@link #onLanguageChange()} and grabbing/indexing patterns. - * @param dataClass The {@link SyntaxElement} class - * @param codeNames The codeNames to look for in the lang file - * @param languageNode The language node to look inside in the lang file - * @param priority The priority for registering a new language listener - */ - public MultiPatternedSyntaxInfo( - Class dataClass, - String[] codeNames, - String languageNode, - LanguageListenerPriority priority - ) { - super(new String[codeNames.length], dataClass, dataClass.getName()); - this.dataClass = dataClass; - this.codeNames = codeNames; - this.languageNode = languageNode; - - for (int i = 0; i < codeNames.length; i++) { - codeNamePlacements.put(codeNames[i], i); - } - - Language.addListener(this, priority); - } - - @Override - public void onLanguageChange() { - List allPatterns = new ArrayList<>(); - for (String codeName : codeNames) { - if (Language.keyExistsDefault(languageNode + "." + codeName + ".pattern")) { - String pattern = patternChanger(Language.get(languageNode + "." + codeName + ".pattern")); - multiPatternCorrelation.put(pattern, codeName); - allPatterns.add(pattern); - } - if (Language.keyExistsDefault(languageNode + "." + codeName + ".patterns.0")) { - int multiCount = 0; - while (Language.keyExistsDefault(languageNode + "." + codeName + ".patterns." + multiCount)) { - String pattern = patternChanger(Language.get(languageNode + "." + codeName + ".patterns." + multiCount)); - multiCount++; - multiPatternCorrelation.put(pattern, codeName); - allPatterns.add(pattern); - } - } - } - patterns = allPatterns.toArray(String[]::new); - } - - /** - * Make any changes to the pattern when being grabbed from the lang file. - * @param pattern The grabbed pattern from the lang file. - * @return The new pattern. - */ - public String patternChanger(String pattern) { - return pattern; - } - - /** - * Returns the {@link SyntaxElement} class used for this {@link MultiPatternedSyntaxInfo}. - */ - public Class getDataClass() { - return dataClass; - } - - /** - * Returns the code names to look for in the lang file. - */ - public String[] getCodeNames() { - return Arrays.copyOf(codeNames, codeNames.length); - } - - /** - * Returns all patterns grabbed using {@link #languageNode} and {@link #codeNames}. - */ - @Override - public String[] getPatterns() { - return Arrays.copyOf(patterns, patterns.length); - } - - /** - * Returns the language node to look inside in the lang file. - */ - public String getLanguageNode() { - return languageNode; - } - - /** - * Uses the given {@code pattern} to grab the actual pattern index. - * @param pattern The pattern used. - * @return The actual pattern number. - */ - public int getPatternIndex(String pattern) { - return codeNamePlacements.get(multiPatternCorrelation.get(pattern)); - } - - @Override - public boolean equals(Object obj) { - if (!(obj instanceof MultiPatternedSyntaxInfo other)) - return false; - return dataClass == other.dataClass - && languageNode.equals(other.languageNode) - && Arrays.equals(codeNames, other.codeNames); - } - -} diff --git a/src/main/java/ch/njol/skript/lang/SkriptParser.java b/src/main/java/ch/njol/skript/lang/SkriptParser.java index 2cfe127ac9c..387983b5d69 100644 --- a/src/main/java/ch/njol/skript/lang/SkriptParser.java +++ b/src/main/java/ch/njol/skript/lang/SkriptParser.java @@ -243,10 +243,7 @@ public boolean hasTag(String tag) { if (!checkExperimentalSyntax(element)) continue; - int actualPatternIndex = patternIndex; - if (info instanceof MultiPatternedSyntaxInfo multiInfo) - actualPatternIndex = multiInfo.getPatternIndex(pattern); - boolean success = element.preInit() && element.init(parseResult.exprs, actualPatternIndex, getParser().getHasDelayBefore(), parseResult); + boolean success = element.preInit() && element.init(parseResult.exprs, patternIndex, getParser().getHasDelayBefore(), parseResult); if (success) { log.printLog(); return element; diff --git a/src/main/java/ch/njol/skript/localization/Language.java b/src/main/java/ch/njol/skript/localization/Language.java index 34bbd22e5d7..df33b15fdbc 100644 --- a/src/main/java/ch/njol/skript/localization/Language.java +++ b/src/main/java/ch/njol/skript/localization/Language.java @@ -2,8 +2,6 @@ import ch.njol.skript.Skript; import ch.njol.skript.config.Config; -import ch.njol.skript.config.EntryNode; -import ch.njol.skript.config.Node; import ch.njol.skript.util.ExceptionUtils; import ch.njol.skript.util.FileUtils; import ch.njol.skript.util.Version; @@ -43,9 +41,10 @@ public class Language { */ private static String name = "english"; - private static final Map defaultLanguage = new HashMap<>(); + private static final HashMap defaultLanguage = new HashMap<>(); - private static @Nullable Map localizedLanguage = null; + @Nullable + private static HashMap localizedLanguage = null; private static final HashMap langVersion = new HashMap<>(); @@ -53,22 +52,14 @@ public static String getName() { return name; } - private static @Nullable String getEntryNodeValue(Map map, String key) { - if (!map.containsKey(key)) - return null; - Node node = map.get(key); - if (node instanceof EntryNode entryNode) - return entryNode.getValue(); - return null; - } - - private static @Nullable String get_i(String key) { + @Nullable + private static String get_i(String key) { String value; - if ((value = getEntryNodeValue(defaultLanguage, key)) != null) { + if ((value = defaultLanguage.get(key)) != null) { return value; } - if (localizedLanguage != null && (value = getEntryNodeValue(localizedLanguage, key)) != null) { + if (localizedLanguage != null && (value = localizedLanguage.get(key)) != null) { return value; } @@ -77,15 +68,6 @@ public static String getName() { return null; } - private static @Nullable Node getNode_i(String key) { - if (defaultLanguage.containsKey(key)) { - return defaultLanguage.get(key); - } else if (localizedLanguage != null && localizedLanguage.containsKey(key)) { - return localizedLanguage.get(key); - } - return null; - } - /** * Gets a string from the language file with the given key, or the key itself if the key does * not exist. @@ -104,14 +86,11 @@ public static String get(String key) { * @param key The message's key (case-insensitive) * @return The requested message or null if it doesn't exist */ - public static @Nullable String get_(String key) { + @Nullable + public static String get_(String key) { return get_i("" + key.toLowerCase(Locale.ENGLISH)); } - public static @Nullable Node getNode(String key) { - return getNode_i(key); - } - public static void missingEntryError(String key) { Skript.error("Missing entry '" + key.toLowerCase(Locale.ENGLISH) + "' in the default/english language file"); } @@ -231,10 +210,10 @@ public static void loadDefault(SkriptAddon addon) { } } - Map def = load(defaultLangIs, "default", false); - Map en = load(englishLangIs, "english", addon instanceof org.skriptlang.skript.Skript); + Map def = load(defaultLangIs, "default", false); + Map en = load(englishLangIs, "english", addon instanceof org.skriptlang.skript.Skript); - String v = ((EntryNode) def.get("version")).getValue(); + String v = def.get("version"); if (v == null) Skript.warning("Missing version in default.lang"); @@ -298,7 +277,7 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { } } - Map l; + Map l; try (InputStream is = source.getResourceAsStream("/" + languageFileDirectory + "/" + name + ".lang")) { l = load(is, name, tryUpdate); } catch (IOException e) { @@ -322,7 +301,7 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { Skript.error(addon + "'s language file " + name + ".lang does not provide a version number!"); } else { try { - Version v = new Version("" + getEntryNodeValue(l, "version")); + Version v = new Version("" + l.get("version")); Version lv = langVersion.get(addon.name()); assert lv != null; // set in loadDefault() if (v.isSmallerThan(lv)) @@ -333,14 +312,14 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { } l.remove("version"); if (localizedLanguage != null) { - for (Map.Entry entry : l.entrySet()) { + for (Map.Entry entry : l.entrySet()) { String key = entry.getKey(); - Node node = entry.getValue(); + String value = entry.getValue(); if (defaultLanguage.containsKey(key)) { Skript.warning("'" + key + "' is part of the default language file, " + "and can therefore not be modified in a localized language file."); } else { - localizedLanguage.put(key, node); + localizedLanguage.put(key, value); } } } else { @@ -349,7 +328,7 @@ private static boolean load(SkriptAddon addon, String name, boolean tryUpdate) { return true; } - private static Map load(@Nullable InputStream in, String name, boolean tryUpdate) { + private static Map load(@Nullable InputStream in, String name, boolean tryUpdate) { if (in == null) return new HashMap<>(); @@ -381,7 +360,7 @@ private static Map load(@Nullable InputStream in, String name, boo } } - return langConfig.toKeyNodeMap("."); + return langConfig.toMap("."); } catch (IOException e) { //noinspection ThrowableNotThrown Skript.exception(e, "Could not load the language file '" + name + ".lang': " + ExceptionUtils.toString(e)); diff --git a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java index f5b30c75443..7782ae54d8f 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java +++ b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java @@ -80,13 +80,13 @@ public DisplayData() {} public DisplayData(DisplayType type) { this.type = type; - this.matchedPattern = type.ordinal(); + this.matchedCodeName = type.ordinal(); } @Override @SuppressWarnings("unchecked") - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - type = DisplayType.values()[matchedPattern]; + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + type = DisplayType.values()[matchedCodeName]; // default to 0, use 1 for alternate pattern: %x% display instead of display of %x% if (exprs.length == 0 || exprs[0] == null) return true; diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index 234041ae071..a01d12a7c6f 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -605,43 +605,69 @@ entities: pattern: fish[plural:es] tropical fish: name: tropical fish¦es - pattern: [(%-color%[-%-color%]|fully %-color%)] tropical fish[plural:es] + patterns: + 0: [%-color%[-%-color%]] tropical fish[plural:es] + 1: fully %-color% tropical fish[plural:es] kob: name: kob¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] kob[plural:s] + patterns: + 0: [%-color%[-%-color%]] kob[plural:s] + 1: fully %-color% kob[plural:s] sunstreak: name: sunstreak¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] sunstreak[plural:s] + patterns: + 0: [%-color%[-%-color%]] sunstreak[plural:s] + 1: fully %-color% sunstreak[plural:s] snooper: name: snooper¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] snooper[plural:s] + patterns: + 0: [%-color%[-%-color%]] snooper[plural:s] + 1: fully %-color% snooper[plural:s] dasher: name: dasher¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] dasher[plural:s] + patterns: + 0: [%-color%[-%-color%]] dasher[plural:s] + 1: fully %-color% dasher[plural:s] brinely: name: brinely¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] brinely[plural:s] + patterns: + 0: [%-color%[-%-color%]] brinely[plural:s] + 1: fully %-color% brinely[plural:s] spotty: name: spotty¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] spotty[plural:s] + patterns: + 0: [%-color%[-%-color%]] spotty[plural:s] + 1: fully %-color% spotty[plural:s] flopper: name: flopper¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] flopper[plural:s] + patterns: + 0: [%-color%[-%-color%]] flopper[plural:s] + 1: fully %-color% flopper[plural:s] stripey: name: stripey¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] stripey[plural:s] + patterns: + 0: [%-color%[-%-color%]] stripey[plural:s] + 1: fully %-color% stripey[plural:s] glitter: name: glitter¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] glitter[plural:s] + patterns: + 0: [%-color%[-%-color%]] glitter[plural:s] + 1: fully %-color% glitter[plural:s] blockfish: name: blockfish¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] blockfish[plural:s] + patterns: + 0: [%-color%[-%-color%]] blockfish[plural:[e]s] + 1: fully %-color% blockfish[plural:[e]s] betty: name: betty¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] betty[plural:s] + patterns: + 0: [%-color%[-%-color%]] betty[plural:s] + 1: fully %-color% betty[plural:s] clayfish: name: clayfish¦s - pattern: [(%-color%[-%-color%]|fully %-color%)] clayfish[plural:s] + patterns: + 0: [%-color%[-%-color%]] clayfish[plural:[e]s] + 1: fully %-color% clayfish[plural:[e]s] ghast: name: ghast¦s pattern: ghast[plural:s] From 4a256d9a4ba5d7d205737bbe8f84139ee7f8bd4e Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Mon, 30 Jun 2025 20:42:02 -0400 Subject: [PATCH 08/21] Overhaul --- .../ch/njol/skript/entity/AxolotlData.java | 64 +++--- .../java/ch/njol/skript/entity/BeeData.java | 60 +++--- .../ch/njol/skript/entity/BoatChestData.java | 43 ++-- .../java/ch/njol/skript/entity/BoatData.java | 43 ++-- .../java/ch/njol/skript/entity/CatData.java | 66 +++--- .../ch/njol/skript/entity/ChickenData.java | 37 ++-- .../java/ch/njol/skript/entity/CowData.java | 47 ++--- .../ch/njol/skript/entity/CreeperData.java | 91 ++++---- .../njol/skript/entity/DroppedItemData.java | 84 ++++---- .../ch/njol/skript/entity/EndermanData.java | 104 +++------- .../ch/njol/skript/entity/EntityData.java | 25 +-- .../ch/njol/skript/entity/EntityPatterns.java | 71 +++++++ .../njol/skript/entity/FallingBlockData.java | 196 ++++++++---------- .../java/ch/njol/skript/entity/FoxData.java | 66 +++--- .../java/ch/njol/skript/entity/FrogData.java | 76 +++---- .../java/ch/njol/skript/entity/GoatData.java | 63 +++--- .../java/ch/njol/skript/entity/LlamaData.java | 61 +++--- .../ch/njol/skript/entity/MinecartData.java | 58 ++---- .../ch/njol/skript/entity/MooshroomData.java | 69 +++--- .../ch/njol/skript/entity/OcelotData.java | 95 --------- .../java/ch/njol/skript/entity/PandaData.java | 79 ++++--- .../ch/njol/skript/entity/ParrotData.java | 104 ++++------ .../java/ch/njol/skript/entity/PigData.java | 51 ++--- .../ch/njol/skript/entity/RabbitData.java | 125 ++++------- .../ch/njol/skript/entity/SalmonData.java | 81 +++++--- .../java/ch/njol/skript/entity/SheepData.java | 193 ++++++++--------- .../njol/skript/entity/SimpleEntityData.java | 188 ++++++++--------- .../ch/njol/skript/entity/StriderData.java | 61 +++--- .../njol/skript/entity/ThrownPotionData.java | 189 ++++++++--------- .../njol/skript/entity/TropicalFishData.java | 107 +++++----- .../ch/njol/skript/entity/VillagerData.java | 94 ++++----- .../java/ch/njol/skript/entity/WolfData.java | 63 +++--- .../java/ch/njol/skript/entity/XpOrbData.java | 118 +++++------ .../skript/entity/ZombieVillagerData.java | 93 ++++----- .../skript/bukkit/displays/DisplayData.java | 6 +- src/main/resources/lang/default.lang | 10 +- 36 files changed, 1411 insertions(+), 1570 deletions(-) create mode 100644 src/main/java/ch/njol/skript/entity/EntityPatterns.java delete mode 100644 src/main/java/ch/njol/skript/entity/OcelotData.java diff --git a/src/main/java/ch/njol/skript/entity/AxolotlData.java b/src/main/java/ch/njol/skript/entity/AxolotlData.java index 5e7c021400e..dc5319088e8 100644 --- a/src/main/java/ch/njol/skript/entity/AxolotlData.java +++ b/src/main/java/ch/njol/skript/entity/AxolotlData.java @@ -1,55 +1,67 @@ package ch.njol.skript.entity; -import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Axolotl; import org.bukkit.entity.Axolotl.Variant; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.Objects; + public class AxolotlData extends EntityData { + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"axolotl", null}, + {"lucy axolotl", Variant.LUCY}, + {"wild axolotl", Variant.WILD}, + {"gold axolotl", Variant.GOLD}, + {"cyan axolotl", Variant.CYAN}, + {"blue axolotl", Variant.BLUE} + }); + private static final Variant[] VARIANTS = Variant.values(); + static { - if (Skript.classExists("org.bukkit.entity.Axolotl")) { - EntityData.register(AxolotlData.class, "axolotl", Axolotl.class, 0, - "axolotl", "lucy axolotl", "wild axolotl", "gold axolotl", "cyan axolotl", "blue axolotl"); - } + EntityData.register(AxolotlData.class, "axolotl", Axolotl.class, 0, PATTERNS.getPatterns()); } - @Nullable - private Variant variant = null; + private @Nullable Variant variant = null; public AxolotlData() {} public AxolotlData(@Nullable Variant variant) { this.variant = variant; - matchedCodeName = variant != null ? variant.ordinal() + 1 : 0; + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName > 0) - variant = Variant.values()[matchedCodeName - 1]; + variant = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class c, @Nullable Axolotl axolotl) { - if (axolotl != null) + protected boolean init(@Nullable Class entityClass, @Nullable Axolotl axolotl) { + if (axolotl != null) { variant = axolotl.getVariant(); + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + } return true; } @Override - public void set(Axolotl entity) { - if (variant != null) - entity.setVariant(variant); + public void set(Axolotl axolotl) { + Variant variant = this.variant; + if (variant == null) + variant = CollectionUtils.getRandom(VARIANTS); + assert variant != null; + axolotl.setVariant(variant); } @Override - protected boolean match(Axolotl entity) { - return variant == null || variant == entity.getVariant(); + protected boolean match(Axolotl axolotl) { + return variant == null || variant == axolotl.getVariant(); } @Override @@ -58,27 +70,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new AxolotlData(variant); + public @NotNull EntityData getSuperType() { + return new AxolotlData(); } @Override protected int hashCode_i() { - return variant != null ? variant.hashCode() : 0; + return variant == null ? 0 : Objects.hashCode(variant); } @Override - protected boolean equals_i(EntityData data) { - if (!(data instanceof AxolotlData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof AxolotlData other)) return false; - return variant == ((AxolotlData) data).variant; + return variant == other.variant; } @Override - public boolean isSupertypeOf(EntityData data) { - if (!(data instanceof AxolotlData)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof AxolotlData other)) return false; - return variant == null || variant == ((AxolotlData) data).variant; + return variant == null || variant == other.variant; } } diff --git a/src/main/java/ch/njol/skript/entity/BeeData.java b/src/main/java/ch/njol/skript/entity/BeeData.java index 7abe7f08868..2e054d826ce 100644 --- a/src/main/java/ch/njol/skript/entity/BeeData.java +++ b/src/main/java/ch/njol/skript/entity/BeeData.java @@ -1,9 +1,9 @@ package ch.njol.skript.entity; -import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import org.bukkit.entity.Bee; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.Random; @@ -11,10 +11,8 @@ public class BeeData extends EntityData { static { - if (Skript.classExists("org.bukkit.entity.Bee")) { - EntityData.register(BeeData.class, "bee", Bee.class, 2, - "no nectar bee", "happy bee", "bee", "nectar bee", "angry bee", "angry nectar bee"); - } + EntityData.register(BeeData.class, "bee", Bee.class, 2, + "no nectar bee", "happy bee", "bee", "nectar bee", "angry bee", "angry nectar bee"); } private int nectar = 0; @@ -36,29 +34,38 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(@Nullable Class c, @Nullable Bee e) { - angry = e == null ? 0 : (e.getAnger() > 0) ? 1 : -1; - nectar = e == null ? 0 : e.hasNectar() ? 1 : -1; + protected boolean init(@Nullable Class entityClass, @Nullable Bee bee) { + angry = bee == null ? 0 : (bee.getAnger() > 0) ? 1 : -1; + nectar = bee == null ? 0 : bee.hasNectar() ? 1 : -1; return true; } @Override - public void set(Bee entity) { + public void set(Bee bee) { int random = new Random().nextInt(400) + 400; - entity.setAnger(angry > 0 ? random : 0); - entity.setHasNectar(nectar > 0); + bee.setAnger(angry > 0 ? random : 0); + bee.setHasNectar(nectar > 0); } @Override - protected boolean match(Bee entity) { - return (angry == 0 || (entity.getAnger() > 0) == (angry == 1)) && (nectar == 0 || entity.hasNectar() == (nectar == 1)); - } + protected boolean match(Bee bee) { + if (angry == 0 && nectar == 0) + return true; + if ((bee.getAnger() > 0) != (angry == 1)) + return false; + return bee.hasNectar() == (nectar == 1); + } @Override public Class getType() { return Bee.class; } - + + @Override + public @NotNull EntityData getSuperType() { + return new BeeData(); + } + @Override protected int hashCode_i() { int prime = 31; @@ -67,22 +74,21 @@ protected int hashCode_i() { result = prime * result + nectar; return result; } - + @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof BeeData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof BeeData other)) return false; - final BeeData other = (BeeData) obj; return (angry == other.angry) && (nectar == other.nectar); } - - @Override - public boolean isSupertypeOf(EntityData e) { - return (e instanceof BeeData) && (angry == 0 || ((BeeData) e).angry == angry) && (nectar == 0 || ((BeeData) e).nectar == nectar); - } - + @Override - public @NotNull EntityData getSuperType() { - return new BeeData(); + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof BeeData other)) + return false; + if (angry != 0 && angry != other.angry) + return false; + return nectar == 0 || nectar == other.nectar; } + } diff --git a/src/main/java/ch/njol/skript/entity/BoatChestData.java b/src/main/java/ch/njol/skript/entity/BoatChestData.java index 3499c82efb6..9474c975c1d 100644 --- a/src/main/java/ch/njol/skript/entity/BoatChestData.java +++ b/src/main/java/ch/njol/skript/entity/BoatChestData.java @@ -8,6 +8,7 @@ import org.bukkit.Material; import org.bukkit.entity.Boat; import org.bukkit.entity.ChestBoat; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.HashMap; @@ -50,7 +51,7 @@ public BoatChestData(@Nullable Boat.Type type) { } private BoatChestData(int type) { - matchedCodeName = type; + dataCodeName = type; } @Override @@ -59,23 +60,23 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(@Nullable Class clazz, @Nullable ChestBoat entity) { - if (entity != null) - matchedCodeName = 2 + entity.getBoatType().ordinal(); + protected boolean init(@Nullable Class entityClass, @Nullable ChestBoat chestBoat) { + if (chestBoat != null) + dataCodeName = 2 + chestBoat.getBoatType().ordinal(); return true; } @Override - public void set(ChestBoat entity) { - if (matchedCodeName == 1) // If the type is 'any boat'. - matchedCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. - if (matchedCodeName > 1) // 0 and 1 are excluded - entity.setBoatType(types[matchedCodeName - 2]); // Removes 2 to fix the index. + public void set(ChestBoat chestBoat) { + if (dataCodeName == 1) // If the type is 'any boat'. + dataCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. + if (dataCodeName > 1) // 0 and 1 are excluded + chestBoat.setBoatType(types[dataCodeName - 2]); // Removes 2 to fix the index. } @Override - protected boolean match(ChestBoat entity) { - return matchedCodeName <= 1 || entity.getBoatType().ordinal() == matchedCodeName - 2; + protected boolean match(ChestBoat chestBoat) { + return dataCodeName <= 1 || chestBoat.getBoatType().ordinal() == dataCodeName - 2; } @Override @@ -84,26 +85,26 @@ public Class getType() { } @Override - public EntityData getSuperType() { - return new BoatChestData(matchedCodeName); + public @NotNull EntityData getSuperType() { + return new BoatChestData(); } @Override protected int hashCode_i() { - return matchedCodeName <= 1 ? 0 : matchedCodeName; + return dataCodeName <= 1 ? 0 : dataCodeName; } @Override - protected boolean equals_i(EntityData obj) { - if (obj instanceof BoatChestData boatChestData) - return matchedCodeName == boatChestData.matchedCodeName; + protected boolean equals_i(EntityData entityData) { + if (entityData instanceof BoatChestData other) + return dataCodeName == other.dataCodeName; return false; } @Override - public boolean isSupertypeOf(EntityData entity) { - if (entity instanceof BoatChestData boatChestData) - return matchedCodeName <= 1 || matchedCodeName == boatChestData.matchedCodeName; + public boolean isSupertypeOf(EntityData entityData) { + if (entityData instanceof BoatChestData other) + return dataCodeName <= 1 || dataCodeName == other.dataCodeName; return false; } @@ -129,7 +130,7 @@ public boolean isOfItemType(ItemType itemType) { // material is a boat AND (data matches any boat OR material and data are same) if (type != null) { ordinal = type.ordinal(); - if (matchedCodeName <= 1 || matchedCodeName == ordinal + 2) + if (dataCodeName <= 1 || dataCodeName == ordinal + 2) return true; } } diff --git a/src/main/java/ch/njol/skript/entity/BoatData.java b/src/main/java/ch/njol/skript/entity/BoatData.java index 9025514b729..c5321d0d450 100644 --- a/src/main/java/ch/njol/skript/entity/BoatData.java +++ b/src/main/java/ch/njol/skript/entity/BoatData.java @@ -7,6 +7,7 @@ import ch.njol.skript.lang.SkriptParser.ParseResult; import org.bukkit.Material; import org.bukkit.entity.Boat; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.HashMap; @@ -48,7 +49,7 @@ public BoatData(@Nullable Boat.Type type){ } private BoatData(int type) { - matchedCodeName = type; + dataCodeName = type; } @Override @@ -57,23 +58,23 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(@Nullable Class clazz, @Nullable Boat entity) { - if (entity != null) - matchedCodeName = 2 + entity.getBoatType().ordinal(); + protected boolean init(@Nullable Class entityClass, @Nullable Boat boat) { + if (boat != null) + dataCodeName = 2 + boat.getBoatType().ordinal(); return true; } @Override - public void set(Boat entity) { - if (matchedCodeName == 1) // If the type is 'any boat'. - matchedCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. - if (matchedCodeName > 1) // 0 and 1 are excluded - entity.setBoatType(types[matchedCodeName - 2]); // Removes 2 to fix the index. + public void set(Boat boat) { + if (dataCodeName == 1) // If the type is 'any boat'. + dataCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. + if (dataCodeName > 1) // 0 and 1 are excluded + boat.setBoatType(types[dataCodeName - 2]); // Removes 2 to fix the index. } @Override - protected boolean match(Boat entity) { - return matchedCodeName <= 1 || entity.getBoatType().ordinal() == matchedCodeName - 2; + protected boolean match(Boat boat) { + return dataCodeName <= 1 || boat.getBoatType().ordinal() == dataCodeName - 2; } @Override @@ -82,26 +83,26 @@ public Class getType() { } @Override - public EntityData getSuperType() { - return new BoatData(matchedCodeName); + public @NotNull EntityData getSuperType() { + return new BoatData(dataCodeName); } @Override protected int hashCode_i() { - return matchedCodeName <= 1 ? 0 : matchedCodeName; + return dataCodeName <= 1 ? 0 : dataCodeName; } @Override - protected boolean equals_i(EntityData obj) { - if (obj instanceof BoatData boatData) - return matchedCodeName == boatData.matchedCodeName; + protected boolean equals_i(EntityData entityData) { + if (entityData instanceof BoatData other) + return dataCodeName == other.dataCodeName; return false; } @Override - public boolean isSupertypeOf(EntityData entity) { - if (entity instanceof BoatData boatData) - return matchedCodeName <= 1 || matchedCodeName == boatData.matchedCodeName; + public boolean isSupertypeOf(EntityData entityData) { + if (entityData instanceof BoatData other) + return dataCodeName <= 1 || dataCodeName == other.dataCodeName; return false; } @@ -136,7 +137,7 @@ public boolean isOfItemType(ItemType itemType) { // material is a boat AND (data matches any boat OR material and data are same) if (type != null) { ordinal = type.ordinal(); - if (matchedCodeName <= 1 || matchedCodeName == ordinal + 2) + if (dataCodeName <= 1 || dataCodeName == ordinal + 2) return true; } } diff --git a/src/main/java/ch/njol/skript/entity/CatData.java b/src/main/java/ch/njol/skript/entity/CatData.java index 1754465354a..f077a109fc6 100644 --- a/src/main/java/ch/njol/skript/entity/CatData.java +++ b/src/main/java/ch/njol/skript/entity/CatData.java @@ -1,55 +1,56 @@ package ch.njol.skript.entity; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.registrations.Classes; +import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; import org.bukkit.entity.Cat; +import org.bukkit.entity.Cat.Type; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.Skript; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.util.coll.CollectionUtils; - import java.util.Objects; public class CatData extends EntityData { - + + private static final Type[] TYPES; + static { - if (Skript.classExists("org.bukkit.entity.Cat")) { - EntityData.register(CatData.class, "cat", Cat.class, "cat"); - types = Iterators.toArray(Classes.getExactClassInfo(Cat.Type.class).getSupplier().get(), Cat.Type.class); - } + EntityData.register(CatData.class, "cat", Cat.class, "cat"); + TYPES = Iterators.toArray(Classes.getExactClassInfo(Type.class).getSupplier().get(), Type.class); } - private static Cat.Type[] types; - - private Cat.@Nullable Type race = null; - - @SuppressWarnings("unchecked") + private @Nullable Type type = null; + @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (exprs.length > 0 && exprs[0] != null) - race = ((Literal) exprs[0]).getSingle(); + if (exprs.length > 0 && exprs[0] != null) { + //noinspection unchecked + type = ((Literal) exprs[0]).getSingle(); + } return true; } @Override - protected boolean init(@Nullable Class c, @Nullable Cat cat) { - race = (cat == null) ? Cat.Type.TABBY : cat.getCatType(); + protected boolean init(@Nullable Class entityClass, @Nullable Cat cat) { + if (cat != null) + type = cat.getCatType(); return true; } @Override - public void set(Cat entity) { - Cat.Type type = race != null ? race : CollectionUtils.getRandom(types); + public void set(Cat cat) { + Type type = this.type; + if (type == null) + type = CollectionUtils.getRandom(TYPES); assert type != null; - entity.setCatType(type); + cat.setCatType(type); } @Override - protected boolean match(Cat entity) { - return race == null || entity.getCatType() == race; + protected boolean match(Cat cat) { + return type == null || cat.getCatType() == type; } @Override @@ -58,22 +59,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { + public @NotNull EntityData getSuperType() { return new CatData(); } @Override protected int hashCode_i() { - return Objects.hashCode(race); + return Objects.hashCode(type); } @Override - protected boolean equals_i(EntityData data) { - return data instanceof CatData ? race == ((CatData) data).race : false; + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof CatData other)) + return false; + return type == other.type; } @Override - public boolean isSupertypeOf(EntityData data) { - return data instanceof CatData ? race == null || race == ((CatData) data).race : false; + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof CatData other)) + return false; + return type == null || type == other.type; } + } diff --git a/src/main/java/ch/njol/skript/entity/ChickenData.java b/src/main/java/ch/njol/skript/entity/ChickenData.java index f3270bc94fc..d7091378319 100644 --- a/src/main/java/ch/njol/skript/entity/ChickenData.java +++ b/src/main/java/ch/njol/skript/entity/ChickenData.java @@ -7,6 +7,8 @@ import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; import org.bukkit.entity.Chicken; +import org.bukkit.entity.Chicken.Variant; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.Objects; @@ -14,16 +16,16 @@ public class ChickenData extends EntityData { private static final boolean VARIANTS_ENABLED; - private static final Object[] variants; + private static final Object[] VARIANTS; static { register(ChickenData.class, "chicken", Chicken.class, "chicken"); if (Skript.classExists("org.bukkit.entity.Chicken$Variant")) { VARIANTS_ENABLED = true; - variants = Iterators.toArray(Classes.getExactClassInfo(Chicken.Variant.class).getSupplier().get(), Chicken.Variant.class); + VARIANTS = Iterators.toArray(Classes.getExactClassInfo(Chicken.Variant.class).getSupplier().get(), Chicken.Variant.class); } else { VARIANTS_ENABLED = false; - variants = null; + VARIANTS = null; } } @@ -37,17 +39,10 @@ public ChickenData(@Nullable Object variant) { } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (VARIANTS_ENABLED) { - Literal expr = null; - if (exprs[0] != null) { // chicken - expr = exprs[0]; - } else if (exprs[1] != null) { // chicks - expr = exprs[1]; - } - if (expr != null) - //noinspection unchecked - variant = ((Literal) expr).getSingle(); + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (VARIANTS_ENABLED && exprs[0] != null) { + //noinspection unchecked + variant = ((Literal) exprs[0]).getSingle(); } return true; } @@ -63,9 +58,11 @@ protected boolean init(@Nullable Class entityClass, @Nullable @Override public void set(Chicken chicken) { if (VARIANTS_ENABLED) { - Object finalVariant = variant != null ? variant : CollectionUtils.getRandom(variants); - assert finalVariant != null; - chicken.setVariant((Chicken.Variant) finalVariant); + Variant variant = (Variant) this.variant; + if (variant == null) + variant = (Variant) CollectionUtils.getRandom(VARIANTS); + assert variant != null; + chicken.setVariant(variant); } } @@ -80,7 +77,7 @@ public Class getType() { } @Override - public EntityData getSuperType() { + public @NotNull EntityData getSuperType() { return new ChickenData(); } @@ -90,8 +87,8 @@ protected int hashCode_i() { } @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof ChickenData other)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof ChickenData other)) return false; return variant == other.variant; } diff --git a/src/main/java/ch/njol/skript/entity/CowData.java b/src/main/java/ch/njol/skript/entity/CowData.java index 4184bbe7317..6faf87f40fe 100644 --- a/src/main/java/ch/njol/skript/entity/CowData.java +++ b/src/main/java/ch/njol/skript/entity/CowData.java @@ -7,7 +7,9 @@ import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; import org.bukkit.entity.Cow; +import org.bukkit.entity.Cow.Variant; import org.bukkit.entity.Entity; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.lang.reflect.InvocationTargetException; @@ -17,7 +19,7 @@ public class CowData extends EntityData { private static final boolean VARIANTS_ENABLED; - private static final Object[] variants; + private static final Object[] VARIANTS; private static final Class COW_CLASS; private static final @Nullable Method getVariantMethod; private static final @Nullable Method setVariantMethod; @@ -34,7 +36,7 @@ public class CowData extends EntityData { register(CowData.class, "cow", COW_CLASS, 0, "cow"); if (Skript.classExists("org.bukkit.entity.Cow$Variant")) { VARIANTS_ENABLED = true; - variants = Iterators.toArray(Classes.getExactClassInfo(Cow.Variant.class).getSupplier().get(), Cow.Variant.class); + VARIANTS = Iterators.toArray(Classes.getExactClassInfo(Cow.Variant.class).getSupplier().get(), Cow.Variant.class); try { getVariantMethod = COW_CLASS.getDeclaredMethod("getVariant"); setVariantMethod = COW_CLASS.getDeclaredMethod("setVariant", Cow.Variant.class); @@ -43,7 +45,7 @@ public class CowData extends EntityData { } } else { VARIANTS_ENABLED = false; - variants = null; + VARIANTS = null; getVariantMethod = null; setVariantMethod = null; } @@ -59,17 +61,10 @@ public CowData(@Nullable Object variant) { } @Override - protected boolean init(Literal[] exprs, int matchedPattern, ParseResult parseResult) { - if (VARIANTS_ENABLED) { - Literal expr = null; - if (exprs[0] != null) { // cow - expr = exprs[0]; - } else if (exprs[1] != null) { // calf - expr = exprs[1]; - } - if (expr != null) - //noinspection unchecked - variant = ((Literal) expr).getSingle(); + protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + if (VARIANTS_ENABLED && exprs[0] != null) { + //noinspection unchecked + variant = ((Literal) exprs[0]).getSingle(); } return true; } @@ -83,17 +78,19 @@ protected boolean init(@Nullable Class entityClass, @Nullable Cow } @Override - public void set(Cow entity) { - if (!VARIANTS_ENABLED) - return; - Object finalVariant = variant != null ? variant : CollectionUtils.getRandom(variants); - assert finalVariant != null; - setVariant(entity, finalVariant); + public void set(Cow cow) { + if (VARIANTS_ENABLED) { + Variant variant = (Variant) this.variant; + if (variant == null) + variant = (Variant) CollectionUtils.getRandom(VARIANTS); + assert variant != null; + setVariant(cow, variant); + } } @Override - protected boolean match(Cow entity) { - return variant == null || getVariant(entity) == variant; + protected boolean match(Cow cow) { + return variant == null || getVariant(cow) == variant; } @Override @@ -102,7 +99,7 @@ public Class getType() { } @Override - public EntityData getSuperType() { + public @NotNull EntityData getSuperType() { return new CowData(); } @@ -112,8 +109,8 @@ protected int hashCode_i() { } @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof CowData other)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof CowData other)) return false; return variant == other.variant; } diff --git a/src/main/java/ch/njol/skript/entity/CreeperData.java b/src/main/java/ch/njol/skript/entity/CreeperData.java index db74a7900d3..3b4122afeb1 100644 --- a/src/main/java/ch/njol/skript/entity/CreeperData.java +++ b/src/main/java/ch/njol/skript/entity/CreeperData.java @@ -7,78 +7,87 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; -/** - * @author Peter Güttinger - */ +import java.util.Objects; + + public class CreeperData extends EntityData { + + public enum PoweredState { + UNKNOWN, POWERED, UNPOWERED + } + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"creeper", PoweredState.UNKNOWN}, + {"powered creeper", PoweredState.POWERED}, + {"unpowered creeper", PoweredState.UNPOWERED} + }); + static { - EntityData.register(CreeperData.class, "creeper", Creeper.class, 1, "unpowered creeper", "creeper", "powered creeper"); + EntityData.register(CreeperData.class, "creeper", Creeper.class, 0, PATTERNS.getPatterns()); } - private int powered = 0; + private PoweredState state = PoweredState.UNKNOWN; + + public CreeperData() {} + + public CreeperData(@Nullable CreeperData.PoweredState state) { + this.state = state != null ? state : PoweredState.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(this.state)[0]; + } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - powered = matchedCodeName - 1; + state = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(final @Nullable Class c, final @Nullable Creeper e) { - powered = e == null ? 0 : e.isPowered() ? 1 : -1; + protected boolean init(@Nullable Class entityClass, @Nullable Creeper creeper) { + state = PoweredState.UNKNOWN; + if (creeper != null) { + state = creeper.isPowered() ? PoweredState.POWERED : PoweredState.UNPOWERED; + super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + } return true; } @Override - public void set(final Creeper c) { - if (powered != 0) - c.setPowered(powered == 1); + public void set(Creeper creeper) { + creeper.setPowered(state == PoweredState.POWERED); } @Override - public boolean match(final Creeper entity) { - return powered == 0 || entity.isPowered() == (powered == 1); + public boolean match(Creeper creeper) { + return state == PoweredState.UNKNOWN || creeper.isPowered() == (state == PoweredState.POWERED); } @Override public Class getType() { return Creeper.class; } - + @Override - protected int hashCode_i() { - return powered; + public @NotNull EntityData getSuperType() { + return new CreeperData(); } - + @Override - protected boolean equals_i(final EntityData obj) { - if (!(obj instanceof CreeperData)) - return false; - final CreeperData other = (CreeperData) obj; - return powered == other.powered; + protected int hashCode_i() { + return Objects.hashCode(state); } - -// return "" + powered; + @Override - protected boolean deserialize(final String s) { - try { - powered = Integer.parseInt(s); - return true; - } catch (final NumberFormatException e) { + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof CreeperData other)) return false; - } + return state == other.state; } - - @Override - public boolean isSupertypeOf(final EntityData e) { - if (e instanceof CreeperData) - return powered == 0 || ((CreeperData) e).powered == powered; - return false; - } - + @Override - public @NotNull EntityData getSuperType() { - return new CreeperData(); + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof CreeperData other)) + return false; + return state == other.state; } - + } diff --git a/src/main/java/ch/njol/skript/entity/DroppedItemData.java b/src/main/java/ch/njol/skript/entity/DroppedItemData.java index bfcc3585484..5a0fd8f85e5 100644 --- a/src/main/java/ch/njol/skript/entity/DroppedItemData.java +++ b/src/main/java/ch/njol/skript/entity/DroppedItemData.java @@ -13,6 +13,7 @@ import org.bukkit.World; import org.bukkit.entity.Item; import org.bukkit.inventory.ItemStack; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.lang.reflect.InvocationTargetException; @@ -58,19 +59,19 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(@Nullable Class clazz, @Nullable Item itemEntity) { - if (itemEntity != null) { - final ItemStack i = itemEntity.getItemStack(); - types = new ItemType[] {new ItemType(i)}; + protected boolean init(@Nullable Class entityClass, @Nullable Item item) { + if (item != null) { + ItemStack itemStack = item.getItemStack(); + types = new ItemType[] {new ItemType(itemStack)}; } return true; } @Override - protected boolean match(Item entity) { + protected boolean match(Item item) { if (types != null) { for (ItemType t : types) { - if (t.isOfType(entity.getItemStack())) + if (t.isOfType(item.getItemStack())) return true; } return false; @@ -79,36 +80,47 @@ protected boolean match(Item entity) { } @Override - public void set(final Item entity) { + public void set(Item item) { if (types == null) return; - final ItemType t = CollectionUtils.getRandom(types); - assert t != null; - ItemStack stack = t.getItem().getRandom(); + ItemType itemType = CollectionUtils.getRandom(types); + assert itemType != null; + ItemStack stack = itemType.getItem().getRandom(); assert stack != null; // should be true by init checks - entity.setItemStack(stack); - } - - @Override - public boolean isSupertypeOf(EntityData otherData) { - if (!(otherData instanceof DroppedItemData)) - return false; - DroppedItemData otherItemData = (DroppedItemData) otherData; - if (types != null) - return otherItemData.types != null && ItemType.isSubset(types, otherItemData.types); - return true; + item.setItemStack(stack); } @Override public Class getType() { return Item.class; } - + @Override - public EntityData getSuperType() { - return new DroppedItemData(types); + public @NotNull EntityData getSuperType() { + return new DroppedItemData(); } - + + @Override + protected int hashCode_i() { + return Arrays.hashCode(types); + } + + @Override + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof DroppedItemData)) + return false; + return Arrays.equals(types, ((DroppedItemData) entityData).types); + } + + @Override + public boolean isSupertypeOf(EntityData otherData) { + if (!(otherData instanceof DroppedItemData other)) + return false; + if (types != null) + return other.types != null && ItemType.isSubset(types, other.types); + return true; + } + @Override public String toString(int flags) { if (types == null) @@ -120,19 +132,6 @@ public String toString(int flags) { Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false); } - @Override - @Deprecated(since = "2.3.0", forRemoval = true) - protected boolean deserialize(String s) { - throw new UnsupportedOperationException("old serialization is no longer supported"); - } - - @Override - protected boolean equals_i(EntityData otherData) { - if (!(otherData instanceof DroppedItemData)) - return false; - return Arrays.equals(types, ((DroppedItemData) otherData).types); - } - @Override public boolean canSpawn(@Nullable World world) { return types != null && types.length > 0 && world != null; @@ -145,7 +144,7 @@ public boolean canSpawn(@Nullable World world) { return null; assert types != null && types.length > 0; - final ItemType itemType = CollectionUtils.getRandom(types); + ItemType itemType = CollectionUtils.getRandom(types); assert itemType != null; ItemStack stack = itemType.getItem().getRandom(); assert stack != null; // should be true by init checks @@ -157,7 +156,7 @@ public boolean canSpawn(@Nullable World world) { item = world.dropItem(location, stack, consumer); } else if (BUKKIT_CONSUMER_DROP != null) { try { - // noinspection deprecation + //noinspection removal item = (Item) BUKKIT_CONSUMER_DROP.invoke(world, location, stack, (org.bukkit.util.Consumer) consumer::accept); } catch (InvocationTargetException | IllegalAccessException e) { if (Skript.testing()) @@ -171,9 +170,4 @@ public boolean canSpawn(@Nullable World world) { return item; } - @Override - protected int hashCode_i() { - return Arrays.hashCode(types); - } - } diff --git a/src/main/java/ch/njol/skript/entity/EndermanData.java b/src/main/java/ch/njol/skript/entity/EndermanData.java index 50b0d189bbc..e6a24c6c92e 100644 --- a/src/main/java/ch/njol/skript/entity/EndermanData.java +++ b/src/main/java/ch/njol/skript/entity/EndermanData.java @@ -16,21 +16,19 @@ import org.jetbrains.annotations.Nullable; import java.util.Arrays; -import java.util.function.Predicate; -@SuppressWarnings("deprecation") public class EndermanData extends EntityData { + private final static ArgsMessage FORMAT = new ArgsMessage("entities.enderman.format"); + static { EntityData.register(EndermanData.class, "enderman", Enderman.class, "enderman"); } - - @Nullable - private ItemType[] hand = null; + private ItemType @Nullable [] hand = null; public EndermanData() {} - public EndermanData(@Nullable ItemType[] hand) { + public EndermanData(ItemType @Nullable [] hand) { this.hand = hand; } @@ -43,12 +41,11 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(final @Nullable Class c, final @Nullable Enderman e) { - if (e != null) { - BlockData data = e.getCarriedBlock(); + protected boolean init(@Nullable Class entityClass, @Nullable Enderman enderman) { + if (enderman != null) { + BlockData data = enderman.getCarriedBlock(); if (data != null) { Material type = data.getMaterial(); - assert type != null; hand = new ItemType[] {new ItemType(type)}; } } @@ -56,24 +53,24 @@ protected boolean init(final @Nullable Class c, final @Nulla } @Override - public void set(final Enderman entity) { + public void set(Enderman enderman) { if (hand != null) { - final ItemType t = CollectionUtils.getRandom(hand); - assert t != null; - final ItemStack i = t.getBlock().getRandom(); - if (i != null) { + ItemType itemType = CollectionUtils.getRandom(hand); + assert itemType != null; + ItemStack itemStack = itemType.getBlock().getRandom(); + if (itemStack != null) { // 1.13: item->block usually keeps only material - entity.setCarriedBlock(Bukkit.createBlockData(i.getType())); + enderman.setCarriedBlock(Bukkit.createBlockData(itemStack.getType())); } } } @Override - public boolean match(final Enderman entity) { + public boolean match(Enderman enderman) { return hand == null || SimpleExpression.check(hand, type -> { // TODO {Block/Material}Data -> Material conversion is not 100% accurate, needs a better solution - return type != null && type.isOfType(entity.getCarriedBlock().getMaterial()); + return type != null && type.isOfType(enderman.getCarriedBlock().getMaterial()); }, false, false); } @@ -82,14 +79,9 @@ public Class getType() { return Enderman.class; } - private final static ArgsMessage format = new ArgsMessage("entities.enderman.format"); - @Override - public String toString(final int flags) { - final ItemType[] hand = this.hand; - if (hand == null) - return super.toString(flags); - return format.toString(super.toString(flags), Classes.toString(hand, false)); + public @NotNull EntityData getSuperType() { + return new EndermanData(); } @Override @@ -98,63 +90,31 @@ protected int hashCode_i() { } @Override - protected boolean equals_i(final EntityData obj) { - if (!(obj instanceof EndermanData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof EndermanData other)) return false; - final EndermanData other = (EndermanData) obj; return Arrays.equals(hand, other.hand); } -// if (hand == null) -// return ""; -// final StringBuilder b = new StringBuilder(); -// for (final ItemType h : hand) { -// final Pair s = Classes.serialize(h); -// if (s == null) -// return null; -// if (b.length() != 0) -// b.append(","); -// b.append(s.first); -// b.append(":"); -// b.append(s.second.replace(",", ",,").replace(":", "::")); -// } -// return b.toString(); - @SuppressWarnings("null") @Override - @Deprecated(since = "2.3.0", forRemoval = true) - protected boolean deserialize(final String s) { - if (s.isEmpty()) - return true; - final String[] split = s.split("(? entityData) { + if (!(entityData instanceof EndermanData other)) + return false; + return isSubhand(other.hand); } @Override - public boolean isSupertypeOf(final EntityData e) { - if (e instanceof EndermanData) - return isSubhand(((EndermanData) e).hand); - return false; + public String toString(int flags) { + ItemType[] hand = this.hand; + if (hand == null) + return super.toString(flags); + return FORMAT.toString(super.toString(flags), Classes.toString(hand, false)); } - @Override - public @NotNull EntityData getSuperType() { - return new EndermanData(hand); + private boolean isSubhand(@Nullable ItemType[] sub) { + if (hand != null) + return sub != null && ItemType.isSubset(hand, sub); + return true; } } diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 29d31456ec4..c5766dc0652 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -44,11 +44,6 @@ import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Arrays; -import java.util.Iterator; -import java.util.List; -import java.util.Objects; -import java.util.ArrayList; -import java.util.Arrays; import java.util.HashMap; import java.util.Iterator; import java.util.List; @@ -342,7 +337,7 @@ public static > void register( } transient EntityDataInfo info; - protected int matchedCodeName = 0; + protected int dataCodeName = 0; private Kleenean plural = Kleenean.UNKNOWN; private Kleenean baby = Kleenean.UNKNOWN; @@ -350,7 +345,7 @@ public EntityData() { for (EntityDataInfo info : infos) { if (getClass() == info.getElementClass()) { this.info = info; - matchedCodeName = info.defaultName; + dataCodeName = info.defaultName; return; } } @@ -373,7 +368,7 @@ public final boolean init(Expression[] exprs, int matchedPattern, Kleenean is String codeName = info.getCodeNameFromPattern(matchedPattern); int matchedCodeName = info.getCodeNamePlacement(codeName); int actualPattern = info.getActualMatchedPattern(matchedPattern); - this.matchedCodeName = matchedCodeName; + this.dataCodeName = matchedCodeName; return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedCodeName, actualPattern, parseResult); } @@ -462,7 +457,7 @@ protected abstract boolean init( * * @return A generalized {@link EntityData} representing the base entity type. */ - public abstract @NotNull EntityData getSuperType(); + public abstract @NotNull EntityData getSuperType(); @Override public final String toString() { @@ -471,7 +466,7 @@ public final String toString() { @SuppressWarnings("null") protected Noun getName() { - return info.names[matchedCodeName]; + return info.names[dataCodeName]; } protected @Nullable Adjective getAgeAdjective() { @@ -480,7 +475,7 @@ protected Noun getName() { @SuppressWarnings("null") public String toString(int flags) { - Noun name = info.names[matchedCodeName]; + Noun name = info.names[dataCodeName]; return baby.isTrue() ? m_baby.toString(name, flags) : baby.isFalse() ? m_adult.toString(name, flags) : name.toString(flags); } @@ -512,7 +507,7 @@ public final int hashCode() { int result = 1; result = prime * result + baby.hashCode(); result = prime * result + plural.hashCode(); - result = prime * result + matchedCodeName; + result = prime * result + dataCodeName; result = prime * result + info.hashCode(); result = prime * result + hashCode_i(); return result; @@ -522,10 +517,10 @@ public final int hashCode() { * Internal helper for {@link #equals(Object)} to compare the specific data * of this {@link EntityData} with another. * - * @param obj The {@link EntityData} to compare with. + * @param entityData The {@link EntityData} to compare with. * @return {@code true} if the data is considered equal, otherwise {@code false}. */ - protected abstract boolean equals_i(EntityData obj); + protected abstract boolean equals_i(EntityData entityData); @Override public final boolean equals(@Nullable Object obj) { @@ -539,7 +534,7 @@ public final boolean equals(@Nullable Object obj) { return false; if (plural != other.plural) return false; - if (matchedCodeName != other.matchedCodeName) + if (dataCodeName != other.dataCodeName) return false; if (!info.equals(other.info)) return false; diff --git a/src/main/java/ch/njol/skript/entity/EntityPatterns.java b/src/main/java/ch/njol/skript/entity/EntityPatterns.java new file mode 100644 index 00000000000..16438a7a2e0 --- /dev/null +++ b/src/main/java/ch/njol/skript/entity/EntityPatterns.java @@ -0,0 +1,71 @@ +package ch.njol.skript.entity; + +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.SyntaxElement; +import ch.njol.util.Kleenean; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class EntityPatterns { + + private final String[] patterns; + private final Object[] ts; + private final Map> matchedPatterns = new HashMap<>(); + + /** + * @param info An array which must be like {{String, T}, {String, T}, ...} + */ + public EntityPatterns(Object[][] info) { + patterns = new String[info.length]; + ts = new Object[info.length]; + for (int i = 0; i < info.length; i++) { + if (info[i].length != 2 || !(info[i][0] instanceof String)) + throw new IllegalArgumentException("given array is not like {{String, T}, {String, T}, ...}"); + Object object = info[i][1]; + if (object == null) + object = EntityPatternNone.NONE; + patterns[i] = (String) info[i][0]; + ts[i] = object; + matchedPatterns.computeIfAbsent(object, list -> new ArrayList<>()).add(i); + } + } + + public String[] getPatterns() { + return patterns; + } + + /** + * @param matchedPattern The pattern to get the data to as given in {@link SyntaxElement#init(Expression[], int, Kleenean, ParseResult)} + * @return The info associated with the matched pattern + * @throws ClassCastException If the item in the source array is not of the requested type + */ + public @Nullable T getInfo(int matchedPattern) { + Object object = ts[matchedPattern]; + if (object == null || object == EntityPatternNone.NONE) + return null; + //noinspection unchecked + return (T) object; + } + + /** + * Gets all pattern indices that correlate to {@code t}. + * @param t The typed object. + * @return An array of pattern indices. + */ + public Integer[] getMatchedPatterns(@Nullable T t) { + Object object = t; + if (object == null) + object = EntityPatternNone.NONE; + return matchedPatterns.get(object).toArray(Integer[]::new); + } + + private enum EntityPatternNone { + NONE + } + +} diff --git a/src/main/java/ch/njol/skript/entity/FallingBlockData.java b/src/main/java/ch/njol/skript/entity/FallingBlockData.java index 71b4763dc67..4ea7407c6e9 100644 --- a/src/main/java/ch/njol/skript/entity/FallingBlockData.java +++ b/src/main/java/ch/njol/skript/entity/FallingBlockData.java @@ -1,21 +1,8 @@ package ch.njol.skript.entity; -import java.util.Arrays; - -import java.util.Iterator; -import java.util.function.Consumer; - -import org.bukkit.Location; -import org.bukkit.Material; -import org.bukkit.entity.FallingBlock; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - import ch.njol.skript.Skript; import ch.njol.skript.aliases.ItemData; import ch.njol.skript.aliases.ItemType; -import ch.njol.skript.bukkitutil.block.BlockCompat; -import org.skriptlang.skript.lang.converter.Converter; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.localization.Adjective; @@ -23,49 +10,57 @@ import ch.njol.skript.localization.Message; import ch.njol.skript.localization.Noun; import ch.njol.skript.registrations.Classes; -import org.skriptlang.skript.lang.converter.Converters; import ch.njol.util.coll.CollectionUtils; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.entity.FallingBlock; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.skriptlang.skript.lang.converter.Converters; + +import java.util.Arrays; +import java.util.Iterator; +import java.util.function.Consumer; public class FallingBlockData extends EntityData { + + private final static Message m_not_a_block_error = new Message("entities.falling block.not a block error"); + private final static Adjective m_adjective = new Adjective("entities.falling block.adjective"); + static { EntityData.register(FallingBlockData.class, "falling block", FallingBlock.class, "falling block"); } - - private final static Message m_not_a_block_error = new Message("entities.falling block.not a block error"); - private final static Adjective m_adjective = new Adjective("entities.falling block.adjective"); - @Nullable - private ItemType[] types = null; + private ItemType @Nullable [] types = null; public FallingBlockData() {} - public FallingBlockData(@Nullable ItemType[] types) { + public FallingBlockData(ItemType @Nullable [] types) { this.types = types; } @SuppressWarnings("unchecked") @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (exprs.length > 0 && exprs[0] != null) { - if ((types = Converters.convert(((Literal) exprs[0]).getAll(), ItemType.class, new Converter() { - @Override - @Nullable - public ItemType convert(ItemType t) { - t = t.getBlock().clone(); - final Iterator iter = t.iterator(); - while (iter.hasNext()) { - final Material id = iter.next().getType(); - if (!id.isBlock()) - iter.remove(); - } - if (t.numTypes() == 0) - return null; - t.setAmount(-1); - t.setAll(false); - t.clearEnchantments(); - return t; + if (matchedPattern == 1) { + assert exprs[0] != null; + ItemType[] itemTypes = ((Literal) exprs[0]).getAll(); + types = Converters.convert(itemTypes, ItemType.class, itemType -> { + ItemType clone = itemType.getBlock().clone(); + Iterator iterator = clone.iterator(); + while (iterator.hasNext()) { + Material material = iterator.next().getType(); + if (!material.isBlock()) + iterator.remove(); } - })).length == 0) { + if (clone.numTypes() == 0) + return null; + clone.setAmount(-1); + clone.setAll(false); + clone.clearEnchantments(); + return clone; + }); + if (types.length == 0) { Skript.error(m_not_a_block_error.toString()); return false; } @@ -74,17 +69,22 @@ public ItemType convert(ItemType t) { } @Override - protected boolean init(final @Nullable Class c, final @Nullable FallingBlock e) { - if (e != null) // TODO material data support - types = new ItemType[] {new ItemType(e.getBlockData())}; + protected boolean init(@Nullable Class entityClass, @Nullable FallingBlock fallingBlock) { + if (fallingBlock != null) // TODO material data support + types = new ItemType[] {new ItemType(fallingBlock.getBlockData())}; return true; } - + + @Override + public void set(FallingBlock fallingBlock) { + assert false; + } + @Override - protected boolean match(final FallingBlock entity) { + protected boolean match(FallingBlock fallingBlock) { if (types != null) { - for (final ItemType t : types) { - if (t.isOfType(entity.getBlockData())) + for (ItemType itemType : types) { + if (itemType.isOfType(fallingBlock.getBlockData())) return true; } return false; @@ -93,85 +93,67 @@ protected boolean match(final FallingBlock entity) { } @Override - @Nullable - public FallingBlock spawn(Location loc, @Nullable Consumer consumer) { - ItemType t = types == null ? new ItemType(Material.STONE) : CollectionUtils.getRandom(types); - assert t != null; - Material material = t.getMaterial(); - if (!material.isBlock()) { - assert false : t; - return null; - } - - FallingBlock fallingBlock = loc.getWorld().spawnFallingBlock(loc, material.createBlockData()); - if (consumer != null) - consumer.accept(fallingBlock); + public Class getType() { + return FallingBlock.class; + } - return fallingBlock; + @Override + public @NotNull EntityData getSuperType() { + return new FallingBlockData(); } @Override - public void set(final FallingBlock entity) { - assert false; + protected int hashCode_i() { + return Arrays.hashCode(types); } - + @Override - public Class getType() { - return FallingBlock.class; + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof FallingBlockData other)) + return false; + return Arrays.equals(types, other.types); } - + @Override - public boolean isSupertypeOf(final EntityData e) { - if (!(e instanceof FallingBlockData)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof FallingBlockData other)) return false; - final FallingBlockData d = (FallingBlockData) e; if (types != null) { - if (d.types != null) - return ItemType.isSubset(types, d.types); + if (other.types != null) + return ItemType.isSubset(types, other.types); return false; } return true; } - + @Override - public @NotNull EntityData getSuperType() { - return new FallingBlockData(types); + public @Nullable FallingBlock spawn(Location loc, @Nullable Consumer consumer) { + ItemType t = types == null ? new ItemType(Material.STONE) : CollectionUtils.getRandom(types); + assert t != null; + Material material = t.getMaterial(); + if (!material.isBlock()) { + assert false : t; + return null; + } + + FallingBlock fallingBlock = loc.getWorld().spawnFallingBlock(loc, material.createBlockData()); + if (consumer != null) + consumer.accept(fallingBlock); + + return fallingBlock; } - + @Override - public String toString(final int flags) { - final ItemType[] types = this.types; + public String toString(int flags) { + ItemType[] types = this.types; if (types == null) return super.toString(flags); - final StringBuilder b = new StringBuilder(); - b.append(Noun.getArticleWithSpace(types[0].getTypes().get(0).getGender(), flags)); - b.append(m_adjective.toString(types[0].getTypes().get(0).getGender(), flags)); - b.append(" "); - b.append(Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false)); - return "" + b.toString(); - } - -// return ItemType.serialize(types); - @Override - @Deprecated(since = "2.3.0", forRemoval = true) - protected boolean deserialize(final String s) { - throw new UnsupportedOperationException("old serialization is not supported"); -// if (s.isEmpty()) -// return true; -// types = ItemType.deserialize(s); -// return types != null; + StringBuilder builder = new StringBuilder(); + builder.append(Noun.getArticleWithSpace(types[0].getTypes().get(0).getGender(), flags)); + builder.append(m_adjective.toString(types[0].getTypes().get(0).getGender(), flags)); + builder.append(" "); + builder.append(Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false)); + return builder.toString(); } - - @Override - protected boolean equals_i(final EntityData obj) { - if (!(obj instanceof FallingBlockData)) - return false; - return Arrays.equals(types, ((FallingBlockData) obj).types); - } - - @Override - protected int hashCode_i() { - return Arrays.hashCode(types); - } - + } diff --git a/src/main/java/ch/njol/skript/entity/FoxData.java b/src/main/java/ch/njol/skript/entity/FoxData.java index 1e0f407ab18..f849eeaba84 100644 --- a/src/main/java/ch/njol/skript/entity/FoxData.java +++ b/src/main/java/ch/njol/skript/entity/FoxData.java @@ -1,55 +1,64 @@ package ch.njol.skript.entity; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Fox; import org.bukkit.entity.Fox.Type; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.Skript; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; +import java.util.Objects; public class FoxData extends EntityData { + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"fox", null}, + {"red fox", Type.RED}, + {"snow fox", Type.SNOW} + }); + private static final Type[] TYPES = Type.values(); + static { - if (Skript.classExists("org.bukkit.entity.Fox")) - EntityData.register(FoxData.class, "fox", Fox.class, 1, - "fox", "red fox", "snow fox"); + EntityData.register(FoxData.class, "fox", Fox.class, 0, PATTERNS.getPatterns()); } - - @Nullable - private Type type = null; + + private @Nullable Type type = null; public FoxData() {} public FoxData(@Nullable Type type) { this.type = type; - super.matchedCodeName = type == Type.SNOW ? 2 : 1; + super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName > 0) - type = Type.values()[matchedCodeName - 1]; + type = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class c, @Nullable Fox fox) { - if (fox != null) + protected boolean init(@Nullable Class entityClass, @Nullable Fox fox) { + if (fox != null) { type = fox.getFoxType(); + super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + } return true; } @Override - public void set(Fox entity) { - if (type != null) - entity.setFoxType(type); + public void set(Fox fox) { + Type type = this.type; + if (type == null) + type = CollectionUtils.getRandom(TYPES); + assert type != null; + fox.setFoxType(type); } @Override - protected boolean match(Fox entity) { - return type == null || type == entity.getFoxType(); + protected boolean match(Fox fox) { + return type == null || type == fox.getFoxType(); } @Override @@ -58,26 +67,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new FoxData(type); + public @NotNull EntityData getSuperType() { + return new FoxData(); } @Override protected int hashCode_i() { - return type != null ? type.hashCode() : 0; + return type != null ? Objects.hashCode(type) : 0; } @Override - protected boolean equals_i(EntityData data) { - if (!(data instanceof FoxData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof FoxData other)) return false; - return type == ((FoxData) data).type; + return type == other.type; } @Override - public boolean isSupertypeOf(EntityData data) { - if (!(data instanceof FoxData)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof FoxData other)) return false; - return type == null || type == ((FoxData) data).type; + return type == null || type == other.type; } + } diff --git a/src/main/java/ch/njol/skript/entity/FrogData.java b/src/main/java/ch/njol/skript/entity/FrogData.java index faa3b088fda..5a59f46a668 100644 --- a/src/main/java/ch/njol/skript/entity/FrogData.java +++ b/src/main/java/ch/njol/skript/entity/FrogData.java @@ -1,8 +1,8 @@ package ch.njol.skript.entity; -import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Frog; import org.bukkit.entity.Frog.Variant; import org.jetbrains.annotations.NotNull; @@ -12,62 +12,54 @@ public class FrogData extends EntityData { + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"frog", null}, + {"temperate frog", Variant.TEMPERATE}, + {"warm frog", Variant.WARM}, + {"cold frog", Variant.COLD} + }); + private static final Variant[] VARIANTS = Variant.values(); + static { - if (Skript.classExists("org.bukkit.entity.Frog")) { - EntityData.register(FrogData.class, "frog", Frog.class, 0, - "frog", "temperate frog", "warm frog", "cold frog"); - } + EntityData.register(FrogData.class, "frog", Frog.class, 0, PATTERNS.getPatterns()); } - @Nullable - private Variant variant = null; + private @Nullable Variant variant = null; - public FrogData() { - } + public FrogData() {} public FrogData(@Nullable Variant variant) { this.variant = variant; - matchedCodeName = 0; - if (variant == Variant.TEMPERATE) - matchedCodeName = 1; - if (variant == Variant.WARM) - matchedCodeName = 2; - if (variant == Variant.COLD) - matchedCodeName = 3; + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - switch (matchedCodeName) { - case 1: - variant = Variant.TEMPERATE; - break; - case 2: - variant = Variant.WARM; - break; - case 3: - variant = Variant.COLD; - break; - } + variant = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class c, @Nullable Frog frog) { - if (frog != null) + protected boolean init(@Nullable Class entityClass, @Nullable Frog frog) { + if (frog != null) { variant = frog.getVariant(); + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + } return true; } @Override - public void set(Frog entity) { - if (variant != null) - entity.setVariant(variant); + public void set(Frog frog) { + Variant variant = this.variant; + if (variant == null) + variant = CollectionUtils.getRandom(VARIANTS); + assert variant != null; + frog.setVariant(variant); } @Override - protected boolean match(Frog entity) { - return variant == null || variant == entity.getVariant(); + protected boolean match(Frog frog) { + return variant == null || variant == frog.getVariant(); } @Override @@ -76,8 +68,8 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new FrogData(variant); + public @NotNull EntityData getSuperType() { + return new FrogData(); } @Override @@ -86,17 +78,17 @@ protected int hashCode_i() { } @Override - protected boolean equals_i(EntityData data) { - if (!(data instanceof FrogData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof FrogData other)) return false; - return variant == ((FrogData) data).variant; + return variant == other.variant; } @Override - public boolean isSupertypeOf(EntityData data) { - if (!(data instanceof FrogData)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof FrogData other)) return false; - return variant == null || variant == ((FrogData) data).variant; + return variant == null || variant == other.variant; } } diff --git a/src/main/java/ch/njol/skript/entity/GoatData.java b/src/main/java/ch/njol/skript/entity/GoatData.java index 58633a2a8cf..6cc3916a6a2 100644 --- a/src/main/java/ch/njol/skript/entity/GoatData.java +++ b/src/main/java/ch/njol/skript/entity/GoatData.java @@ -1,52 +1,61 @@ package ch.njol.skript.entity; -import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import org.bukkit.entity.Goat; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.Objects; + public class GoatData extends EntityData { + public enum ScreamingState { + UNKNOWN, SCREAMING, QUIET + } + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"goat", ScreamingState.UNKNOWN}, + {"screaming goat", ScreamingState.SCREAMING}, + {"quiet goat", ScreamingState.QUIET} + }); + static { - if (Skript.classExists("org.bukkit.entity.Goat")) - EntityData.register(GoatData.class, "goat", Goat.class, 0, - "goat", "screaming goat", "quiet goat"); + EntityData.register(GoatData.class, "goat", Goat.class, 0, PATTERNS.getPatterns()); } - private int screaming = 0; // 0 = random, 1 = screaming, 2 = quiet + private ScreamingState state = ScreamingState.UNKNOWN; public GoatData() {} - public GoatData(int screaming) { - this.screaming = screaming; + public GoatData(@Nullable GoatData.ScreamingState state) { + this.state = state != null ? state : ScreamingState.UNKNOWN; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - screaming = matchedCodeName; + state = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class c, @Nullable Goat goat) { - if (goat != null && matchedCodeName > 0) - goat.setScreaming(matchedCodeName == 1); + protected boolean init(@Nullable Class entityClass, @Nullable Goat goat) { + state = ScreamingState.UNKNOWN; + if (goat != null) { + state = goat.isScreaming() ? ScreamingState.SCREAMING : ScreamingState.QUIET; + super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + } return true; } @Override - public void set(Goat entity) { - if (matchedCodeName > 0) - entity.setScreaming(screaming == 1); + public void set(Goat goat) { + goat.setScreaming(state == ScreamingState.SCREAMING); } @Override - protected boolean match(Goat entity) { - if (matchedCodeName > 0) - return entity.isScreaming() ? screaming == 1 : screaming == 2; - return true; + protected boolean match(Goat goat) { + return state == ScreamingState.UNKNOWN || goat.isScreaming() == (state == ScreamingState.SCREAMING); } @Override @@ -55,27 +64,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new GoatData(screaming); + public @NotNull EntityData getSuperType() { + return new GoatData(); } @Override protected int hashCode_i() { - return screaming; + return Objects.hashCode(state); } @Override - protected boolean equals_i(EntityData data) { - if (!(data instanceof GoatData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof GoatData other)) return false; - return screaming == ((GoatData) data).screaming; + return state == other.state; } @Override - public boolean isSupertypeOf(EntityData data) { - if (!(data instanceof GoatData)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof GoatData other)) return false; - return screaming == ((GoatData) data).screaming; + return state == ScreamingState.UNKNOWN || state == other.state; } } diff --git a/src/main/java/ch/njol/skript/entity/LlamaData.java b/src/main/java/ch/njol/skript/entity/LlamaData.java index 2ccc4a03408..7b9709aebe4 100644 --- a/src/main/java/ch/njol/skript/entity/LlamaData.java +++ b/src/main/java/ch/njol/skript/entity/LlamaData.java @@ -9,14 +9,26 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.Objects; + public class LlamaData extends EntityData { + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"llama", null}, + {"creamy llama", Color.CREAMY}, + {"white llama", Color.WHITE}, + {"brown llama", Color.BROWN}, + {"gray llama", Color.GRAY}, + {"trader llama", null}, + {"creamy trader llama", Color.CREAMY}, + {"white trader llama", Color.WHITE}, + {"brown trader llama", Color.BROWN}, + {"gray trader llama", Color.GRAY} + }); private static final Color[] LLAMA_COLORS = Color.values(); static { - EntityData.register(LlamaData.class, "llama", Llama.class, 0, - "llama", "creamy llama", "white llama", "brown llama", "gray llama", - "trader llama", "creamy trader llama", "white trader llama", "brown trader llama", "gray trader llama"); + EntityData.register(LlamaData.class, "llama", Llama.class, 0, PATTERNS.getPatterns()); } private @Nullable Color color = null; @@ -27,19 +39,13 @@ public LlamaData() {} public LlamaData(@Nullable Color color, boolean isTrader) { this.color = color; this.isTrader = isTrader; - super.matchedCodeName = (color != null ? (color.ordinal() + 1) : 0) + (isTrader ? 5 : 0); + super.dataCodeName = PATTERNS.getMatchedPatterns(color)[!isTrader ? 0 : 1]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { isTrader = matchedCodeName > 4; - if (matchedCodeName > 5) { - color = LLAMA_COLORS[matchedCodeName - 6]; - } else if (matchedCodeName > 0 && matchedCodeName < 5) { - color = LLAMA_COLORS[matchedCodeName - 1]; - } - // Sets 'matchedCodeName' of 'EntityData' for proper 'toString' - super.matchedCodeName = (color != null ? (color.ordinal() + 1) : 0) + (isTrader ? 5 : 0); + color = PATTERNS.getInfo(matchedCodeName); return true; } @@ -50,22 +56,25 @@ protected boolean init(@Nullable Class entityClass, @Nullable L if (llama != null) { color = llama.getColor(); isTrader = llama instanceof TraderLlama; + super.dataCodeName = PATTERNS.getMatchedPatterns(color)[!isTrader ? 0 : 1]; } return true; } @Override - public void set(Llama entity) { - Color randomColor = color == null ? CollectionUtils.getRandom(LLAMA_COLORS) : color; - assert randomColor != null; - entity.setColor(randomColor); + public void set(Llama llama) { + Color color = this.color; + if (color == null) + color = CollectionUtils.getRandom(LLAMA_COLORS); + assert color != null; + llama.setColor(color); } @Override - protected boolean match(Llama entity) { - if (isTrader && !(entity instanceof TraderLlama)) + protected boolean match(Llama llama) { + if (isTrader && !(llama instanceof TraderLlama)) return false; - return color == null || color == entity.getColor(); + return color == null || color == llama.getColor(); } @Override @@ -74,29 +83,29 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new LlamaData(color, isTrader); + public @NotNull EntityData getSuperType() { + return new LlamaData(); } @Override protected int hashCode_i() { - final int prime = 31; + int prime = 31; int result = 1; - result = prime * result + (color != null ? color.hashCode() : 0); + result = prime * result + (color != null ? Objects.hashCode(color) : 0); result = prime * result + (isTrader ? 1 : 0); return result; } @Override - protected boolean equals_i(EntityData data) { - if (!(data instanceof LlamaData other)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof LlamaData other)) return false; return isTrader == other.isTrader && other.color == color; } @Override - public boolean isSupertypeOf(EntityData data) { - if (!(data instanceof LlamaData other)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof LlamaData other)) return false; if (isTrader && !other.isTrader) diff --git a/src/main/java/ch/njol/skript/entity/MinecartData.java b/src/main/java/ch/njol/skript/entity/MinecartData.java index 554a0af21fa..07d4f68d439 100644 --- a/src/main/java/ch/njol/skript/entity/MinecartData.java +++ b/src/main/java/ch/njol/skript/entity/MinecartData.java @@ -68,9 +68,9 @@ public String toString() { public MinecartData() {} - public MinecartData(final MinecartType type) { + public MinecartData(MinecartType type) { this.type = type; - this.matchedCodeName = type.ordinal(); + this.dataCodeName = type.ordinal(); } @Override @@ -81,13 +81,13 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @SuppressWarnings("null") @Override - protected boolean init(final @Nullable Class c, final @Nullable Minecart e) { + protected boolean init(@Nullable Class entityClass, @Nullable Minecart minecart) { final MinecartType[] ts = MinecartType.values(); for (int i = ts.length - 1; i >= 0; i--) { final Class mc = ts[i].c; if (mc == null) continue; - if (e == null ? mc.isAssignableFrom(c) : mc.isInstance(e)) { + if (minecart == null ? mc.isAssignableFrom(entityClass) : mc.isInstance(minecart)) { type = ts[i]; return true; } @@ -97,55 +97,43 @@ protected boolean init(final @Nullable Class c, final @Nulla } @Override - public void set(final Minecart entity) {} + public void set(Minecart minecart) {} @Override - public boolean match(final Minecart entity) { + public boolean match(Minecart minecart) { if (type == MinecartType.NORMAL && type.c == Minecart.class) // pre-1.5 - return !(entity.getClass().equals(Utils.classForName("org.bukkit.entity.StorageMinecart")) - || entity.getClass().equals(Utils.classForName("org.bukkit.entity.PoweredMinecart"))); - return type.c != null && type.c.isInstance(entity); + return !(minecart.getClass().equals(Utils.classForName("org.bukkit.entity.StorageMinecart")) + || minecart.getClass().equals(Utils.classForName("org.bukkit.entity.PoweredMinecart"))); + return type.c != null && type.c.isInstance(minecart); } @Override public Class getType() { return type.c != null ? type.c : Minecart.class; } - + + @Override + public @NotNull EntityData getSuperType() { + return new MinecartData(); + } + @Override protected int hashCode_i() { return type.hashCode(); } - + @Override - protected boolean equals_i(final EntityData obj) { - if (!(obj instanceof MinecartData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof MinecartData other)) return false; - final MinecartData other = (MinecartData) obj; return type == other.type; } - -// return type.name(); + @Override - protected boolean deserialize(final String s) { - try { - type = MinecartType.valueOf(s); - return true; - } catch (final IllegalArgumentException e) { + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof MinecartData other)) return false; - } + return type == MinecartType.ANY || type == other.type; } - - @Override - public boolean isSupertypeOf(final EntityData e) { - if (e instanceof MinecartData) - return type == MinecartType.ANY || ((MinecartData) e).type == type; - return false; - } - - @Override - public @NotNull EntityData getSuperType() { - return new MinecartData(type); - } - + } diff --git a/src/main/java/ch/njol/skript/entity/MooshroomData.java b/src/main/java/ch/njol/skript/entity/MooshroomData.java index a1c4b2d452a..0a915bf52c2 100644 --- a/src/main/java/ch/njol/skript/entity/MooshroomData.java +++ b/src/main/java/ch/njol/skript/entity/MooshroomData.java @@ -1,56 +1,64 @@ package ch.njol.skript.entity; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.MushroomCow; import org.bukkit.entity.MushroomCow.Variant; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.Skript; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; +import java.util.Objects; public class MooshroomData extends EntityData { - + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"mooshroom", null}, + {"red mooshroom", Variant.RED}, + {"brown mooshroom", Variant.BROWN} + }); + private static final Variant[] VARIANTS = Variant.values(); + static { - if (Skript.methodExists(MushroomCow.class, "getVariant")) { - EntityData.register(MooshroomData.class, "mooshroom", MushroomCow.class, 1, - "mooshroom", "red mooshroom", "brown mooshroom"); - } + EntityData.register(MooshroomData.class, "mooshroom", MushroomCow.class, 0, PATTERNS.getPatterns()); } - - @Nullable - private Variant variant = null; + + private @Nullable Variant variant = null; public MooshroomData() {} public MooshroomData(@Nullable Variant variant) { this.variant = variant; - super.matchedCodeName = variant == Variant.BROWN ? 2 : 1; + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName > 0) - variant = Variant.values()[matchedCodeName - 1]; + variant = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class c, @Nullable MushroomCow mushroomCow) { - if (mushroomCow != null) + protected boolean init(@Nullable Class entityClass, @Nullable MushroomCow mushroomCow) { + if (mushroomCow != null) { variant = mushroomCow.getVariant(); + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + } return true; } @Override - public void set(MushroomCow entity) { - if (variant != null) - entity.setVariant(variant); + public void set(MushroomCow mushroomCow) { + Variant variant = this.variant; + if (variant == null) + variant = CollectionUtils.getRandom(VARIANTS); + assert variant != null; + mushroomCow.setVariant(variant); } @Override - protected boolean match(MushroomCow entity) { - return variant == null || variant == entity.getVariant(); + protected boolean match(MushroomCow mushroomCow) { + return variant == null || variant == mushroomCow.getVariant(); } @Override @@ -59,26 +67,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new MooshroomData(variant); + public @NotNull EntityData getSuperType() { + return new MooshroomData(); } @Override protected int hashCode_i() { - return variant != null ? variant.hashCode() : 0; + return variant != null ? Objects.hashCode(variant) : 0; } @Override - protected boolean equals_i(EntityData data) { - if (!(data instanceof MooshroomData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof MooshroomData other)) return false; - return variant == ((MooshroomData) data).variant; + return variant == other.variant; } @Override - public boolean isSupertypeOf(EntityData data) { - if (!(data instanceof MooshroomData)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof MooshroomData other)) return false; - return variant == null || variant == ((MooshroomData) data).variant; + return variant == null || variant == other.variant; } + } diff --git a/src/main/java/ch/njol/skript/entity/OcelotData.java b/src/main/java/ch/njol/skript/entity/OcelotData.java deleted file mode 100644 index 6a5a8357ade..00000000000 --- a/src/main/java/ch/njol/skript/entity/OcelotData.java +++ /dev/null @@ -1,95 +0,0 @@ -package ch.njol.skript.entity; - -import org.bukkit.entity.Ocelot; -import org.bukkit.entity.Tameable; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import ch.njol.skript.Skript; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; - -/** - * @author Peter Güttinger - */ -public class OcelotData extends EntityData { - - private static final boolean TAMEABLE = Skript.methodExists(Ocelot.class, "setTamed"); - static { - if (TAMEABLE) { - EntityData.register(OcelotData.class, "ocelot", Ocelot.class, 1, - "wild ocelot", "ocelot", "cat"); - } else { - EntityData.register(OcelotData.class, "ocelot", Ocelot.class, "ocelot"); - } - } - - int tamed = 0; - - @Override - protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - tamed = TAMEABLE ? matchedCodeName - 1 : 0; - return true; - } - - @Override - protected boolean init(final @Nullable Class c, final @Nullable Ocelot e) { - if (TAMEABLE) - tamed = e == null ? 0 : ((Tameable) e).isTamed() ? 1 : -1; - return true; - } - - @Override - public void set(final Ocelot entity) { - if (TAMEABLE) { - ((Tameable) entity).setTamed(tamed != 0); - } - } - - @Override - protected boolean match(final Ocelot entity) { - return tamed == 0 || ((Tameable) entity).isTamed() == (tamed == 1); - } - - @Override - public Class getType() { - return Ocelot.class; - } - - @Override - protected int hashCode_i() { - return tamed; - } - - @Override - protected boolean equals_i(final EntityData obj) { - if (!(obj instanceof OcelotData)) - return false; - final OcelotData other = (OcelotData) obj; - return tamed == other.tamed; - } - -// return "" + tamed; - @Override - protected boolean deserialize(final String s) { - try { - tamed = Integer.parseInt(s); - return true; - } catch (final NumberFormatException e) { - return false; - } - } - - @Override - public boolean isSupertypeOf(final EntityData e) { - if (e instanceof OcelotData) - return tamed == 0 || ((OcelotData) e).tamed == tamed; - return false; - } - - @Override - public @NotNull EntityData getSuperType() { - return new OcelotData(); - } - -} diff --git a/src/main/java/ch/njol/skript/entity/PandaData.java b/src/main/java/ch/njol/skript/entity/PandaData.java index 9702b7251df..0bedc810c19 100644 --- a/src/main/java/ch/njol/skript/entity/PandaData.java +++ b/src/main/java/ch/njol/skript/entity/PandaData.java @@ -1,26 +1,26 @@ package ch.njol.skript.entity; -import java.util.concurrent.ThreadLocalRandom; - +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.localization.Language; +import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Panda; import org.bukkit.entity.Panda.Gene; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.Skript; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.skript.localization.Language; +import java.util.Objects; public class PandaData extends EntityData { + private static final Gene[] GENES = Gene.values(); + static { - if (Skript.isRunningMinecraft(1, 14)) - EntityData.register(PandaData.class, "panda", Panda.class, "panda"); + EntityData.register(PandaData.class, "panda", Panda.class, "panda"); } - - @Nullable - private Gene mainGene = null, hiddenGene = null; + + private @Nullable Gene mainGene = null; + private @Nullable Gene hiddenGene = null; public PandaData() {} @@ -39,7 +39,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(@Nullable Class c, @Nullable Panda panda) { + protected boolean init(@Nullable Class entityClass, @Nullable Panda panda) { if (panda != null) { mainGene = panda.getMainGene(); hiddenGene = panda.getHiddenGene(); @@ -48,28 +48,23 @@ protected boolean init(@Nullable Class c, @Nullable Panda panda } @Override - public void set(Panda entity) { - Gene gen = mainGene; - if (gen == null) - gen = Gene.values()[ThreadLocalRandom.current().nextInt(0, 7)]; - assert gen != null; - entity.setMainGene(gen); - entity.setHiddenGene(hiddenGene != null ? hiddenGene : gen); + public void set(Panda panda) { + Gene gene = mainGene; + if (gene == null) + gene = CollectionUtils.getRandom(GENES); + assert gene != null; + panda.setMainGene(gene); + panda.setHiddenGene(hiddenGene != null ? hiddenGene : gene); } @Override - protected boolean match(Panda entity) { - if (hiddenGene != null) { - if(mainGene != null) - return mainGene == entity.getMainGene() && hiddenGene == entity.getHiddenGene(); - else - return hiddenGene == entity.getHiddenGene(); - } else { - if(mainGene != null) - return mainGene == entity.getMainGene(); - else - return true; - } + protected boolean match(Panda panda) { + boolean matched = true; + if (mainGene != null) + matched &= (mainGene == panda.getMainGene()); + if (hiddenGene != null) + matched &= (hiddenGene == panda.getHiddenGene()); + return matched; } @Override @@ -78,33 +73,31 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new PandaData(mainGene, hiddenGene); + public @NotNull EntityData getSuperType() { + return new PandaData(); } @Override protected int hashCode_i() { int prime = 7; int result = 0; - result = result * prime + (mainGene != null ? mainGene.hashCode() : 0); - result = result * prime + (hiddenGene != null ? hiddenGene.hashCode() : 0); + result = result * prime + (mainGene != null ? Objects.hashCode(mainGene) : 0); + result = result * prime + (hiddenGene != null ? Objects.hashCode(hiddenGene) : 0); return result; } @Override - protected boolean equals_i(EntityData data) { - if (!(data instanceof PandaData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof PandaData other)) return false; - PandaData d = (PandaData) data; - return d.mainGene == mainGene && d.hiddenGene == hiddenGene; + return other.mainGene == mainGene && other.hiddenGene == hiddenGene; } @Override - public boolean isSupertypeOf(EntityData data) { - if (!(data instanceof PandaData)) + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof PandaData other)) return false; - PandaData d = (PandaData) data; - return (mainGene == null || mainGene == d.mainGene) && (hiddenGene == null || hiddenGene == d.hiddenGene); + return (mainGene == null || mainGene == other.mainGene) && (hiddenGene == null || hiddenGene == other.hiddenGene); } @Override diff --git a/src/main/java/ch/njol/skript/entity/ParrotData.java b/src/main/java/ch/njol/skript/entity/ParrotData.java index f36efb9a543..6d455813d29 100644 --- a/src/main/java/ch/njol/skript/entity/ParrotData.java +++ b/src/main/java/ch/njol/skript/entity/ParrotData.java @@ -1,87 +1,66 @@ package ch.njol.skript.entity; -import java.util.concurrent.ThreadLocalRandom; - -import org.bukkit.entity.Parrot; -import org.bukkit.entity.Parrot.Variant; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Parrot; import org.bukkit.entity.Parrot.Variant; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.concurrent.ThreadLocalRandom; - public class ParrotData extends EntityData { - - // Cached variants, values() copies array each time it is called - @SuppressWarnings("null") // If null, ParrotData is not registered - private static Object[] variants; + + private static final Variant[] VARIANTS = Variant.values(); + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"parrot", null}, + {"red parrot", Variant.RED}, + {"blue parrot", Variant.BLUE}, + {"green parrot", Variant.GREEN}, + {"cyan parrot", Variant.CYAN}, + {"gray parrot", Variant.GRAY} + }); static { - if (Skript.classExists("org.bukkit.entity.Parrot")) { - variants = Parrot.Variant.values(); - EntityData.register(ParrotData.class, "parrot", Parrot.class, 0, - "parrot", "red parrot", "blue parrot", "green parrot", "cyan parrot", "gray parrot"); - } + EntityData.register(ParrotData.class, "parrot", Parrot.class, 0, + PATTERNS.getPatterns()); } - - /** - * Parrot variant. To avoid literally crashing on MC<1.12, - * we just map enum values to int. - */ - private int variant; + + private @Nullable Variant variant = null; public ParrotData() {} - public ParrotData(int variant) { + public ParrotData(@Nullable Variant variant) { this.variant = variant; - super.matchedCodeName = variant + 1; + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName == 0) { // Just a parrot, variant -1 to request random variant on spawn - variant = -1; - } else { // Specific variant was given - variant = matchedCodeName - 1; // Patterns begin from 1, enum elements from 0 - } + variant = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class c, @Nullable Parrot e) { - if (e != null) { // Entity provided, take its variant - Parrot.Variant entityVariant = e.getVariant(); - for (int i = 0; i < variants.length; i++) { - Object var = variants[i]; - if (var == entityVariant) { // Found variant of entity - variant = i; // Put its numeric id here - } - } - } else { // No entity, ask for variant randomization on spawn - variant = -1; + protected boolean init(@Nullable Class entityClass, @Nullable Parrot parrot) { + if (parrot != null) { + variant = parrot.getVariant(); + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; } return true; } @Override - public void set(Parrot entity) { - if (variant == -1) { - int randomVariant = ThreadLocalRandom.current().nextInt(0, variants.length); - entity.setVariant((Variant) variants[randomVariant]); - } else { - entity.setVariant((Variant) variants[variant]); - } + public void set(Parrot parrot) { + Variant variant = this.variant; + if (variant == null) + variant = CollectionUtils.getRandom(VARIANTS); + assert variant != null; + parrot.setVariant(variant); } @Override - protected boolean match(Parrot entity) { - return variant == -1 || entity.getVariant() == variants[variant]; + protected boolean match(Parrot parrot) { + return variant == null || variant == parrot.getVariant(); } @Override @@ -90,26 +69,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new ParrotData(variant); + public @NotNull EntityData getSuperType() { + return new ParrotData(); } @Override protected int hashCode_i() { - return variant; + return variant == null ? 0 : variant.hashCode(); } @Override - protected boolean equals_i(EntityData obj) { - if (obj instanceof ParrotData) - return ((ParrotData) obj).variant == variant; - return false; + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof ParrotData other)) + return false; + return variant == other.variant; } @Override - public boolean isSupertypeOf(EntityData e) { - // True if e is parrot, and this is generic parrot OR if this and e are similar parrots - return e instanceof ParrotData && (variant == -1 || ((ParrotData) e).variant == variant); + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof ParrotData other)) + return false; + return variant == null || variant == other.variant; } } diff --git a/src/main/java/ch/njol/skript/entity/PigData.java b/src/main/java/ch/njol/skript/entity/PigData.java index 06f42fc6c6d..c2d93103770 100644 --- a/src/main/java/ch/njol/skript/entity/PigData.java +++ b/src/main/java/ch/njol/skript/entity/PigData.java @@ -18,18 +18,22 @@ public enum SaddleState { NOT_SADDLED, UNKNOWN, SADDLED } - private static final SaddleState[] SADDLE_STATES = SaddleState.values(); private static final boolean VARIANTS_ENABLED; - private static final Object[] variants; + private static final Object[] VARIANTS; + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"pig", SaddleState.UNKNOWN}, + {"saddled pig", SaddleState.SADDLED}, + {"unsaddled pig", SaddleState.NOT_SADDLED} + }); static { - EntityData.register(PigData.class, "pig", Pig.class, 1, "unsaddled pig", "pig", "saddled pig"); + EntityData.register(PigData.class, "pig", Pig.class, 0, PATTERNS.getPatterns()); if (Skript.classExists("org.bukkit.entity.Pig$Variant")) { VARIANTS_ENABLED = true; - variants = Iterators.toArray(Classes.getExactClassInfo(Pig.Variant.class).getSupplier().get(), Pig.Variant.class); + VARIANTS = Iterators.toArray(Classes.getExactClassInfo(Pig.Variant.class).getSupplier().get(), Pig.Variant.class); } else { VARIANTS_ENABLED = false; - variants = null; + VARIANTS = null; } } @@ -42,22 +46,15 @@ public PigData() {} public PigData(SaddleState saddled, @Nullable Object variant) { this.saddled = saddled; this.variant = variant; + super.dataCodeName = PATTERNS.getMatchedPatterns(saddled)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - saddled = SADDLE_STATES[matchedCodeName]; - if (VARIANTS_ENABLED) { - Literal expr = null; - if (exprs[0] != null) { // pig - expr = exprs[0]; - } else if (exprs[1] != null) { // piglet - expr = exprs[1]; - } - if (expr != null) { - //noinspection unchecked - variant = ((Literal) expr).getSingle(); - } + saddled = PATTERNS.getInfo(matchedCodeName); + if (VARIANTS_ENABLED && exprs[0] != null) { + //noinspection unchecked + variant = ((Literal) exprs[0]).getSingle(); } return true; } @@ -67,30 +64,28 @@ protected boolean init(@Nullable Class entityClass, @Nullable Pig saddled = SaddleState.UNKNOWN; if (pig != null) { saddled = pig.hasSaddle() ? SaddleState.SADDLED : SaddleState.NOT_SADDLED; + super.dataCodeName = PATTERNS.getMatchedPatterns(saddled)[0]; if (VARIANTS_ENABLED) variant = pig.getVariant(); } return true; } - - @Override - protected boolean deserialize(String string) { - return true; - } @Override public void set(Pig pig) { pig.setSaddle(saddled == SaddleState.SADDLED); if (VARIANTS_ENABLED) { - Object finalVariant = variant != null ? variant : CollectionUtils.getRandom(variants); + Object finalVariant = variant != null ? variant : CollectionUtils.getRandom(VARIANTS); + assert finalVariant != null; pig.setVariant((Pig.Variant) finalVariant); } } @Override protected boolean match(Pig pig) { - return (saddled == SaddleState.UNKNOWN || (pig.hasSaddle() ? SaddleState.SADDLED : SaddleState.NOT_SADDLED) == saddled) - && (variant == null || variant == pig.getVariant()); + if (saddled != SaddleState.UNKNOWN && pig.hasSaddle() != (saddled == SaddleState.SADDLED)) + return false; + return variant == null || variant == pig.getVariant(); } @Override @@ -99,8 +94,8 @@ public Class getType() { } @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof PigData other)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof PigData other)) return false; if (saddled != other.saddled) return false; @@ -122,7 +117,7 @@ public boolean isSupertypeOf(EntityData entityData) { } @Override - public @NotNull EntityData getSuperType() { + public @NotNull EntityData getSuperType() { return new PigData(); } diff --git a/src/main/java/ch/njol/skript/entity/RabbitData.java b/src/main/java/ch/njol/skript/entity/RabbitData.java index 8b1880da519..be6e8854218 100644 --- a/src/main/java/ch/njol/skript/entity/RabbitData.java +++ b/src/main/java/ch/njol/skript/entity/RabbitData.java @@ -1,53 +1,69 @@ package ch.njol.skript.entity; -import org.bukkit.entity.Rabbit; - -import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.coll.CollectionUtils; +import org.bukkit.entity.Rabbit; +import org.bukkit.entity.Rabbit.Type; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; public class RabbitData extends EntityData { - + + private static final Type[] TYPES = Type.values(); + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"rabbit", null}, + {"white rabbit", Type.WHITE}, + {"black rabbit", Type.BLACK}, + {"black and white rabbit", Type.BLACK_AND_WHITE}, + {"brown rabbit", Type.BROWN}, + {"gold rabbit", Type.GOLD}, + {"salt and pepper rabbit", Type.SALT_AND_PEPPER}, + {"killer rabbit", Type.THE_KILLER_BUNNY} + }); + static { - if(Skript.classExists("org.bukkit.entity.Rabbit")){ - EntityData.register(RabbitData.class, "rabbit", Rabbit.class, 0, "rabbit", "black rabbit", "black and white rabbit", - "brown rabbit", "gold rabbit", "salt and pepper rabbit", "killer rabbit", "white rabbit"); - } + EntityData.register(RabbitData.class, "rabbit", Rabbit.class, 0, PATTERNS.getPatterns()); } - private int type = 0; + private @Nullable Type type = null; public RabbitData() {} - public RabbitData(int type) { + public RabbitData(@Nullable Type type) { this.type = type; - super.matchedCodeName = type; + super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - type = matchedCodeName; + type = PATTERNS.getInfo(matchedCodeName); return true; } - @SuppressWarnings("null") @Override - protected boolean init(Class c, Rabbit rabbit) { - type = (rabbit == null) ? 0 : intFromType(rabbit.getRabbitType()); + protected boolean init(@Nullable Class entityClass, @Nullable Rabbit rabbit) { + if (rabbit != null) { + type = rabbit.getRabbitType(); + super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + } return true; } @Override - public void set(Rabbit entity) { - if (type != 0) - entity.setRabbitType(typeFromInt(type)); + public void set(Rabbit rabbit) { + Type type = this.type; + if (type == null) + type = CollectionUtils.getRandom(TYPES); + assert type != null; + rabbit.setRabbitType(type); } @Override - protected boolean match(Rabbit entity) { - return type == 0 || intFromType(entity.getRabbitType()) == type; + protected boolean match(Rabbit rabbit) { + return type == null || type == rabbit.getRabbitType(); } @Override @@ -56,78 +72,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new RabbitData(type); + public @NotNull EntityData getSuperType() { + return new RabbitData(); } @Override protected int hashCode_i() { - return type; + return type == null ? 1 : type.hashCode(); } @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof RabbitData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof RabbitData other)) return false; - final RabbitData other = (RabbitData) obj; return type == other.type; } @Override - public boolean isSupertypeOf(EntityData e) { - return e instanceof RabbitData && (type == 0 || ((RabbitData) e).type == type); - } - - private static Rabbit.Type typeFromInt(int i){ - switch(i){ - case 1: - return Rabbit.Type.BLACK; - case 2: - return Rabbit.Type.BLACK_AND_WHITE; - case 3: - return Rabbit.Type.BROWN; - case 4: - return Rabbit.Type.GOLD; - case 5: - return Rabbit.Type.SALT_AND_PEPPER; - case 6: - return Rabbit.Type.THE_KILLER_BUNNY; - case 7: - return Rabbit.Type.WHITE; - default: - break; - } - return Rabbit.Type.BLACK; - } - - private static int intFromType(Rabbit.Type type){ - int i = 0; - switch(type){ - case BLACK: - i = 1; - break; - case BLACK_AND_WHITE: - i = 2; - break; - case BROWN: - i = 3; - break; - case GOLD: - i = 4; - break; - case SALT_AND_PEPPER: - i = 5; - break; - case THE_KILLER_BUNNY: - i = 6; - break; - case WHITE: - i = 7; - break; - default: - break; - } - return i; + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof RabbitData other)) + return false; + return type == null || type == other.type; } } diff --git a/src/main/java/ch/njol/skript/entity/SalmonData.java b/src/main/java/ch/njol/skript/entity/SalmonData.java index e158f7244f7..b58af3643d0 100644 --- a/src/main/java/ch/njol/skript/entity/SalmonData.java +++ b/src/main/java/ch/njol/skript/entity/SalmonData.java @@ -5,60 +5,75 @@ import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Salmon; +import org.bukkit.entity.Salmon.Variant; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.ArrayList; -import java.util.List; -import java.util.Locale; - public class SalmonData extends EntityData { private static final boolean SUPPORT_SALMON_VARIANTS = Skript.classExists("org.bukkit.entity.Salmon$Variant"); - private static Object[] variants; + private static final Object[] VARIANTS; + private static final EntityPatterns PATTERNS; static { - List patternList = new ArrayList<>(); - patternList.add("salmon"); if (SUPPORT_SALMON_VARIANTS) { - variants = Salmon.Variant.values(); - patternList.add("any salmon"); - for (Object object : variants) { - Salmon.Variant variant = (Salmon.Variant) object; - patternList.add(variant.toString().replace("_", " ").toLowerCase(Locale.ENGLISH) + " salmon"); - } + VARIANTS = Salmon.Variant.values(); + PATTERNS = new EntityPatterns<>(new Object[][]{ + {"salmon", null}, + {"any salmon", null}, + {"small salmon", Variant.SMALL}, + {"medium salmon", Variant.MEDIUM}, + {"large salmon", Variant.LARGE} + }); + } else { + VARIANTS = null; + PATTERNS = new EntityPatterns<>(new Object[][]{ + {"salmon", null} + }); } - EntityData.register(SalmonData.class, "salmon", Salmon.class, 0, patternList.toArray(String[]::new)); + EntityData.register(SalmonData.class, "salmon", Salmon.class, 0, PATTERNS.getPatterns()); } - private @Nullable Object variant; + private @Nullable Object variant = null; + + public SalmonData() {} + + // TODO: When safe, 'variant' should have the type changed to 'Salmon.Variant' + public SalmonData(@Nullable Object variant) { + this.variant = variant; + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName > 1) - variant = variants[matchedCodeName - 2]; + variant = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class c, @Nullable Salmon salmon) { - if (salmon != null && SUPPORT_SALMON_VARIANTS) + protected boolean init(@Nullable Class entityClass, @Nullable Salmon salmon) { + if (salmon != null && SUPPORT_SALMON_VARIANTS) { variant = salmon.getVariant(); + super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + } return true; } @Override public void set(Salmon entity) { if (SUPPORT_SALMON_VARIANTS) { - Object variantSet = variant != null ? variant : CollectionUtils.getRandom(variants); - entity.setVariant((Salmon.Variant) variantSet); + Variant variant = (Variant) this.variant; + if (variant == null) + variant = (Variant) CollectionUtils.getRandom(VARIANTS); + assert variant != null; + entity.setVariant(variant); } } @Override protected boolean match(Salmon entity) { - return matchedCodeName <= 1 || variant == entity.getVariant(); + return variant == null || variant == entity.getVariant(); } @Override @@ -67,29 +82,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { + public @NotNull EntityData getSuperType() { return new SalmonData(); } @Override protected int hashCode_i() { - return matchedCodeName <= 1 ? 0 : matchedCodeName; + return variant == null ? 1 : variant.hashCode(); } @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof SalmonData salmonData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof SalmonData other)) return false; - if (matchedCodeName > 1 && variant != salmonData.variant) - return false; - return true; - } + return variant == null || variant == other.variant; + } @Override - public boolean isSupertypeOf(EntityData entity) { - if (entity instanceof SalmonData salmonData) - return matchedCodeName <= 1 || variant == salmonData.variant; - return false; + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof SalmonData other)) + return false; + return variant == null || variant == other.variant; } } diff --git a/src/main/java/ch/njol/skript/entity/SheepData.java b/src/main/java/ch/njol/skript/entity/SheepData.java index 6797dfd606f..a8c7361ddaf 100644 --- a/src/main/java/ch/njol/skript/entity/SheepData.java +++ b/src/main/java/ch/njol/skript/entity/SheepData.java @@ -1,11 +1,5 @@ package ch.njol.skript.entity; -import java.util.Arrays; - -import org.bukkit.entity.Sheep; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.util.SimpleExpression; @@ -16,6 +10,7 @@ import ch.njol.skript.util.SkriptColor; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Sheep; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.Arrays; @@ -24,149 +19,123 @@ * @author Peter Güttinger */ public class SheepData extends EntityData { + + public enum ShearState { + UNKNOWN, SHEARED, UNSHEARED + } + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"sheep", ShearState.UNKNOWN}, + {"sheared sheep", ShearState.SHEARED}, + {"unsheared sheep", ShearState.UNSHEARED} + }); + static { - EntityData.register(SheepData.class, "sheep", Sheep.class, 1, "unsheared sheep", "sheep", "sheared sheep"); + EntityData.register(SheepData.class, "sheep", Sheep.class, 0, PATTERNS.getPatterns()); } - - @Nullable - private Color[] colors; - private int sheared = 0; - - @SuppressWarnings("unchecked") + + private Color @Nullable [] colors; + private ShearState state = ShearState.UNKNOWN; + private Adjective @Nullable [] adjectives = null; + + public SheepData() {} + + public SheepData(@Nullable ShearState state, Color @Nullable [] colors) { + this.state = state != null ? state : ShearState.UNKNOWN; + this.colors = colors; + super.dataCodeName = PATTERNS.getMatchedPatterns(this.state)[0]; + } + @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - sheared = matchedCodeName - 1; - if (exprs[0] != null) + state = PATTERNS.getInfo(matchedCodeName); + if (exprs[0] != null) { + //noinspection unchecked colors = ((Literal) exprs[0]).getAll(); + } return true; } - - @SuppressWarnings("null") + @Override - protected boolean init(@Nullable Class c, @Nullable Sheep e) { - if (e != null) { - sheared = e.isSheared() ? 1 : -1; - colors = CollectionUtils.array(SkriptColor.fromDyeColor(e.getColor())); + protected boolean init(@Nullable Class entityClass, @Nullable Sheep sheep) { + state = ShearState.UNKNOWN; + if (sheep != null) { + state = sheep.isSheared() ? ShearState.SHEARED : ShearState.UNSHEARED; + colors = CollectionUtils.array(SkriptColor.fromDyeColor(sheep.getColor())); + super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; } return true; } - + @Override - public void set(final Sheep entity) { + public void set(Sheep entity) { if (colors != null) { - final Color c = CollectionUtils.getRandom(colors); - assert c != null; - entity.setColor(c.asDyeColor()); + Color color = CollectionUtils.getRandom(colors); + assert color != null; + entity.setColor(color.asDyeColor()); } } - + @Override - public boolean match(final Sheep entity) { - return (sheared == 0 || entity.isSheared() == (sheared == 1)) - && (colors == null || SimpleExpression.check(colors, c -> entity.getColor() == c.asDyeColor(), false, false)); + public boolean match(Sheep entity) { + if (state != ShearState.UNKNOWN && entity.isSheared() != (state == ShearState.SHEARED)) + return false; + return colors == null || SimpleExpression.check(colors, c -> entity.getColor() == c.asDyeColor(), false, false); } - + @Override public Class getType() { return Sheep.class; } - - @Nullable - private Adjective[] adjectives = null; - + @Override - public String toString(final int flags) { - final Color[] colors = this.colors; - if (colors == null) - return super.toString(flags); - Adjective[] adjectives = this.adjectives; - if (adjectives == null) { - this.adjectives = adjectives = new Adjective[colors.length]; - for (int i = 0; i < colors.length; i++) - if (colors[i] instanceof SkriptColor) - adjectives[i] = ((SkriptColor)colors[i]).getAdjective(); - } - final Noun name = getName(); - final Adjective age = getAgeAdjective(); - return name.getArticleWithSpace(flags) + (age == null ? "" : age.toString(name.getGender(), flags) + " ") - + Adjective.toString(adjectives, name.getGender(), flags, false) + " " + name.toString(flags & Language.NO_ARTICLE_MASK); + public @NotNull EntityData getSuperType() { + return new SheepData(); } - + @Override protected int hashCode_i() { - final int prime = 31; + int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(colors); - result = prime * result + sheared; + result = prime * result + state.hashCode(); return result; } - + @Override - protected boolean equals_i(final EntityData obj) { - if (!(obj instanceof SheepData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof SheepData other)) return false; - final SheepData other = (SheepData) obj; if (!Arrays.equals(colors, other.colors)) return false; - if (sheared != other.sheared) - return false; - return true; - } - -// if (colors != null) { -// final StringBuilder b = new StringBuilder(); -// b.append(sheared); -// b.append("|"); -// for (final Color c : colors) { -// if (b.length() != 0) -// b.append(","); -// b.append(c.name()); -// } -// return b.toString(); -// } else { -// return "" + sheared; -// } + return state == other.state; + } + @Override - protected boolean deserialize(final String s) { - final String[] split = s.split("\\|"); - final String sh; - if (split.length == 1) { - sh = s; - } else if (split.length == 2) { - sh = split[0]; - final String[] cs = split[1].split(","); - colors = new Color[cs.length]; - for (int i = 0; i < cs.length; i++) { - try { - final String c = cs[i]; - assert c != null; - assert colors != null; - colors[i] = SkriptColor.valueOf(c); - } catch (final IllegalArgumentException e) { - return false; - } - } - } else { + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof SheepData other)) return false; - } - try { - sheared = Integer.parseInt(sh); - return true; - } catch (final NumberFormatException e) { + if (state != ShearState.UNKNOWN && state != other.state) return false; - } + return colors == null || CollectionUtils.isSubset(colors, other.colors); } - - @Override - public boolean isSupertypeOf(final EntityData e) { - if (e instanceof SheepData) - return colors == null || CollectionUtils.isSubset(colors, ((SheepData) e).colors); - return false; - } - + @Override - public @NotNull EntityData getSuperType() { - return new SheepData(); + public String toString(int flags) { + Color[] colors = this.colors; + if (colors == null) + return super.toString(flags); + Adjective[] adjectives = this.adjectives; + if (adjectives == null) { + this.adjectives = adjectives = new Adjective[colors.length]; + for (int i = 0; i < colors.length; i++) + if (colors[i] instanceof SkriptColor skriptColor) + adjectives[i] = skriptColor.getAdjective(); + } + Noun name = getName(); + Adjective age = getAgeAdjective(); + return name.getArticleWithSpace(flags) + (age == null ? "" : age.toString(name.getGender(), flags) + " ") + + Adjective.toString(adjectives, name.getGender(), flags, false) + " " + name.toString(flags & Language.NO_ARTICLE_MASK); } - + } diff --git a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java index 64e034cd7a6..b657a0688fe 100644 --- a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java +++ b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java @@ -75,80 +75,100 @@ private static void addSuperEntity(String codeName, Class enti static { // Simple Entities - addSimpleEntity("arrow", Arrow.class); - addSimpleEntity("spectral arrow", SpectralArrow.class); - addSimpleEntity("tipped arrow", TippedArrow.class); - addSimpleEntity("blaze", Blaze.class); - addSimpleEntity("mooshroom", MushroomCow.class); - addSimpleEntity("cave spider", CaveSpider.class); - addSimpleEntity("dragon fireball", DragonFireball.class); - addSimpleEntity("egg", Egg.class); - addSimpleEntity("ender crystal", EnderCrystal.class); - addSimpleEntity("ender dragon", EnderDragon.class); - addSimpleEntity("ender pearl", EnderPearl.class); - addSimpleEntity("ender eye", EnderSignal.class); + + // Alpha + Beta + addSuperEntity("skeleton", Skeleton.class); + addSimpleEntity("tnt", TNTPrimed.class); + addSimpleEntity("spider", Spider.class); + addSimpleEntity("player", Player.class); + addSimpleEntity("lightning bolt", LightningStrike.class); + addSimpleEntity("giant", Giant.class); + addSimpleEntity("ghast", Ghast.class); + addSimpleEntity("fish hook", FishHook.class); + addSuperEntity("fireball", Fireball.class, Kleenean.TRUE); addSimpleEntity("small fireball", SmallFireball.class); addSimpleEntity("large fireball", LargeFireball.class); - addSuperEntity("fireball", Fireball.class, Kleenean.TRUE); - addSimpleEntity("fish hook", FishHook.class); - addSimpleEntity("ghast", Ghast.class); - addSimpleEntity("giant", Giant.class); - addSimpleEntity("iron golem", IronGolem.class); - addSimpleEntity("lightning bolt", LightningStrike.class); - addSimpleEntity("magma cube", MagmaCube.class); + addSimpleEntity("ender pearl", EnderPearl.class); + addSimpleEntity("ender dragon", EnderDragon.class); + addSimpleEntity("ender crystal", EnderCrystal.class); + addSimpleEntity("dragon fireball", DragonFireball.class); + addSimpleEntity("egg", Egg.class); + addSimpleEntity("cave spider", CaveSpider.class); + addSimpleEntity("arrow", Arrow.class); + + // 1.0 + addSimpleEntity("snow golem", Snowman.class); + addSimpleEntity("snowball", Snowball.class); addSimpleEntity("slime", Slime.class); - addSimpleEntity("painting", Painting.class); - addSimpleEntity("player", Player.class); + addSimpleEntity("magma cube", MagmaCube.class); + addSimpleEntity("ender eye", EnderSignal.class); + addSimpleEntity("mooshroom", MushroomCow.class); + addSimpleEntity("blaze", Blaze.class); + + // 1.2 addSimpleEntity("zombie pigman", PigZombie.class); - addSimpleEntity("silverfish", Silverfish.class); - addSimpleEntity("snowball", Snowball.class); - addSimpleEntity("snow golem", Snowman.class); - addSimpleEntity("spider", Spider.class); addSimpleEntity("bottle of enchanting", ThrownExpBottle.class); - addSimpleEntity("tnt", TNTPrimed.class); - addSimpleEntity("leash hitch", LeashHitch.class); - addSimpleEntity("item frame", ItemFrame.class); - addSimpleEntity("bat", Bat.class); - addSimpleEntity("witch", Witch.class); + addSimpleEntity("iron golem", IronGolem.class); + addSimpleEntity("ocelot", Ocelot.class); + + // 1.4 + addSimpleEntity("wither skeleton", WitherSkeleton.class); + addSimpleEntity("firework", Firework.class, Kleenean.TRUE); // bukkit marks fireworks as not spawnable, see https://hub.spigotmc.org/jira/browse/SPIGOT-7677 addSimpleEntity("wither", Wither.class); addSimpleEntity("wither skull", WitherSkull.class); - // bukkit marks fireworks as not spawnable - // see https://hub.spigotmc.org/jira/browse/SPIGOT-7677 - addSimpleEntity("firework", Firework.class, Kleenean.TRUE); - addSimpleEntity("endermite", Endermite.class); + addSimpleEntity("witch", Witch.class); + addSimpleEntity("bat", Bat.class); + addSimpleEntity("item frame", ItemFrame.class); + addSimpleEntity("painting", Painting.class); + + // 1.6 + addSimpleEntity("horse", Horse.class); + addSimpleEntity("skeleton horse", SkeletonHorse.class); + addSimpleEntity("undead horse", ZombieHorse.class); + addSimpleEntity("mule", Mule.class); + addSimpleEntity("donkey", Donkey.class); + addSimpleEntity("leash hitch", LeashHitch.class); + + // 1.8 + addSimpleEntity("elder guardian", ElderGuardian.class); + addSimpleEntity("normal guardian", Guardian.class); addSimpleEntity("armor stand", ArmorStand.class); + addSimpleEntity("endermite", Endermite.class); + addSimpleEntity("silverfish", Silverfish.class); + addSimpleEntity("tipped arrow", TippedArrow.class); + + // 1.9 + addSimpleEntity("area effect cloud", AreaEffectCloud.class); addSimpleEntity("shulker", Shulker.class); addSimpleEntity("shulker bullet", ShulkerBullet.class); - addSimpleEntity("polar bear", PolarBear.class); - addSimpleEntity("area effect cloud", AreaEffectCloud.class); - addSimpleEntity("wither skeleton", WitherSkeleton.class); - addSimpleEntity("stray", Stray.class); + addSimpleEntity("spectral arrow", SpectralArrow.class); + + // 1.10 addSimpleEntity("husk", Husk.class); - addSuperEntity("skeleton", Skeleton.class); + addSimpleEntity("stray", Stray.class); + addSimpleEntity("polar bear", PolarBear.class); + + // 1.11 + addSimpleEntity("llama", Llama.class); addSimpleEntity("llama spit", LlamaSpit.class); + addSimpleEntity("vindicator", Vindicator.class); + addSimpleEntity("vex", Vex.class); addSimpleEntity("evoker", Evoker.class); addSimpleEntity("evoker fangs", EvokerFangs.class); - addSimpleEntity("vex", Vex.class); - addSimpleEntity("vindicator", Vindicator.class); - addSimpleEntity("elder guardian", ElderGuardian.class); - addSimpleEntity("normal guardian", Guardian.class); - addSimpleEntity("donkey", Donkey.class); - addSimpleEntity("mule", Mule.class); - addSimpleEntity("llama", Llama.class); - addSimpleEntity("undead horse", ZombieHorse.class); - addSimpleEntity("skeleton horse", SkeletonHorse.class); - addSimpleEntity("horse", Horse.class); - addSimpleEntity("dolphin", Dolphin.class); - addSimpleEntity("phantom", Phantom.class); - addSimpleEntity("drowned", Drowned.class); - addSimpleEntity("turtle", Turtle.class); - addSimpleEntity("cod", Cod.class); - addSimpleEntity("puffer fish", PufferFish.class); - addSimpleEntity("tropical fish", TropicalFish.class); - addSimpleEntity("trident", Trident.class); + // 1.12 addSimpleEntity("illusioner", Illusioner.class); + // 1.13 + addSimpleEntity("trident", Trident.class); + addSimpleEntity("tropical fish", TropicalFish.class); + addSimpleEntity("puffer fish", PufferFish.class); + addSimpleEntity("cod", Cod.class); + addSimpleEntity("turtle", Turtle.class); + addSimpleEntity("drowned", Drowned.class); + addSimpleEntity("phantom", Phantom.class); + addSimpleEntity("dolphin", Dolphin.class); + // 1.14 addSimpleEntity("pillager", Pillager.class); addSimpleEntity("ravager", Ravager.class); @@ -275,7 +295,7 @@ public SimpleEntityData() { private SimpleEntityData(SimpleEntityDataInfo info) { assert info != null; this.info = info; - matchedCodeName = types.indexOf(info); + dataCodeName = types.indexOf(info); } public SimpleEntityData(Class entityClass) { @@ -294,7 +314,7 @@ public SimpleEntityData(Class entityClass) { } if (closestInfo != null) { this.info = closestInfo; - this.matchedCodeName = closestPattern; + this.dataCodeName = closestPattern; return; } throw new IllegalStateException(); @@ -315,7 +335,7 @@ public SimpleEntityData(Entity entity) { } if (closestInfo != null) { this.info = closestInfo; - this.matchedCodeName = closestPattern; + this.dataCodeName = closestPattern; return; } throw new IllegalStateException(); @@ -358,19 +378,29 @@ public boolean match(Entity entity) { public Class getType() { return info.c; } - + + @Override + public @NotNull EntityData getSuperType() { + return new SimpleEntityData(info); + } + @Override protected int hashCode_i() { return info.hashCode(); } - + @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof SimpleEntityData other)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof SimpleEntityData other)) return false; return info.equals(other.info); } + @Override + public boolean isSupertypeOf(EntityData entityData) { + return info.c == entityData.getType() || info.isSupertype && info.c.isAssignableFrom(entityData.getType()); + } + @Override public boolean canSpawn(@Nullable World world) { if (info.allowSpawning.isUnknown()) // unspecified, refer to default behavior @@ -386,7 +416,7 @@ public Fields serialize() throws NotSerializableException { fields.putObject("info.codeName", info.codeName); return fields; } - + @Override public void deserialize(Fields fields) throws StreamCorruptedException, NotSerializableException { String codeName = fields.getAndRemoveObject("info.codeName", String.class); @@ -399,33 +429,5 @@ public void deserialize(Fields fields) throws StreamCorruptedException, NotSeria } throw new StreamCorruptedException("Invalid SimpleEntityDataInfo code name " + codeName); } - - @Override - @Deprecated(since = "2.3.0", forRemoval = true) - protected boolean deserialize(String string) { - try { - Class c = Class.forName(string); - for (SimpleEntityDataInfo info : types) { - if (info.c == c) { - this.info = info; - return true; - } - } - return false; - } catch (ClassNotFoundException e) { - return false; - } - } - - @Override - public boolean isSupertypeOf(EntityData entityData) { - return info.c == entityData.getType() || info.isSupertype && info.c.isAssignableFrom(entityData.getType()); - } - - @Override - public @NotNull EntityData getSuperType() { - return new SimpleEntityData(info); - } - } diff --git a/src/main/java/ch/njol/skript/entity/StriderData.java b/src/main/java/ch/njol/skript/entity/StriderData.java index 561a57286a2..06c57ea2a0c 100644 --- a/src/main/java/ch/njol/skript/entity/StriderData.java +++ b/src/main/java/ch/njol/skript/entity/StriderData.java @@ -2,7 +2,6 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.util.Kleenean; import org.bukkit.entity.Strider; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -11,45 +10,53 @@ public class StriderData extends EntityData { + public enum ShiveringState { + UNKNOWN, WARM, COLD + } + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"strider", ShiveringState.UNKNOWN}, + {"warm strider", ShiveringState.WARM}, + {"shivering strider", ShiveringState.COLD} + }); + static { - register(StriderData.class, "strider", Strider.class, 1, - "warm strider", "strider", "shivering strider"); + register(StriderData.class, "strider", Strider.class, 0, PATTERNS.getPatterns()); } - private Kleenean shivering = Kleenean.UNKNOWN; + private ShiveringState state = ShiveringState.UNKNOWN; public StriderData() {} - public StriderData(Kleenean shivering) { - this.shivering = shivering; + public StriderData(@Nullable ShiveringState state) { + this.state = state != null ? state : ShiveringState.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - shivering = Kleenean.get(matchedCodeName - 1); + state = PATTERNS.getInfo(matchedCodeName); return true; } @Override protected boolean init(@Nullable Class entityClass, @Nullable Strider entity) { - shivering = Kleenean.get(entity == null ? 0 : (entity.isShivering() ? 1 : -1)); + state = ShiveringState.UNKNOWN; + if (entity != null) { + state = entity.isShivering() ? ShiveringState.COLD : ShiveringState.WARM; + super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + } return true; } @Override public void set(Strider entity) { - entity.setShivering(shivering.isTrue()); + entity.setShivering(state == ShiveringState.COLD); } @Override protected boolean match(Strider entity) { - return shivering.isUnknown() || (this.shivering.isTrue() == entity.isShivering()); - } - - @Override - public boolean isSupertypeOf(EntityData entityData) { - return entityData instanceof StriderData striderData - && (this.shivering.isUnknown() || striderData.shivering.is(shivering).isTrue()); + return state == ShiveringState.UNKNOWN || state == (entity.isShivering() ? ShiveringState.COLD : ShiveringState.WARM); } @Override @@ -58,29 +65,27 @@ public Class getType() { } @Override - public @NotNull EntityData getSuperType() { - return new StriderData(shivering); + public @NotNull EntityData getSuperType() { + return new StriderData(); } @Override protected int hashCode_i() { - return Objects.hash(shivering); + return Objects.hash(state); } @Override protected boolean equals_i(EntityData entityData) { - return entityData instanceof StriderData striderData - && striderData.shivering == this.shivering; + if (!(entityData instanceof StriderData other)) + return false; + return state == other.state; } @Override - public String toString(int flags) { - StringBuilder builder = new StringBuilder(); - switch (shivering) { - case TRUE -> builder.append("shivering "); - case FALSE -> builder.append("warm "); - }; - return builder.append("strider").toString(); + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof StriderData other)) + return false; + return state == ShiveringState.UNKNOWN || state == other.state; } } diff --git a/src/main/java/ch/njol/skript/entity/ThrownPotionData.java b/src/main/java/ch/njol/skript/entity/ThrownPotionData.java index b0acaf627b1..edce6349def 100644 --- a/src/main/java/ch/njol/skript/entity/ThrownPotionData.java +++ b/src/main/java/ch/njol/skript/entity/ThrownPotionData.java @@ -1,17 +1,5 @@ package ch.njol.skript.entity; -import java.util.Arrays; -import java.util.function.Consumer; - -import org.bukkit.Location; -import org.bukkit.Material; -import org.bukkit.entity.LingeringPotion; -import org.bukkit.entity.ThrownPotion; -import org.bukkit.inventory.ItemStack; -import org.bukkit.inventory.meta.ItemMeta; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - import ch.njol.skript.Skript; import ch.njol.skript.aliases.ItemType; import ch.njol.skript.lang.Literal; @@ -27,6 +15,7 @@ import org.bukkit.entity.ThrownPotion; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; +import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.skriptlang.skript.lang.converter.Converters; @@ -34,6 +23,7 @@ import java.util.function.Consumer; public class ThrownPotionData extends EntityData { + static { EntityData.register(ThrownPotionData.class, "thrown potion", ThrownPotion.class, "thrown potion"); } @@ -47,25 +37,27 @@ public class ThrownPotionData extends EntityData { private static final Material POTION = Material.POTION; private static final Material SPLASH_POTION = Material.SPLASH_POTION; private static final Material LINGER_POTION = Material.LINGERING_POTION; - - @Nullable - private ItemType[] types; + + private ItemType @Nullable [] types; @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs.length > 0 && exprs[0] != null) { - return (types = Converters.convert((ItemType[]) exprs[0].getAll(), ItemType.class, t -> { - // If the itemtype is a potion, lets make it a splash potion (required by Bukkit) - if (t.getMaterial() == POTION) { - ItemMeta meta = t.getItemMeta(); - ItemType itemType = new ItemType(SPLASH_POTION); - itemType.setItemMeta(meta); - return itemType; - } else if (t.getMaterial() != SPLASH_POTION && t.getMaterial() != LINGER_POTION) { + //noinspection unchecked + ItemType[] itemTypes = ((Literal) exprs[0]).getAll(); + types = Converters.convert(itemTypes, ItemType.class, itemType -> { + Material material = itemType.getMaterial(); + if (material == POTION) { + ItemMeta itemMeta = itemType.getItemMeta(); + ItemType splashItem = new ItemType(SPLASH_POTION); + splashItem.setItemMeta(itemMeta); + return splashItem; + } else if (material != SPLASH_POTION && material != LINGER_POTION) { return null; } - return t; - })).length != 0; // no error message - other things can be thrown as well + return itemType; + }); + return types.length != 0; } else { types = new ItemType[]{new ItemType(SPLASH_POTION)}; } @@ -73,19 +65,34 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(@Nullable Class c, @Nullable ThrownPotion e) { - if (e != null) { - ItemStack i = e.getItem(); - types = new ItemType[] {new ItemType(i)}; + protected boolean init(@Nullable Class entityClass, @Nullable ThrownPotion thrownPotion) { + if (thrownPotion != null) { + ItemStack itemStack = thrownPotion.getItem(); + types = new ItemType[] {new ItemType(itemStack)}; } return true; } - + + @Override + public void set(ThrownPotion thrownPotion) { + if (types != null) { + ItemType itemType = CollectionUtils.getRandom(types); + assert itemType != null; + ItemStack itemStack = itemType.getRandom(); + if (itemStack == null) + return; // Missing item, can't make thrown potion of it + if (LINGERING_POTION_ENTITY_USED && (LINGERING_POTION_ENTITY_CLASS.isInstance(thrownPotion) != (LINGER_POTION == itemStack.getType()))) + return; + thrownPotion.setItem(itemStack); + } + assert false; + } + @Override - protected boolean match(ThrownPotion entity) { + protected boolean match(ThrownPotion thrownPotion) { if (types != null) { - for (ItemType t : types) { - if (t.isOfType(entity.getItem())) + for (ItemType itemType : types) { + if (itemType.isOfType(thrownPotion.getItem())) return true; } return false; @@ -93,16 +100,47 @@ protected boolean match(ThrownPotion entity) { return true; } + @Override + public Class getType() { + return ThrownPotion.class; + } + + @Override + public @NotNull EntityData getSuperType() { + return new ThrownPotionData(); + } + + @Override + protected int hashCode_i() { + return Arrays.hashCode(types); + } + + @Override + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof ThrownPotionData other)) + return false; + return Arrays.equals(types, other.types); + } + + @Override + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof ThrownPotionData other)) + return false; + if (types == null) + return true; + return other.types != null && ItemType.isSubset(types, other.types); + } + @Override @SuppressWarnings({"unchecked", "rawtypes"}) public @Nullable ThrownPotion spawn(Location location, @Nullable Consumer consumer) { - ItemType t = CollectionUtils.getRandom(types); - assert t != null; - ItemStack i = t.getRandom(); - if (i == null) + ItemType itemType = CollectionUtils.getRandom(types); + assert itemType != null; + ItemStack itemStack = itemType.getRandom(); + if (itemStack == null) return null; - Class thrownPotionClass = (Class) (i.getType() == LINGER_POTION ? LINGERING_POTION_ENTITY_CLASS : ThrownPotion.class); + Class thrownPotionClass = (Class) (itemStack.getType() == LINGER_POTION ? LINGERING_POTION_ENTITY_CLASS : ThrownPotion.class); ThrownPotion potion; if (consumer != null) { potion = EntityData.spawn(location, thrownPotionClass, consumer); @@ -112,80 +150,21 @@ protected boolean match(ThrownPotion entity) { if (potion == null) return null; - potion.setItem(i); + potion.setItem(itemStack); return potion; } - @Override - public void set(ThrownPotion entity) { - if (types != null) { - ItemType t = CollectionUtils.getRandom(types); - assert t != null; - ItemStack i = t.getRandom(); - if (i == null) - return; // Missing item, can't make thrown potion of it - if (LINGERING_POTION_ENTITY_USED && (LINGERING_POTION_ENTITY_CLASS.isInstance(entity) != (LINGER_POTION == i.getType()))) - return; - entity.setItem(i); - } - assert false; - } - - @Override - public Class getType() { - return ThrownPotion.class; - } - - @Override - public @NotNull EntityData getSuperType() { - return new ThrownPotionData(); - } - - @Override - public boolean isSupertypeOf(EntityData e) { - if (!(e instanceof ThrownPotionData)) - return false; - ThrownPotionData d = (ThrownPotionData) e; - if (types != null) { - return d.types != null && ItemType.isSubset(types, d.types); - } - return true; - } - @Override public String toString(int flags) { ItemType[] types = this.types; if (types == null) return super.toString(flags); - StringBuilder b = new StringBuilder(); - b.append(Noun.getArticleWithSpace(types[0].getTypes().get(0).getGender(), flags)); - b.append(m_adjective.toString(types[0].getTypes().get(0).getGender(), flags)); - b.append(" "); - b.append(Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false)); - return "" + b.toString(); + StringBuilder builder = new StringBuilder(); + builder.append(Noun.getArticleWithSpace(types[0].getTypes().get(0).getGender(), flags)); + builder.append(m_adjective.toString(types[0].getTypes().get(0).getGender(), flags)); + builder.append(" "); + builder.append(Classes.toString(types, flags & Language.NO_ARTICLE_MASK, false)); + return builder.toString(); } - - // return ItemType.serialize(types); - @Override - @Deprecated(since = "2.3.0", forRemoval = true) - protected boolean deserialize(String s) { - throw new UnsupportedOperationException("old serialization is no longer supported"); -// if (s.isEmpty()) -// return true; -// types = ItemType.deserialize(s); -// return types != null; - } - - @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof ThrownPotionData)) - return false; - return Arrays.equals(types, ((ThrownPotionData) obj).types); - } - - @Override - protected int hashCode_i() { - return Arrays.hashCode(types); - } - + } diff --git a/src/main/java/ch/njol/skript/entity/TropicalFishData.java b/src/main/java/ch/njol/skript/entity/TropicalFishData.java index cf60a43fea9..694f11b199e 100644 --- a/src/main/java/ch/njol/skript/entity/TropicalFishData.java +++ b/src/main/java/ch/njol/skript/entity/TropicalFishData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Color; +import ch.njol.util.coll.CollectionUtils; import org.bukkit.DyeColor; import org.bukkit.entity.TropicalFish; import org.bukkit.entity.TropicalFish.Pattern; @@ -10,36 +11,44 @@ import org.jetbrains.annotations.Nullable; import java.util.Objects; -import java.util.concurrent.ThreadLocalRandom; public class TropicalFishData extends EntityData { - private static final Pattern[] patterns = Pattern.values(); + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"tropical fish", null}, + {"kob", Pattern.KOB}, + {"sunstreak", Pattern.SUNSTREAK}, + {"snooper", Pattern.SNOOPER}, + {"dasher", Pattern.DASHER}, + {"brinely", Pattern.BRINELY}, + {"spotty", Pattern.SPOTTY}, + {"flopper", Pattern.FLOPPER}, + {"stripey", Pattern.STRIPEY}, + {"glitter", Pattern.GLITTER}, + {"blockfish", Pattern.BLOCKFISH}, + {"betty", Pattern.BETTY}, + {"clayfish", Pattern.CLAYFISH}, + }); + private static final Pattern[] FISH_PATTERNS = Pattern.values(); static { - register(TropicalFishData.class, "tropical fish", TropicalFish.class, 12, - "kob", "sunstreak", "snooper", "dasher", - "brinely", "spotty", "flopper", "stripey", - "glitter", "blockfish", "betty", "clayfish", "tropical fish"); + register(TropicalFishData.class, "tropical fish", TropicalFish.class, 0, PATTERNS.getPatterns()); } - public TropicalFishData() { - this(0); - } + private @Nullable DyeColor patternColor; + private @Nullable DyeColor bodyColor; + private @Nullable Pattern fishPattern = null; - public TropicalFishData(Pattern pattern) { - matchedCodeName = pattern.ordinal(); - } + public TropicalFishData() {} - private TropicalFishData(int pattern) { - matchedCodeName = pattern; + public TropicalFishData(@Nullable Pattern fishPattern) { + this.fishPattern = fishPattern; + super.dataCodeName = PATTERNS.getMatchedPatterns(fishPattern)[0]; } - private @Nullable DyeColor patternColor; - private @Nullable DyeColor bodyColor; - @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { + fishPattern = PATTERNS.getInfo(matchedCodeName); if (exprs.length == 0) return true; // FIXME aliases reloading must work @@ -47,10 +56,10 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte if (exprs[0] != null) { //noinspection unchecked bodyColor = ((Literal) exprs[0]).getSingle().asDyeColor(); - } - if (exprs[1] != null) { - //noinspection unchecked - patternColor = ((Literal) exprs[1]).getSingle().asDyeColor(); + if (exprs[1] != null) { + //noinspection unchecked + patternColor = ((Literal) exprs[1]).getSingle().asDyeColor(); + } } } else if (exprs[0] != null) { //noinspection unchecked @@ -64,20 +73,21 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @Override protected boolean init(@Nullable Class entityClass, @Nullable TropicalFish tropicalFish) { if (tropicalFish != null) { - matchedCodeName = tropicalFish.getPattern().ordinal(); bodyColor = tropicalFish.getBodyColor(); patternColor = tropicalFish.getPatternColor(); + fishPattern = tropicalFish.getPattern(); + super.dataCodeName = PATTERNS.getMatchedPatterns(fishPattern)[0]; } return true; } @Override public void set(TropicalFish tropicalFish) { - if (matchedCodeName == patterns.length) { - tropicalFish.setPattern(patterns[ThreadLocalRandom.current().nextInt(patterns.length)]); - } else { - tropicalFish.setPattern(patterns[matchedCodeName]); - } + Pattern fishPattern = this.fishPattern; + if (fishPattern == null) + fishPattern = CollectionUtils.getRandom(FISH_PATTERNS); + assert fishPattern != null; + tropicalFish.setPattern(fishPattern); if (bodyColor != null) tropicalFish.setBodyColor(bodyColor); @@ -87,14 +97,11 @@ public void set(TropicalFish tropicalFish) { @Override protected boolean match(TropicalFish tropicalFish) { - boolean samePattern = matchedCodeName == patterns.length || matchedCodeName == tropicalFish.getPattern().ordinal(); - boolean sameBody = bodyColor == null || bodyColor == tropicalFish.getBodyColor(); - - if (patternColor == null) { - return samePattern && sameBody; - } else { - return samePattern && sameBody && patternColor == tropicalFish.getPatternColor(); - } + if (bodyColor != null && bodyColor != tropicalFish.getBodyColor()) + return false; + if (patternColor != null && patternColor != tropicalFish.getPatternColor()) + return false; + return fishPattern == null || fishPattern == tropicalFish.getPattern(); } @Override @@ -103,31 +110,35 @@ public Class getType() { } @Override - protected boolean equals_i(EntityData entityData) { - if (!(entityData instanceof TropicalFishData fishData)) - return false; - - return matchedCodeName == fishData.matchedCodeName - && bodyColor == fishData.bodyColor && patternColor == fishData.patternColor; + public @NotNull EntityData getSuperType() { + return new TropicalFishData(); } @Override protected int hashCode_i() { - return Objects.hash(matchedCodeName, bodyColor, patternColor); + return Objects.hash(fishPattern, bodyColor, patternColor); } @Override - public boolean isSupertypeOf(EntityData entityData) { - if (!(entityData instanceof TropicalFishData fishData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof TropicalFishData other)) return false; - return matchedCodeName == fishData.matchedCodeName - && bodyColor == fishData.bodyColor && patternColor == fishData.patternColor; + return fishPattern == other.fishPattern + && bodyColor == other.bodyColor + && patternColor == other.patternColor; } @Override - public @NotNull EntityData getSuperType() { - return new TropicalFishData(matchedCodeName); + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof TropicalFishData other)) + return false; + + if (bodyColor != null && bodyColor != other.bodyColor) + return false; + if (patternColor != null && patternColor != other.patternColor) + return false; + return fishPattern == null || fishPattern == other.fishPattern; } } diff --git a/src/main/java/ch/njol/skript/entity/VillagerData.java b/src/main/java/ch/njol/skript/entity/VillagerData.java index 65cf69b5923..6c054663ccc 100644 --- a/src/main/java/ch/njol/skript/entity/VillagerData.java +++ b/src/main/java/ch/njol/skript/entity/VillagerData.java @@ -9,9 +9,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.Arrays; import java.util.Collections; -import java.util.List; import java.util.Objects; public class VillagerData extends EntityData { @@ -20,18 +18,30 @@ public class VillagerData extends EntityData { * Professions can be for zombies also. These are the ones which are only * for villagers. */ - private static final List professions; + private static final Profession[] PROFESSIONS = Profession.values(); + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"villager", null}, + {"normal", Profession.NONE}, + {"armorer", Profession.ARMORER}, + {"butcher", Profession.BUTCHER}, + {"cartographer", Profession.CARTOGRAPHER}, + {"cleric", Profession.CLERIC}, + {"farmer", Profession.FARMER}, + {"fisherman", Profession.FISHERMAN}, + {"fletcher", Profession.FLETCHER}, + {"leatherworker", Profession.LEATHERWORKER}, + {"librarian", Profession.LIBRARIAN}, + {"mason", Profession.MASON}, + {"nitwit", Profession.NITWIT}, + {"shepherd", Profession.SHEPHERD}, + {"toolsmith", Profession.TOOLSMITH}, + {"weaponsmith", Profession.WEAPONSMITH} + }); static { Variables.yggdrasil.registerSingleClass(Profession.class, "Villager.Profession"); - EntityData.register(VillagerData.class, "villager", Villager.class, 0, - "villager", "normal", "armorer", "butcher", "cartographer", "cleric", "farmer", "fisherman", - "fletcher", "leatherworker", "librarian", "mason", "nitwit", "shepherd", "toolsmith", "weaponsmith"); - professions = Arrays.asList(Profession.NONE, Profession.ARMORER, Profession.BUTCHER, Profession.CARTOGRAPHER, - Profession.CLERIC, Profession.FARMER, Profession.FISHERMAN, Profession.FLETCHER, Profession.LEATHERWORKER, - Profession.LIBRARIAN, Profession.MASON, Profession.NITWIT, Profession.SHEPHERD, Profession.TOOLSMITH, - Profession.WEAPONSMITH); + EntityData.register(VillagerData.class, "villager", Villager.class, 0, PATTERNS.getPatterns()); } private @Nullable Profession profession = null; @@ -40,27 +50,31 @@ public VillagerData() {} public VillagerData(@Nullable Profession profession) { this.profession = profession; - this.matchedCodeName = profession != null ? professions.indexOf(profession) + 1 : 0; + super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName > 0) - profession = professions.get(matchedCodeName - 1); + profession = PATTERNS.getInfo(matchedCodeName); return true; } @Override protected boolean init(@Nullable Class villagerClass, @Nullable Villager villager) { - profession = villager == null ? null : villager.getProfession(); + if (villager != null) { + profession = villager.getProfession(); + super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; + } return true; } @Override public void set(Villager villager) { - Profession prof = profession == null ? CollectionUtils.getRandom(professions) : profession; - assert prof != null; - villager.setProfession(prof); + Profession profession = this.profession; + if (profession == null) + profession = CollectionUtils.getRandom(PROFESSIONS); + assert profession != null; + villager.setProfession(profession); if (profession == Profession.NITWIT) villager.setRecipes(Collections.emptyList()); } @@ -69,48 +83,34 @@ public void set(Villager villager) { protected boolean match(Villager villager) { return profession == null || villager.getProfession() == profession; } - + @Override public Class getType() { return Villager.class; } - + @Override - protected int hashCode_i() { - return Objects.hashCode(profession); + public @NotNull EntityData getSuperType() { + return new VillagerData(); } - + @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof VillagerData villagerData)) - return false; - return profession == villagerData.profession; + protected int hashCode_i() { + return Objects.hashCode(profession); } - -// return profession == null ? "" : profession.name(); + @Override - protected boolean deserialize(final String s) { - if (s.isEmpty()) - return true; - try { - //noinspection unchecked, rawtypes - prevent IncompatibleClassChangeError due to Enum->Interface change - profession = (Profession) Enum.valueOf((Class) Profession.class, s); - return true; - } catch (final IllegalArgumentException e) { + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof VillagerData other)) return false; - } + return profession == other.profession; } - + @Override public boolean isSupertypeOf(EntityData entityData) { - if (entityData instanceof VillagerData villagerData) - return profession == null || profession.equals(villagerData.profession); - return false; - } - - @Override - public @NotNull EntityData getSuperType() { - return new VillagerData(profession); + if (!(entityData instanceof VillagerData other)) + return false; + return profession == null || profession.equals(other.profession); } - + } diff --git a/src/main/java/ch/njol/skript/entity/WolfData.java b/src/main/java/ch/njol/skript/entity/WolfData.java index ff75e04dcc0..4a4170bdebf 100644 --- a/src/main/java/ch/njol/skript/entity/WolfData.java +++ b/src/main/java/ch/njol/skript/entity/WolfData.java @@ -16,21 +16,24 @@ public class WolfData extends EntityData { - private static boolean variantsEnabled = false; + private static final boolean VARIANTS_ENABLED; + private static final Object[] VARIANTS; + static { EntityData.register(WolfData.class, "wolf", Wolf.class, 1, "peaceful wolf", "wolf", "angry wolf", "wild wolf", "tamed wolf"); if (Skript.classExists("org.bukkit.entity.Wolf$Variant")) { - variantsEnabled = true; - variants = Iterators.toArray(Classes.getExactClassInfo(Wolf.Variant.class).getSupplier().get(), Wolf.Variant.class); + VARIANTS_ENABLED = true; + VARIANTS = Iterators.toArray(Classes.getExactClassInfo(Wolf.Variant.class).getSupplier().get(), Wolf.Variant.class); + } else { + VARIANTS_ENABLED = false; + VARIANTS = null; } } - private static Object[] variants; - private @Nullable Object variant; private @Nullable DyeColor collarColor; @@ -45,7 +48,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } else { tamed = matchedCodeName == 3 ? -1 : 1; } - if (exprs[0] != null && variantsEnabled) + if (exprs[0] != null && VARIANTS_ENABLED) variant = ((Literal) exprs[0]).getSingle(); if (exprs[1] != null) collarColor = ((Literal) exprs[1]).getSingle().asDyeColor(); @@ -53,12 +56,12 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte } @Override - protected boolean init(@Nullable Class c, @Nullable Wolf wolf) { + protected boolean init(@Nullable Class entityClass, @Nullable Wolf wolf) { if (wolf != null) { angry = wolf.isAngry() ? 1 : -1; tamed = wolf.isTamed() ? 1 : -1; collarColor = wolf.getCollarColor(); - if (variantsEnabled) + if (VARIANTS_ENABLED) variant = wolf.getVariant(); } return true; @@ -73,8 +76,8 @@ public void set(Wolf entity) { if (collarColor != null) entity.setCollarColor(collarColor); Object variantSet = null; - if (variantsEnabled) { - variantSet = variant != null ? variant : CollectionUtils.getRandom(variants); + if (VARIANTS_ENABLED) { + variantSet = variant != null ? variant : CollectionUtils.getRandom(VARIANTS); entity.setVariant((Wolf.Variant) variantSet); } } @@ -90,65 +93,47 @@ public Class getType() { return Wolf.class; } + @Override + public @NotNull EntityData getSuperType() { + return new WolfData(); + } + @Override protected int hashCode_i() { int prime = 31, result = 1; result = prime * result + angry; result = prime * result + tamed; result = prime * result + (collarColor == null ? 0 : collarColor.hashCode()); - if (variantsEnabled) + if (VARIANTS_ENABLED) result = prime * result + (variant == null ? 0 : Objects.hashCode(variant)); return result; } @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof WolfData)) + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof WolfData)) return false; - WolfData other = (WolfData) obj; + WolfData other = (WolfData) entityData; if (angry != other.angry) return false; if (tamed != other.tamed) return false; if (collarColor != other.collarColor) return false; - if (variantsEnabled && variant != other.variant) + if (VARIANTS_ENABLED && variant != other.variant) return false; return true; } - /** - * Note that this method is only used when changing Skript versions 2.1 to anything above. - */ - @Deprecated(since = "2.3.0", forRemoval = true) - @Override - protected boolean deserialize(String s) { - String[] split = s.split("\\|"); - if (split.length != 2) - return false; - try { - angry = Integer.parseInt(split[0]); - tamed = Integer.parseInt(split[1]); - return true; - } catch (NumberFormatException e) { - return false; - } - } - @Override public boolean isSupertypeOf(EntityData entityData) { if (entityData instanceof WolfData) { WolfData wolfData = (WolfData) entityData; - return (angry == 0 || wolfData.angry == angry) && (tamed == 0 || wolfData.tamed == tamed) && (wolfData.collarColor == collarColor) && (!variantsEnabled || wolfData.variant == variant); + return (angry == 0 || wolfData.angry == angry) && (tamed == 0 || wolfData.tamed == tamed) && (wolfData.collarColor == collarColor) && (!VARIANTS_ENABLED || wolfData.variant == variant); } return false; } - @Override - public @NotNull EntityData getSuperType() { - return new WolfData(); - } - /** * A dummy/placeholder class to ensure working operation on MC versions that do not have `Wolf.Variant` */ diff --git a/src/main/java/ch/njol/skript/entity/XpOrbData.java b/src/main/java/ch/njol/skript/entity/XpOrbData.java index a99a7c0fa2d..35cc44edef7 100644 --- a/src/main/java/ch/njol/skript/entity/XpOrbData.java +++ b/src/main/java/ch/njol/skript/entity/XpOrbData.java @@ -1,59 +1,85 @@ package ch.njol.skript.entity; -import java.util.function.Consumer; - +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.localization.ArgsMessage; import org.bukkit.Location; import org.bukkit.entity.ExperienceOrb; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.skript.localization.ArgsMessage; +import java.util.function.Consumer; public class XpOrbData extends EntityData { + + private final static ArgsMessage FORMAT = new ArgsMessage("entities.xp-orb.format"); + static { EntityData.register(XpOrbData.class, "xporb", ExperienceOrb.class, "xp-orb"); } - + private int xp = -1; - + public XpOrbData() {} - - public XpOrbData(final int xp) { + + public XpOrbData(int xp) { this.xp = xp; } - + @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { return true; } - + @Override - protected boolean init(final @Nullable Class c, final @Nullable ExperienceOrb e) { - xp = e == null ? -1 : e.getExperience(); + protected boolean init(@Nullable Class entityClass, @Nullable ExperienceOrb orb) { + if (orb != null) + xp = orb.getExperience(); return true; } - + + @Override + public void set(ExperienceOrb orb) { + if (xp != -1) + orb.setExperience(xp + orb.getExperience()); + } + + @Override + protected boolean match(ExperienceOrb orb) { + return xp == -1 || orb.getExperience() == xp; + } + @Override public Class getType() { return ExperienceOrb.class; } - + @Override - protected boolean match(final ExperienceOrb entity) { - return xp == -1 || entity.getExperience() == xp; + public @NotNull EntityData getSuperType() { + return new XpOrbData(); } - + @Override - public void set(final ExperienceOrb entity) { - if (xp != -1) - entity.setExperience(xp + entity.getExperience()); + protected int hashCode_i() { + return xp; + } + + @Override + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof XpOrbData other)) + return false; + return xp == other.xp; } @Override - @Nullable - public ExperienceOrb spawn(Location loc, @Nullable Consumer consumer) { + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof XpOrbData other)) + return false; + return xp == -1 || other.xp == xp; + } + + @Override + public @Nullable ExperienceOrb spawn(Location loc, @Nullable Consumer consumer) { ExperienceOrb orb = super.spawn(loc, consumer); if (orb == null) return null; @@ -62,55 +88,17 @@ public ExperienceOrb spawn(Location loc, @Nullable Consumer consu return orb; } - private final static ArgsMessage format = new ArgsMessage("entities.xp-orb.format"); - @Override public String toString(final int flags) { - return xp == -1 ? super.toString(flags) : format.toString(super.toString(flags), xp); + return xp == -1 ? super.toString(flags) : FORMAT.toString(super.toString(flags), xp); } - + public int getExperience() { return xp == -1 ? 1 : xp; } - + public int getInternalExperience() { return xp; } - - @Override - protected int hashCode_i() { - return xp; - } - - @Override - protected boolean equals_i(final EntityData obj) { - if (!(obj instanceof XpOrbData)) - return false; - final XpOrbData other = (XpOrbData) obj; - return xp == other.xp; - } - -// return "" + xp; - @Override - protected boolean deserialize(final String s) { - try { - xp = Integer.parseInt(s); - return true; - } catch (final NumberFormatException e) { - return false; - } - } - - @Override - public boolean isSupertypeOf(final EntityData e) { - if (e instanceof XpOrbData) - return xp == -1 || ((XpOrbData) e).xp == xp; - return false; - } - - @Override - public @NotNull EntityData getSuperType() { - return new XpOrbData(); - } - + } diff --git a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java index b0a57f9aedc..4468dbd3b0f 100644 --- a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java +++ b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java @@ -1,6 +1,5 @@ package ch.njol.skript.entity; -import ch.njol.skript.SkriptAPIException; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.util.coll.CollectionUtils; @@ -9,23 +8,32 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.Arrays; -import java.util.List; import java.util.Objects; public class ZombieVillagerData extends EntityData { - private static final List professions; + private static final Profession[] PROFESSIONS = Profession.values(); + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"zombie villager", null}, + {"zombie normal", Profession.NONE}, + {"zombie armorer", Profession.ARMORER}, + {"zombie butcher", Profession.BUTCHER}, + {"zombie cartographer", Profession.CARTOGRAPHER}, + {"zombie cleric", Profession.CLERIC}, + {"zombie farmer", Profession.FARMER}, + {"zombie fisherman", Profession.FISHERMAN}, + {"zombie fletcher", Profession.FLETCHER}, + {"zombie leatherworker", Profession.LEATHERWORKER}, + {"zombie librarian", Profession.LIBRARIAN}, + {"zombie mason", Profession.MASON}, + {"zombie nitwit", Profession.NITWIT}, + {"zombie shepherd", Profession.SHEPHERD}, + {"zombie toolsmith", Profession.TOOLSMITH}, + {"zombie weaponsmith", Profession.WEAPONSMITH} + }); static { - EntityData.register(ZombieVillagerData.class, "zombie villager", ZombieVillager.class, 0, - "zombie villager", "zombie normal", "zombie armorer", "zombie butcher", "zombie cartographer", - "zombie cleric", "zombie farmer", "zombie fisherman", "zombie fletcher", "zombie leatherworker", - "zombie librarian", "zombie mason", "zombie nitwit", "zombie shepherd", "zombie toolsmith", "zombie weaponsmith"); - professions = Arrays.asList(Profession.NONE, Profession.ARMORER, Profession.BUTCHER, Profession.CARTOGRAPHER, - Profession.CLERIC, Profession.FARMER, Profession.FISHERMAN, Profession.FLETCHER, Profession.LEATHERWORKER, - Profession.LIBRARIAN, Profession.MASON, Profession.NITWIT, Profession.SHEPHERD, Profession.TOOLSMITH, - Profession.WEAPONSMITH); + EntityData.register(ZombieVillagerData.class, "zombie villager", ZombieVillager.class, 0, PATTERNS.getPatterns()); } private @Nullable Profession profession = null; @@ -34,40 +42,31 @@ public ZombieVillagerData() {} public ZombieVillagerData(@Nullable Profession profession) { this.profession = profession; - super.matchedCodeName = profession != null ? professions.indexOf(profession) + 1 : 0; + super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName > 0) - profession = professions.get(matchedCodeName - 1); + profession = PATTERNS.getInfo(matchedCodeName); return true; } - - @SuppressWarnings("null") - @Override - protected boolean init(@Nullable Class zombieClass, @Nullable ZombieVillager zombieVillager) { - profession = zombieVillager == null ? null : zombieVillager.getVillagerProfession(); - return true; - } - - @SuppressWarnings("null") + @Override - protected boolean deserialize(final String s) { - try { - profession = professions.get(Integer.parseInt(s)); - } catch (NumberFormatException | IndexOutOfBoundsException e) { - throw new SkriptAPIException("Cannot parse zombie villager type " + s); + protected boolean init(@Nullable Class entityClass, @Nullable ZombieVillager zombieVillager) { + if (zombieVillager != null) { + profession = zombieVillager.getVillagerProfession(); + super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; } - return true; } @Override public void set(ZombieVillager zombieVillager) { - Profession prof = profession == null ? CollectionUtils.getRandom(professions) : profession; - assert prof != null; - zombieVillager.setVillagerProfession(prof); + Profession profession = this.profession; + if (profession == null) + profession = CollectionUtils.getRandom(PROFESSIONS); + assert profession != null; + zombieVillager.setVillagerProfession(profession); } @Override @@ -79,29 +78,29 @@ protected boolean match(ZombieVillager zombieVillager) { public Class getType() { return ZombieVillager.class; } - + @Override - protected boolean equals_i(EntityData obj) { - if (!(obj instanceof ZombieVillagerData zombieVillagerData)) - return false; - return profession == null || profession.equals(zombieVillagerData.profession); + public @NotNull EntityData getSuperType() { + return new ZombieVillagerData(); } - + @Override protected int hashCode_i() { return Objects.hashCode(profession); } - + @Override - public boolean isSupertypeOf(EntityData entityData) { - if (entityData instanceof ZombieVillagerData zombieVillagerData) - return profession == null || profession.equals(zombieVillagerData.profession); - return false; + protected boolean equals_i(EntityData entityData) { + if (!(entityData instanceof ZombieVillagerData other)) + return false; + return profession == null || profession.equals(other.profession); } - + @Override - public @NotNull EntityData getSuperType() { - return new ZombieVillagerData(profession); + public boolean isSupertypeOf(EntityData entityData) { + if (!(entityData instanceof ZombieVillagerData other)) + return false; + return profession == null || profession.equals(other.profession); } } diff --git a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java index 08abefebd92..9a201a7d8fc 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java +++ b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java @@ -81,7 +81,7 @@ public DisplayData() {} public DisplayData(DisplayType type) { this.type = type; - this.matchedCodeName = type.ordinal(); + this.dataCodeName = type.ordinal(); } @Override @@ -196,8 +196,8 @@ protected int hashCode_i() { } @Override - protected boolean equals_i(EntityData obj) { - if (obj instanceof DisplayData other) + protected boolean equals_i(EntityData entityData) { + if (entityData instanceof DisplayData other) return type == other.type; return false; } diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index 3eda30d76ad..d0c750a2e8b 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -724,7 +724,9 @@ entities: 1: [mine]cart[plural:s] with command block[s] mooshroom: name: mooshroom¦s - pattern: (mooshroom[ cow]|mushroom cow)[plural:s] + patterns: + 0: (mooshroom[ cow]|mushroom cow)[plural:s] + 1: baby:(mooshroom|mushroom) cal(f|plural:ves) red mooshroom: name: red mooshroom¦s patterns: @@ -947,7 +949,7 @@ entities: name: falling block¦s patterns: 0: falling block[plural:s] - 1: unknown_plural:falling %-itemtype% + 1: unknown_plural:falling %-itemtype% [block[s]] adjective: falling not a block error: Falling blocks must be blocks, not items thrown potion: @@ -1548,7 +1550,9 @@ entities: # 1.21.6 Entities happy ghast: name: happy ghast¦s - pattern: happy ghast[plural:s]|baby:[happy] ghastling[plural:s] + patterns: + 0: happy ghast[plural:s] + 1: baby:[happy] ghastling[plural:s] # -- Heal Reasons -- heal reasons: From 3e9879ebceb968326daa78397d6818b0662b6803 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Mon, 30 Jun 2025 21:13:19 -0400 Subject: [PATCH 09/21] Enum->Interface Fixes --- src/main/java/ch/njol/skript/entity/FrogData.java | 5 ++++- src/main/java/ch/njol/skript/entity/VillagerData.java | 7 ++++++- .../java/ch/njol/skript/entity/ZombieVillagerData.java | 7 ++++++- 3 files changed, 16 insertions(+), 3 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/FrogData.java b/src/main/java/ch/njol/skript/entity/FrogData.java index 5a59f46a668..39c030e05b5 100644 --- a/src/main/java/ch/njol/skript/entity/FrogData.java +++ b/src/main/java/ch/njol/skript/entity/FrogData.java @@ -8,6 +8,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.List; import java.util.Objects; public class FrogData extends EntityData { @@ -18,10 +19,12 @@ public class FrogData extends EntityData { {"warm frog", Variant.WARM}, {"cold frog", Variant.COLD} }); - private static final Variant[] VARIANTS = Variant.values(); + + private static final Variant[] VARIANTS; static { EntityData.register(FrogData.class, "frog", Frog.class, 0, PATTERNS.getPatterns()); + VARIANTS = List.of(Variant.TEMPERATE, Variant.WARM, Variant.COLD).toArray(Variant[]::new); } private @Nullable Variant variant = null; diff --git a/src/main/java/ch/njol/skript/entity/VillagerData.java b/src/main/java/ch/njol/skript/entity/VillagerData.java index 6c054663ccc..a2b01e5c73f 100644 --- a/src/main/java/ch/njol/skript/entity/VillagerData.java +++ b/src/main/java/ch/njol/skript/entity/VillagerData.java @@ -10,6 +10,7 @@ import org.jetbrains.annotations.Nullable; import java.util.Collections; +import java.util.List; import java.util.Objects; public class VillagerData extends EntityData { @@ -18,7 +19,7 @@ public class VillagerData extends EntityData { * Professions can be for zombies also. These are the ones which are only * for villagers. */ - private static final Profession[] PROFESSIONS = Profession.values(); + private static final Profession[] PROFESSIONS; private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ {"villager", null}, {"normal", Profession.NONE}, @@ -42,6 +43,10 @@ public class VillagerData extends EntityData { Variables.yggdrasil.registerSingleClass(Profession.class, "Villager.Profession"); EntityData.register(VillagerData.class, "villager", Villager.class, 0, PATTERNS.getPatterns()); + PROFESSIONS = List.of(Profession.NONE, Profession.ARMORER, Profession.BUTCHER, Profession.CARTOGRAPHER, + Profession.CLERIC, Profession.FARMER, Profession.FISHERMAN, Profession.FLETCHER, Profession.LEATHERWORKER, + Profession.LIBRARIAN, Profession.MASON, Profession.NITWIT, Profession.SHEPHERD, Profession.TOOLSMITH, + Profession.WEAPONSMITH).toArray(Profession[]::new); } private @Nullable Profession profession = null; diff --git a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java index 4468dbd3b0f..407ad72d7fc 100644 --- a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java +++ b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java @@ -8,11 +8,12 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.List; import java.util.Objects; public class ZombieVillagerData extends EntityData { - private static final Profession[] PROFESSIONS = Profession.values(); + private static final Profession[] PROFESSIONS; private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ {"zombie villager", null}, {"zombie normal", Profession.NONE}, @@ -34,6 +35,10 @@ public class ZombieVillagerData extends EntityData { static { EntityData.register(ZombieVillagerData.class, "zombie villager", ZombieVillager.class, 0, PATTERNS.getPatterns()); + PROFESSIONS = List.of(Profession.NONE, Profession.ARMORER, Profession.BUTCHER, Profession.CARTOGRAPHER, + Profession.CLERIC, Profession.FARMER, Profession.FISHERMAN, Profession.FLETCHER, Profession.LEATHERWORKER, + Profession.LIBRARIAN, Profession.MASON, Profession.NITWIT, Profession.SHEPHERD, Profession.TOOLSMITH, + Profession.WEAPONSMITH).toArray(Profession[]::new); } private @Nullable Profession profession = null; From 40e1d0ca784097439df2a520361c1b8dddb3c16e Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 3 Jul 2025 05:53:39 -0400 Subject: [PATCH 10/21] Added states and test --- .github/CODEOWNERS | 3 + .../skript/conditions/CondIsSpawnable.java | 53 + .../java/ch/njol/skript/entity/BeeData.java | 115 +- .../ch/njol/skript/entity/CreeperData.java | 39 +- .../ch/njol/skript/entity/EntityData.java | 37 +- .../ch/njol/skript/entity/EntityType.java | 3 - .../java/ch/njol/skript/entity/GoatData.java | 36 +- .../ch/njol/skript/entity/MinecartData.java | 3 - .../java/ch/njol/skript/entity/PandaData.java | 7 +- .../java/ch/njol/skript/entity/PigData.java | 52 +- .../ch/njol/skript/entity/RabbitData.java | 1 - .../java/ch/njol/skript/entity/SheepData.java | 50 +- .../njol/skript/entity/SimpleEntityData.java | 58 +- .../ch/njol/skript/entity/StriderData.java | 44 +- .../njol/skript/entity/TropicalFishData.java | 8 +- .../ch/njol/skript/entity/VillagerData.java | 2 +- .../java/ch/njol/skript/entity/WolfData.java | 133 +- .../skript/entity/ZombieVillagerData.java | 4 +- .../skript/bukkit/displays/DisplayData.java | 22 +- src/main/resources/lang/default.lang | 1552 +++++++++-------- src/test/skript/tests/misc/EntityData.sk | 221 +++ 21 files changed, 1449 insertions(+), 994 deletions(-) create mode 100644 src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java create mode 100644 src/test/skript/tests/misc/EntityData.sk diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS index e0ddf8813eb..39155c3b1e8 100644 --- a/.github/CODEOWNERS +++ b/.github/CODEOWNERS @@ -63,3 +63,6 @@ # Documentation /src/main/java/ch/njol/skript/doc/ @Pikachu920 @AyhamAl-Ali @Efnilite @skriptlang/core-developers + +# EntityData +/src/main/java/ch/njol/skript/entity @Absolutionism @skriptlang/core-developers diff --git a/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java b/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java new file mode 100644 index 00000000000..51503b9d511 --- /dev/null +++ b/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java @@ -0,0 +1,53 @@ +package ch.njol.skript.conditions; + +import ch.njol.skript.Skript; +import ch.njol.skript.conditions.base.PropertyCondition; +import ch.njol.skript.doc.Description; +import ch.njol.skript.doc.Example; +import ch.njol.skript.doc.Name; +import ch.njol.skript.doc.Since; +import ch.njol.skript.entity.EntityData; +import ch.njol.skript.entity.EntityType; +import org.bukkit.Bukkit; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +@Name("Is Spawnable") +@Description(""" + Whether an entity type is spawnable. + Any general types such as 'monster, mob, entity, living entity' etc. will never be spawnable. + """) +@Example(""" + if a pig is spawnable: # true + if a monster can be spawned: # false + """) +@Since("INSERT VERSION") +@SuppressWarnings("rawtypes") +public class CondIsSpawnable extends PropertyCondition { + + static { + List patterns = new ArrayList<>(Arrays.stream(getPatterns(PropertyType.BE, "spawnable", "entitytypes")).toList()); + patterns.addAll(Arrays.stream(getPatterns(PropertyType.CAN, "be spawned", "entitytypes")).toList()); + Skript.registerCondition(CondIsSpawnable.class, patterns.toArray(String[]::new)); + } + + @Override + public boolean check(Object object) { + if (object instanceof EntityData entityData) { + return entityData.canSpawn(Bukkit.getWorlds().get(0)); + } else if (object instanceof EntityType entityType) { + EntityData entityData = entityType.data; + if (entityData != null) + return entityData.canSpawn(Bukkit.getWorlds().get(0)); + } + return false; + } + + @Override + protected String getPropertyName() { + return "spawnable"; + } + +} diff --git a/src/main/java/ch/njol/skript/entity/BeeData.java b/src/main/java/ch/njol/skript/entity/BeeData.java index 2e054d826ce..834845d0e38 100644 --- a/src/main/java/ch/njol/skript/entity/BeeData.java +++ b/src/main/java/ch/njol/skript/entity/BeeData.java @@ -2,58 +2,115 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.Kleenean; import org.bukkit.entity.Bee; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.Objects; import java.util.Random; public class BeeData extends EntityData { - + + public enum BeeState { + BEE(Kleenean.UNKNOWN, Kleenean.UNKNOWN), + NO_NECTAR(Kleenean.UNKNOWN, Kleenean.FALSE), + NECTAR(Kleenean.UNKNOWN, Kleenean.TRUE), + HAPPY(Kleenean.FALSE, Kleenean.UNKNOWN), + HAPPY_NECTAR(Kleenean.FALSE, Kleenean.TRUE), + HAPPY_NO_NECTAR(Kleenean.FALSE, Kleenean.FALSE), + ANGRY(Kleenean.TRUE, Kleenean.UNKNOWN), + ANGRY_NO_NECTAR(Kleenean.TRUE, Kleenean.FALSE), + ANGRY_NECTAR(Kleenean.TRUE, Kleenean.TRUE); + + private final Kleenean angry; + private final Kleenean nectar; + + BeeState(Kleenean angry, Kleenean nectar) { + this.angry = angry; + this.nectar = nectar; + } + + public static BeeState getBeeState(Kleenean angry, Kleenean nectar) { + for (BeeState beeState : BeeState.values()) { + if (beeState.angry == angry && beeState.nectar == nectar) + return beeState; + } + return null; + } + + } + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"bee", BeeState.BEE}, + {"no nectar bee", BeeState.NO_NECTAR}, + {"nectar bee", BeeState.NECTAR}, + {"happy bee", BeeState.HAPPY}, + {"happy nectar bee", BeeState.HAPPY_NECTAR}, + {"happy no nectar bee", BeeState.HAPPY_NO_NECTAR}, + {"angry bee", BeeState.ANGRY}, + {"angry no nectar bee", BeeState.ANGRY_NO_NECTAR}, + {"angry nectar bee", BeeState.ANGRY_NECTAR} + }); + static { - EntityData.register(BeeData.class, "bee", Bee.class, 2, - "no nectar bee", "happy bee", "bee", "nectar bee", "angry bee", "angry nectar bee"); + EntityData.register(BeeData.class, "bee", Bee.class, 0, PATTERNS.getPatterns()); + } + + private Kleenean hasNectar = Kleenean.UNKNOWN; + private Kleenean isAngry = Kleenean.UNKNOWN; + + public BeeData() {} + + public BeeData(@Nullable Kleenean isAngry, @Nullable Kleenean hasNectar) { + this.isAngry = isAngry != null ? isAngry : Kleenean.UNKNOWN; + this.hasNectar = hasNectar != null ? hasNectar : Kleenean.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(BeeState.getBeeState(this.isAngry, this.hasNectar))[0]; + } + + public BeeData(@Nullable BeeState beeState) { + if (beeState != null) { + this.isAngry = beeState.angry; + this.hasNectar = beeState.nectar; + super.dataCodeName = PATTERNS.getMatchedPatterns(beeState)[0]; + } else { + this.isAngry = Kleenean.UNKNOWN; + this.hasNectar = Kleenean.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(BeeState.BEE)[0]; + } } - - private int nectar = 0; - private int angry = 0; @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName > 3) { - angry = 1; - } else if (matchedCodeName < 2) { - angry = -1; - } - if (matchedCodeName == 3 || matchedCodeName == 5) { - nectar = 1; - } else if (matchedCodeName < 2) { - nectar = -1; - } + BeeState state = PATTERNS.getInfo(matchedCodeName); + assert state != null; + hasNectar = state.nectar; + isAngry = state.angry; return true; } @Override protected boolean init(@Nullable Class entityClass, @Nullable Bee bee) { - angry = bee == null ? 0 : (bee.getAnger() > 0) ? 1 : -1; - nectar = bee == null ? 0 : bee.hasNectar() ? 1 : -1; + if (bee != null) { + isAngry = bee.getAnger() > 0 ? Kleenean.TRUE : Kleenean.FALSE; + hasNectar = Kleenean.get(bee.hasNectar()); + super.dataCodeName = PATTERNS.getMatchedPatterns(BeeState.getBeeState(isAngry, hasNectar))[0]; + } return true; } @Override public void set(Bee bee) { int random = new Random().nextInt(400) + 400; - bee.setAnger(angry > 0 ? random : 0); - bee.setHasNectar(nectar > 0); + bee.setAnger(isAngry.isTrue() ? random : 0); + bee.setHasNectar(hasNectar.isTrue()); } @Override protected boolean match(Bee bee) { - if (angry == 0 && nectar == 0) - return true; - if ((bee.getAnger() > 0) != (angry == 1)) + if (isAngry != Kleenean.UNKNOWN && isAngry != (bee.getAnger() > 0 ? Kleenean.TRUE : Kleenean.FALSE)) return false; - return bee.hasNectar() == (nectar == 1); + return hasNectar == Kleenean.UNKNOWN || hasNectar == Kleenean.get(bee.hasNectar()); } @Override @@ -70,8 +127,8 @@ public Class getType() { protected int hashCode_i() { int prime = 31; int result = 1; - result = prime * result + angry; - result = prime * result + nectar; + result = prime * result + Objects.hashCode(isAngry); + result = prime * result + Objects.hashCode(hasNectar); return result; } @@ -79,16 +136,16 @@ protected int hashCode_i() { protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof BeeData other)) return false; - return (angry == other.angry) && (nectar == other.nectar); + return isAngry == other.isAngry && hasNectar == other.hasNectar; } @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof BeeData other)) return false; - if (angry != 0 && angry != other.angry) + if (isAngry != Kleenean.UNKNOWN && isAngry != other.isAngry) return false; - return nectar == 0 || nectar == other.nectar; + return hasNectar == Kleenean.UNKNOWN || hasNectar == other.hasNectar; } } diff --git a/src/main/java/ch/njol/skript/entity/CreeperData.java b/src/main/java/ch/njol/skript/entity/CreeperData.java index 3b4122afeb1..9ed79254c97 100644 --- a/src/main/java/ch/njol/skript/entity/CreeperData.java +++ b/src/main/java/ch/njol/skript/entity/CreeperData.java @@ -1,5 +1,6 @@ package ch.njol.skript.entity; +import ch.njol.util.Kleenean; import org.bukkit.entity.Creeper; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -9,56 +10,50 @@ import java.util.Objects; - public class CreeperData extends EntityData { - public enum PoweredState { - UNKNOWN, POWERED, UNPOWERED - } - - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"creeper", PoweredState.UNKNOWN}, - {"powered creeper", PoweredState.POWERED}, - {"unpowered creeper", PoweredState.UNPOWERED} + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"creeper", Kleenean.UNKNOWN}, + {"powered creeper", Kleenean.TRUE}, + {"unpowered creeper", Kleenean.FALSE} }); static { EntityData.register(CreeperData.class, "creeper", Creeper.class, 0, PATTERNS.getPatterns()); } - private PoweredState state = PoweredState.UNKNOWN; + private Kleenean powered = Kleenean.UNKNOWN; public CreeperData() {} - public CreeperData(@Nullable CreeperData.PoweredState state) { - this.state = state != null ? state : PoweredState.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(this.state)[0]; + public CreeperData(@Nullable Kleenean powered) { + this.powered = powered != null ? powered : Kleenean.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(this.powered)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - state = PATTERNS.getInfo(matchedCodeName); + powered = PATTERNS.getInfo(matchedCodeName); return true; } @Override protected boolean init(@Nullable Class entityClass, @Nullable Creeper creeper) { - state = PoweredState.UNKNOWN; if (creeper != null) { - state = creeper.isPowered() ? PoweredState.POWERED : PoweredState.UNPOWERED; - super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + powered = Kleenean.get(creeper.isPowered()); + super.dataCodeName = PATTERNS.getMatchedPatterns(powered)[0]; } return true; } @Override public void set(Creeper creeper) { - creeper.setPowered(state == PoweredState.POWERED); + creeper.setPowered(powered.isTrue()); } @Override public boolean match(Creeper creeper) { - return state == PoweredState.UNKNOWN || creeper.isPowered() == (state == PoweredState.POWERED); + return powered == Kleenean.UNKNOWN || powered == Kleenean.get(creeper.isPowered()); } @Override @@ -73,21 +68,21 @@ public Class getType() { @Override protected int hashCode_i() { - return Objects.hashCode(state); + return Objects.hashCode(powered); } @Override protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof CreeperData other)) return false; - return state == other.state; + return powered == other.powered; } @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof CreeperData other)) return false; - return state == other.state; + return powered == Kleenean.UNKNOWN || powered == other.powered; } } diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index c5766dc0652..84ca05a609e 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -200,7 +200,7 @@ private final static class EntityDataInfo> extends Synta private String[] patterns; private final Map codeNamePlacements = new HashMap<>(); private final Map matchedPatternToCodeName = new HashMap<>(); - private final Map matchedPatternToActualPattern = new HashMap<>(); + private final Map matchedPatternToCodeNamePattern = new HashMap<>(); public EntityDataInfo(Class dataClass, String codeName, String[] codeNames, int defaultName, Class entityClass) { this(dataClass, codeName, codeNames, defaultName, EntityUtils.toBukkitEntityType(entityClass), entityClass); @@ -235,24 +235,24 @@ public EntityDataInfo( public void onLanguageChange() { List allPatterns = new ArrayList<>(); matchedPatternToCodeName.clear(); - matchedPatternToActualPattern.clear(); + matchedPatternToCodeNamePattern.clear(); for (String codeName : codeNames) { if (Language.keyExistsDefault(LANGUAGE_NODE + "." + codeName + ".pattern")) { String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".pattern") - .replace("", m_age_pattern.toString()); + .replace("", m_age_pattern.toString()); matchedPatternToCodeName.put(allPatterns.size(), codeName); - matchedPatternToActualPattern.put(allPatterns.size(), 0); + matchedPatternToCodeNamePattern.put(allPatterns.size(), 0); allPatterns.add(pattern); } if (Language.keyExistsDefault(LANGUAGE_NODE + "." + codeName + ".patterns.0")) { int multiCount = 0; while (Language.keyExistsDefault(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount)) { String pattern = Language.get(LANGUAGE_NODE + "." + codeName + ".patterns." + multiCount) - .replace("", m_age_pattern.toString()); + .replace("", m_age_pattern.toString()); // correlates '#init.matchedPattern' to 'codeName' matchedPatternToCodeName.put(allPatterns.size(), codeName); - // correlates '#init.matchedPattern' to actual pattern - matchedPatternToActualPattern.put(allPatterns.size(), multiCount); + // correlates '#init.matchedPattern' to pattern in code name + matchedPatternToCodeNamePattern.put(allPatterns.size(), multiCount); allPatterns.add(pattern); multiCount++; } @@ -289,8 +289,8 @@ public int getCodeNamePlacement(String codeName) { * @param matchedPattern The placement of the pattern used * @return The actual placement. */ - public int getActualMatchedPattern(int matchedPattern) { - return matchedPatternToActualPattern.get(matchedPattern); + public int getPatternInCodeName(int matchedPattern) { + return matchedPatternToCodeNamePattern.get(matchedPattern); } @Override @@ -337,6 +337,10 @@ public static > void register( } transient EntityDataInfo info; + + /** + * References the corresponding code name in the order they're registered. + */ protected int dataCodeName = 0; private Kleenean plural = Kleenean.UNKNOWN; private Kleenean baby = Kleenean.UNKNOWN; @@ -367,9 +371,9 @@ public final boolean init(Expression[] exprs, int matchedPattern, Kleenean is this.baby = parseResult.hasTag("unknown_age") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("baby")); String codeName = info.getCodeNameFromPattern(matchedPattern); int matchedCodeName = info.getCodeNamePlacement(codeName); - int actualPattern = info.getActualMatchedPattern(matchedPattern); + int patternInCodeName = info.getPatternInCodeName(matchedPattern); this.dataCodeName = matchedCodeName; - return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedCodeName, actualPattern, parseResult); + return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedCodeName, patternInCodeName, parseResult); } /** @@ -381,7 +385,7 @@ public final boolean init(Expression[] exprs, int matchedPattern, Kleenean is * {@code matchedPattern} will be the index of the pattern used from the patterns of the code name in the lang file. *

* - * @param exprs An arraay of {@link Literal} expressions from the matched pattern, in the order they appear. + * @param exprs An array of {@link Literal} expressions from the matched pattern, in the order they appear. * If an optional value was omitted by the user, it will still be present in the array * with a value of {@code null}. * @param matchedCodeName The index of the code name which matched. @@ -451,7 +455,7 @@ protected abstract boolean init( /** * Returns a more general version of this {@link EntityData} with specific data removed. *

- * For example, calling this on {@code "a saddled pig"} would return {@code "a pig"}. + * For example, calling this on {@code "a saddled pig"} should return {@code "a pig"}. * This is typically used to obtain the base entity type without any modifiers or traits. *

* @@ -476,7 +480,12 @@ protected Noun getName() { @SuppressWarnings("null") public String toString(int flags) { Noun name = info.names[dataCodeName]; - return baby.isTrue() ? m_baby.toString(name, flags) : baby.isFalse() ? m_adult.toString(name, flags) : name.toString(flags); + if (baby.isTrue()) { + return m_baby.toString(name, flags); + } else if (baby.isFalse()) { + return m_adult.toString(name, flags); + } + return name.toString(flags); } /** diff --git a/src/main/java/ch/njol/skript/entity/EntityType.java b/src/main/java/ch/njol/skript/entity/EntityType.java index 9919d1956ad..1544259cae4 100644 --- a/src/main/java/ch/njol/skript/entity/EntityType.java +++ b/src/main/java/ch/njol/skript/entity/EntityType.java @@ -13,9 +13,6 @@ import ch.njol.skript.util.Utils; import ch.njol.yggdrasil.YggdrasilSerializable; -/** - * @author Peter Güttinger - */ public class EntityType implements Cloneable, YggdrasilSerializable { static { diff --git a/src/main/java/ch/njol/skript/entity/GoatData.java b/src/main/java/ch/njol/skript/entity/GoatData.java index 6cc3916a6a2..b2c84ce7472 100644 --- a/src/main/java/ch/njol/skript/entity/GoatData.java +++ b/src/main/java/ch/njol/skript/entity/GoatData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.Kleenean; import org.bukkit.entity.Goat; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -10,52 +11,47 @@ public class GoatData extends EntityData { - public enum ScreamingState { - UNKNOWN, SCREAMING, QUIET - } - - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"goat", ScreamingState.UNKNOWN}, - {"screaming goat", ScreamingState.SCREAMING}, - {"quiet goat", ScreamingState.QUIET} + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"goat", Kleenean.UNKNOWN}, + {"screaming goat", Kleenean.TRUE}, + {"quiet goat", Kleenean.FALSE} }); static { EntityData.register(GoatData.class, "goat", Goat.class, 0, PATTERNS.getPatterns()); } - private ScreamingState state = ScreamingState.UNKNOWN; + private Kleenean screaming = Kleenean.UNKNOWN; public GoatData() {} - public GoatData(@Nullable GoatData.ScreamingState state) { - this.state = state != null ? state : ScreamingState.UNKNOWN; + public GoatData(@Nullable Kleenean screaming) { + this.screaming = screaming != null ? screaming : Kleenean.UNKNOWN; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - state = PATTERNS.getInfo(matchedCodeName); + screaming = PATTERNS.getInfo(matchedCodeName); return true; } @Override protected boolean init(@Nullable Class entityClass, @Nullable Goat goat) { - state = ScreamingState.UNKNOWN; if (goat != null) { - state = goat.isScreaming() ? ScreamingState.SCREAMING : ScreamingState.QUIET; - super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + screaming = Kleenean.get(goat.isScreaming()); + super.dataCodeName = PATTERNS.getMatchedPatterns(screaming)[0]; } return true; } @Override public void set(Goat goat) { - goat.setScreaming(state == ScreamingState.SCREAMING); + goat.setScreaming(screaming.isTrue()); } @Override protected boolean match(Goat goat) { - return state == ScreamingState.UNKNOWN || goat.isScreaming() == (state == ScreamingState.SCREAMING); + return screaming == Kleenean.UNKNOWN || screaming == Kleenean.get(goat.isScreaming()); } @Override @@ -70,21 +66,21 @@ public Class getType() { @Override protected int hashCode_i() { - return Objects.hashCode(state); + return Objects.hashCode(screaming); } @Override protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof GoatData other)) return false; - return state == other.state; + return screaming == other.screaming; } @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof GoatData other)) return false; - return state == ScreamingState.UNKNOWN || state == other.state; + return screaming == Kleenean.UNKNOWN || screaming == other.screaming; } } diff --git a/src/main/java/ch/njol/skript/entity/MinecartData.java b/src/main/java/ch/njol/skript/entity/MinecartData.java index 07d4f68d439..aea284c53eb 100644 --- a/src/main/java/ch/njol/skript/entity/MinecartData.java +++ b/src/main/java/ch/njol/skript/entity/MinecartData.java @@ -17,9 +17,6 @@ import java.util.ArrayList; -/** - * @author Peter Güttinger - */ public class MinecartData extends EntityData { @SuppressWarnings("null") diff --git a/src/main/java/ch/njol/skript/entity/PandaData.java b/src/main/java/ch/njol/skript/entity/PandaData.java index 0bedc810c19..bc1607af379 100644 --- a/src/main/java/ch/njol/skript/entity/PandaData.java +++ b/src/main/java/ch/njol/skript/entity/PandaData.java @@ -31,10 +31,11 @@ public PandaData(@Nullable Gene mainGene, @Nullable Gene hiddenGene) { @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (exprs[0] != null) + if (exprs[0] != null) { mainGene = (Gene) exprs[0].getSingle(); - if (exprs[1] != null) - hiddenGene = (Gene) exprs[1].getSingle(); + if (exprs[1] != null) + hiddenGene = (Gene) exprs[1].getSingle(); + } return true; } diff --git a/src/main/java/ch/njol/skript/entity/PigData.java b/src/main/java/ch/njol/skript/entity/PigData.java index c2d93103770..6e6c2d0e7a3 100644 --- a/src/main/java/ch/njol/skript/entity/PigData.java +++ b/src/main/java/ch/njol/skript/entity/PigData.java @@ -4,6 +4,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.registrations.Classes; +import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; import org.bukkit.entity.Pig; @@ -14,16 +15,12 @@ public class PigData extends EntityData { - public enum SaddleState { - NOT_SADDLED, UNKNOWN, SADDLED - } - private static final boolean VARIANTS_ENABLED; private static final Object[] VARIANTS; - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"pig", SaddleState.UNKNOWN}, - {"saddled pig", SaddleState.SADDLED}, - {"unsaddled pig", SaddleState.NOT_SADDLED} + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"pig", Kleenean.UNKNOWN}, + {"saddled pig", Kleenean.TRUE}, + {"unsaddled pig", Kleenean.FALSE} }); static { @@ -37,14 +34,14 @@ public enum SaddleState { } } - private SaddleState saddled = SaddleState.UNKNOWN; + private Kleenean saddled = Kleenean.UNKNOWN; private @Nullable Object variant = null; public PigData() {} // TODO: When safe, 'variant' should have the type changed to 'Pig.Variant' - public PigData(SaddleState saddled, @Nullable Object variant) { - this.saddled = saddled; + public PigData(@Nullable Kleenean saddled, @Nullable Object variant) { + this.saddled = saddled != null ? saddled : Kleenean.UNKNOWN; this.variant = variant; super.dataCodeName = PATTERNS.getMatchedPatterns(saddled)[0]; } @@ -61,9 +58,8 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @Override protected boolean init(@Nullable Class entityClass, @Nullable Pig pig) { - saddled = SaddleState.UNKNOWN; if (pig != null) { - saddled = pig.hasSaddle() ? SaddleState.SADDLED : SaddleState.NOT_SADDLED; + saddled = Kleenean.get(pig.hasSaddle()); super.dataCodeName = PATTERNS.getMatchedPatterns(saddled)[0]; if (VARIANTS_ENABLED) variant = pig.getVariant(); @@ -73,7 +69,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable Pig @Override public void set(Pig pig) { - pig.setSaddle(saddled == SaddleState.SADDLED); + pig.setSaddle(saddled.isTrue()); if (VARIANTS_ENABLED) { Object finalVariant = variant != null ? variant : CollectionUtils.getRandom(VARIANTS); assert finalVariant != null; @@ -83,7 +79,7 @@ public void set(Pig pig) { @Override protected boolean match(Pig pig) { - if (saddled != SaddleState.UNKNOWN && pig.hasSaddle() != (saddled == SaddleState.SADDLED)) + if (saddled != Kleenean.UNKNOWN && saddled != Kleenean.get(pig.hasSaddle())) return false; return variant == null || variant == pig.getVariant(); } @@ -92,7 +88,17 @@ protected boolean match(Pig pig) { public Class getType() { return Pig.class; } - + + @Override + public @NotNull EntityData getSuperType() { + return new PigData(); + } + + @Override + protected int hashCode_i() { + return saddled.ordinal() + Objects.hashCode(variant); + } + @Override protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof PigData other)) @@ -101,25 +107,15 @@ protected boolean equals_i(EntityData entityData) { return false; return variant == other.variant; } - - @Override - protected int hashCode_i() { - return saddled.ordinal() + Objects.hashCode(variant); - } - + @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof PigData other)) return false; - if (saddled != SaddleState.UNKNOWN && saddled != other.saddled) + if (saddled != Kleenean.UNKNOWN && saddled != other.saddled) return false; return variant == null || variant == other.variant; } - - @Override - public @NotNull EntityData getSuperType() { - return new PigData(); - } /** * A dummy/placeholder class to ensure working operation on MC versions that do not have `Pig.Variant` diff --git a/src/main/java/ch/njol/skript/entity/RabbitData.java b/src/main/java/ch/njol/skript/entity/RabbitData.java index be6e8854218..abab1c875a8 100644 --- a/src/main/java/ch/njol/skript/entity/RabbitData.java +++ b/src/main/java/ch/njol/skript/entity/RabbitData.java @@ -8,7 +8,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; - public class RabbitData extends EntityData { private static final Type[] TYPES = Type.values(); diff --git a/src/main/java/ch/njol/skript/entity/SheepData.java b/src/main/java/ch/njol/skript/entity/SheepData.java index a8c7361ddaf..0bc81af8c15 100644 --- a/src/main/java/ch/njol/skript/entity/SheepData.java +++ b/src/main/java/ch/njol/skript/entity/SheepData.java @@ -8,6 +8,7 @@ import ch.njol.skript.localization.Noun; import ch.njol.skript.util.Color; import ch.njol.skript.util.SkriptColor; +import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Sheep; import org.jetbrains.annotations.NotNull; @@ -15,40 +16,33 @@ import java.util.Arrays; -/** - * @author Peter Güttinger - */ public class SheepData extends EntityData { - public enum ShearState { - UNKNOWN, SHEARED, UNSHEARED - } - - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"sheep", ShearState.UNKNOWN}, - {"sheared sheep", ShearState.SHEARED}, - {"unsheared sheep", ShearState.UNSHEARED} + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"sheep", Kleenean.UNKNOWN}, + {"sheared sheep", Kleenean.TRUE}, + {"unsheared sheep", Kleenean.FALSE} }); static { EntityData.register(SheepData.class, "sheep", Sheep.class, 0, PATTERNS.getPatterns()); } - private Color @Nullable [] colors; - private ShearState state = ShearState.UNKNOWN; + private Color @Nullable [] colors = null; + private Kleenean sheared = Kleenean.UNKNOWN; private Adjective @Nullable [] adjectives = null; public SheepData() {} - public SheepData(@Nullable ShearState state, Color @Nullable [] colors) { - this.state = state != null ? state : ShearState.UNKNOWN; + public SheepData(@Nullable Kleenean sheared, Color @Nullable [] colors) { + this.sheared = sheared != null ? sheared : Kleenean.UNKNOWN; this.colors = colors; - super.dataCodeName = PATTERNS.getMatchedPatterns(this.state)[0]; + super.dataCodeName = PATTERNS.getMatchedPatterns(this.sheared)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - state = PATTERNS.getInfo(matchedCodeName); + sheared = PATTERNS.getInfo(matchedCodeName); if (exprs[0] != null) { //noinspection unchecked colors = ((Literal) exprs[0]).getAll(); @@ -58,29 +52,29 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @Override protected boolean init(@Nullable Class entityClass, @Nullable Sheep sheep) { - state = ShearState.UNKNOWN; if (sheep != null) { - state = sheep.isSheared() ? ShearState.SHEARED : ShearState.UNSHEARED; + sheared = Kleenean.get(sheep.isSheared()); colors = CollectionUtils.array(SkriptColor.fromDyeColor(sheep.getColor())); - super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + super.dataCodeName = PATTERNS.getMatchedPatterns(sheared)[0]; } return true; } @Override - public void set(Sheep entity) { + public void set(Sheep sheep) { if (colors != null) { Color color = CollectionUtils.getRandom(colors); assert color != null; - entity.setColor(color.asDyeColor()); + sheep.setColor(color.asDyeColor()); } + sheep.setSheared(sheared.isTrue()); } @Override - public boolean match(Sheep entity) { - if (state != ShearState.UNKNOWN && entity.isSheared() != (state == ShearState.SHEARED)) + public boolean match(Sheep sheep) { + if (sheared != Kleenean.UNKNOWN && sheared != Kleenean.get(sheep.isSheared())) return false; - return colors == null || SimpleExpression.check(colors, c -> entity.getColor() == c.asDyeColor(), false, false); + return colors == null || SimpleExpression.check(colors, c -> sheep.getColor() == c.asDyeColor(), false, false); } @Override @@ -98,7 +92,7 @@ protected int hashCode_i() { int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(colors); - result = prime * result + state.hashCode(); + result = prime * result + sheared.hashCode(); return result; } @@ -108,14 +102,14 @@ protected boolean equals_i(EntityData entityData) { return false; if (!Arrays.equals(colors, other.colors)) return false; - return state == other.state; + return sheared == other.sheared; } @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof SheepData other)) return false; - if (state != ShearState.UNKNOWN && state != other.state) + if (sheared != Kleenean.UNKNOWN && sheared != other.sheared) return false; return colors == null || CollectionUtils.isSubset(colors, other.colors); } diff --git a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java index b657a0688fe..509107a1fe2 100644 --- a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java +++ b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java @@ -77,6 +77,7 @@ private static void addSuperEntity(String codeName, Class enti // Simple Entities // Alpha + Beta + addSimpleEntity("zombie", Zombie.class); addSuperEntity("skeleton", Skeleton.class); addSimpleEntity("tnt", TNTPrimed.class); addSimpleEntity("spider", Spider.class); @@ -95,6 +96,7 @@ private static void addSuperEntity(String codeName, Class enti addSimpleEntity("egg", Egg.class); addSimpleEntity("cave spider", CaveSpider.class); addSimpleEntity("arrow", Arrow.class); + addSimpleEntity("squid", Squid.class); // 1.0 addSimpleEntity("snow golem", Snowman.class); @@ -102,7 +104,6 @@ private static void addSuperEntity(String codeName, Class enti addSimpleEntity("slime", Slime.class); addSimpleEntity("magma cube", MagmaCube.class); addSimpleEntity("ender eye", EnderSignal.class); - addSimpleEntity("mooshroom", MushroomCow.class); addSimpleEntity("blaze", Blaze.class); // 1.2 @@ -149,7 +150,6 @@ private static void addSuperEntity(String codeName, Class enti addSimpleEntity("polar bear", PolarBear.class); // 1.11 - addSimpleEntity("llama", Llama.class); addSimpleEntity("llama spit", LlamaSpit.class); addSimpleEntity("vindicator", Vindicator.class); addSimpleEntity("vex", Vex.class); @@ -161,7 +161,6 @@ private static void addSuperEntity(String codeName, Class enti // 1.13 addSimpleEntity("trident", Trident.class); - addSimpleEntity("tropical fish", TropicalFish.class); addSimpleEntity("puffer fish", PufferFish.class); addSimpleEntity("cod", Cod.class); addSimpleEntity("turtle", Turtle.class); @@ -178,9 +177,6 @@ private static void addSuperEntity(String codeName, Class enti addSimpleEntity("piglin", Piglin.class); addSimpleEntity("hoglin", Hoglin.class); addSimpleEntity("zoglin", Zoglin.class); - addSimpleEntity("strider", Strider.class); - - // 1.16.2 addSimpleEntity("piglin brute", PiglinBrute.class); // 1.17 @@ -244,11 +240,6 @@ private static void addSuperEntity(String codeName, Class enti if (Skript.isRunningMinecraft(1, 21, 6)) addSimpleEntity("happy ghast", HappyGhast.class); - // Register zombie after Husk and Drowned to make sure both work - addSimpleEntity("zombie", Zombie.class); - // Register squid after glow squid to make sure both work - addSimpleEntity("squid", Squid.class); - // SuperTypes addSuperEntity("human", HumanEntity.class); addSuperEntity("damageable", Damageable.class); @@ -265,7 +256,6 @@ private static void addSuperEntity(String codeName, Class enti addSuperEntity("any horse", AbstractHorse.class); addSuperEntity("guardian", Guardian.class); addSuperEntity("water mob" , WaterMob.class); - addSuperEntity("fish" , Fish.class); addSuperEntity("any fireball", Fireball.class); addSuperEntity("illager", Illager.class); addSuperEntity("spellcaster", Spellcaster.class); @@ -273,8 +263,6 @@ private static void addSuperEntity(String codeName, Class enti // TODO - remove this when 1.19 support is dropped if (Skript.classExists("org.bukkit.entity.Enemy")) // 1.19.3 addSuperEntity("enemy", Enemy.class); - if (Skript.classExists("org.bukkit.entity.Display")) // 1.19.4 - addSuperEntity("display", Display.class); } static { @@ -286,16 +274,16 @@ private static void addSuperEntity(String codeName, Class enti EntityData.register(SimpleEntityData.class, "simple", Entity.class, 0, codeNames); } - private transient SimpleEntityDataInfo info; + private transient SimpleEntityDataInfo simpleInfo; public SimpleEntityData() { this(Entity.class); } - private SimpleEntityData(SimpleEntityDataInfo info) { - assert info != null; - this.info = info; - dataCodeName = types.indexOf(info); + private SimpleEntityData(SimpleEntityDataInfo simpleInfo) { + assert simpleInfo != null; + this.simpleInfo = simpleInfo; + dataCodeName = types.indexOf(simpleInfo); } public SimpleEntityData(Class entityClass) { @@ -313,7 +301,7 @@ public SimpleEntityData(Class entityClass) { i++; } if (closestInfo != null) { - this.info = closestInfo; + this.simpleInfo = closestInfo; this.dataCodeName = closestPattern; return; } @@ -334,7 +322,7 @@ public SimpleEntityData(Entity entity) { i++; } if (closestInfo != null) { - this.info = closestInfo; + this.simpleInfo = closestInfo; this.dataCodeName = closestPattern; return; } @@ -343,8 +331,8 @@ public SimpleEntityData(Entity entity) { @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - info = types.get(matchedCodeName); - assert info != null : matchedCodeName; + simpleInfo = types.get(matchedCodeName); + assert simpleInfo != null : matchedCodeName; return true; } @@ -359,8 +347,8 @@ public void set(Entity entity) {} @Override public boolean match(Entity entity) { - if (info.isSupertype) - return info.c.isInstance(entity); + if (simpleInfo.isSupertype) + return simpleInfo.c.isInstance(entity); SimpleEntityDataInfo closest = null; for (SimpleEntityDataInfo info : types) { if (info.c.isInstance(entity)) { @@ -369,51 +357,51 @@ public boolean match(Entity entity) { } } if (closest != null) - return this.info.c == closest.c; + return this.simpleInfo.c == closest.c; assert false; return false; } @Override public Class getType() { - return info.c; + return simpleInfo.c; } @Override public @NotNull EntityData getSuperType() { - return new SimpleEntityData(info); + return new SimpleEntityData(simpleInfo); } @Override protected int hashCode_i() { - return info.hashCode(); + return simpleInfo.hashCode(); } @Override protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof SimpleEntityData other)) return false; - return info.equals(other.info); + return simpleInfo.equals(other.simpleInfo); } @Override public boolean isSupertypeOf(EntityData entityData) { - return info.c == entityData.getType() || info.isSupertype && info.c.isAssignableFrom(entityData.getType()); + return simpleInfo.c == entityData.getType() || simpleInfo.isSupertype && simpleInfo.c.isAssignableFrom(entityData.getType()); } @Override public boolean canSpawn(@Nullable World world) { - if (info.allowSpawning.isUnknown()) // unspecified, refer to default behavior + if (simpleInfo.allowSpawning.isUnknown()) // unspecified, refer to default behavior return super.canSpawn(world); if (world == null) return false; - return info.allowSpawning.isTrue(); + return simpleInfo.allowSpawning.isTrue(); } @Override public Fields serialize() throws NotSerializableException { Fields fields = super.serialize(); - fields.putObject("info.codeName", info.codeName); + fields.putObject("info.codeName", simpleInfo.codeName); return fields; } @@ -422,7 +410,7 @@ public void deserialize(Fields fields) throws StreamCorruptedException, NotSeria String codeName = fields.getAndRemoveObject("info.codeName", String.class); for (SimpleEntityDataInfo info : types) { if (info.codeName.equals(codeName)) { - this.info = info; + this.simpleInfo = info; super.deserialize(fields); return; } diff --git a/src/main/java/ch/njol/skript/entity/StriderData.java b/src/main/java/ch/njol/skript/entity/StriderData.java index 06c57ea2a0c..2c326cf31e6 100644 --- a/src/main/java/ch/njol/skript/entity/StriderData.java +++ b/src/main/java/ch/njol/skript/entity/StriderData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.util.Kleenean; import org.bukkit.entity.Strider; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -10,53 +11,48 @@ public class StriderData extends EntityData { - public enum ShiveringState { - UNKNOWN, WARM, COLD - } - - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"strider", ShiveringState.UNKNOWN}, - {"warm strider", ShiveringState.WARM}, - {"shivering strider", ShiveringState.COLD} + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"strider", Kleenean.UNKNOWN}, + {"warm strider", Kleenean.FALSE}, + {"shivering strider", Kleenean.TRUE} }); static { register(StriderData.class, "strider", Strider.class, 0, PATTERNS.getPatterns()); } - private ShiveringState state = ShiveringState.UNKNOWN; + private Kleenean shivering = Kleenean.UNKNOWN; public StriderData() {} - public StriderData(@Nullable ShiveringState state) { - this.state = state != null ? state : ShiveringState.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + public StriderData(@Nullable Kleenean shivering) { + this.shivering = shivering != null ? shivering : Kleenean.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(shivering)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - state = PATTERNS.getInfo(matchedCodeName); + shivering = PATTERNS.getInfo(matchedCodeName); return true; } @Override - protected boolean init(@Nullable Class entityClass, @Nullable Strider entity) { - state = ShiveringState.UNKNOWN; - if (entity != null) { - state = entity.isShivering() ? ShiveringState.COLD : ShiveringState.WARM; - super.dataCodeName = PATTERNS.getMatchedPatterns(state)[0]; + protected boolean init(@Nullable Class entityClass, @Nullable Strider strider) { + if (strider != null) { + shivering = Kleenean.get(strider.isShivering()); + super.dataCodeName = PATTERNS.getMatchedPatterns(shivering)[0]; } return true; } @Override public void set(Strider entity) { - entity.setShivering(state == ShiveringState.COLD); + entity.setShivering(shivering.isTrue()); } @Override - protected boolean match(Strider entity) { - return state == ShiveringState.UNKNOWN || state == (entity.isShivering() ? ShiveringState.COLD : ShiveringState.WARM); + protected boolean match(Strider strider) { + return shivering == Kleenean.UNKNOWN || shivering == Kleenean.get(strider.isShivering()); } @Override @@ -71,21 +67,21 @@ public Class getType() { @Override protected int hashCode_i() { - return Objects.hash(state); + return Objects.hash(shivering); } @Override protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof StriderData other)) return false; - return state == other.state; + return shivering == other.shivering; } @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof StriderData other)) return false; - return state == ShiveringState.UNKNOWN || state == other.state; + return shivering == Kleenean.UNKNOWN || shivering == other.shivering; } } diff --git a/src/main/java/ch/njol/skript/entity/TropicalFishData.java b/src/main/java/ch/njol/skript/entity/TropicalFishData.java index 694f11b199e..78b071c6831 100644 --- a/src/main/java/ch/njol/skript/entity/TropicalFishData.java +++ b/src/main/java/ch/njol/skript/entity/TropicalFishData.java @@ -35,14 +35,16 @@ public class TropicalFishData extends EntityData { register(TropicalFishData.class, "tropical fish", TropicalFish.class, 0, PATTERNS.getPatterns()); } - private @Nullable DyeColor patternColor; - private @Nullable DyeColor bodyColor; + private @Nullable DyeColor bodyColor = null; + private @Nullable DyeColor patternColor = null; private @Nullable Pattern fishPattern = null; public TropicalFishData() {} - public TropicalFishData(@Nullable Pattern fishPattern) { + public TropicalFishData(@Nullable Pattern fishPattern, @Nullable DyeColor bodyColor, @Nullable DyeColor patternColor) { this.fishPattern = fishPattern; + this.bodyColor = bodyColor; + this.patternColor = patternColor; super.dataCodeName = PATTERNS.getMatchedPatterns(fishPattern)[0]; } diff --git a/src/main/java/ch/njol/skript/entity/VillagerData.java b/src/main/java/ch/njol/skript/entity/VillagerData.java index a2b01e5c73f..85e353eaa5c 100644 --- a/src/main/java/ch/njol/skript/entity/VillagerData.java +++ b/src/main/java/ch/njol/skript/entity/VillagerData.java @@ -22,7 +22,7 @@ public class VillagerData extends EntityData { private static final Profession[] PROFESSIONS; private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ {"villager", null}, - {"normal", Profession.NONE}, + {"unemployed", Profession.NONE}, {"armorer", Profession.ARMORER}, {"butcher", Profession.BUTCHER}, {"cartographer", Profession.CARTOGRAPHER}, diff --git a/src/main/java/ch/njol/skript/entity/WolfData.java b/src/main/java/ch/njol/skript/entity/WolfData.java index 4a4170bdebf..1c9e14c6724 100644 --- a/src/main/java/ch/njol/skript/entity/WolfData.java +++ b/src/main/java/ch/njol/skript/entity/WolfData.java @@ -5,6 +5,7 @@ import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.registrations.Classes; import ch.njol.skript.util.Color; +import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; import org.bukkit.DyeColor; @@ -16,14 +17,44 @@ public class WolfData extends EntityData { + public enum WolfState { + WOLF(Kleenean.UNKNOWN, Kleenean.UNKNOWN), + WILD(Kleenean.UNKNOWN, Kleenean.FALSE), + TAMED(Kleenean.UNKNOWN, Kleenean.TRUE), + ANGRY(Kleenean.TRUE, Kleenean.UNKNOWN), + PEACEFUL(Kleenean.FALSE, Kleenean.UNKNOWN); + + private final Kleenean angry; + private final Kleenean tamed; + + WolfState(Kleenean angry, Kleenean tamed) { + this.angry = angry; + this.tamed = tamed; + } + + public static WolfState getWolfState(Kleenean angry, Kleenean tamed) { + for (WolfState wolfState : values()) { + if (wolfState.angry == angry && wolfState.tamed == tamed) + return wolfState; + } + return null; + } + } + + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"wolf", WolfState.WOLF}, + {"wild wolf", WolfState.WILD}, + {"tamed wolf", WolfState.TAMED}, + {"angry wolf", WolfState.ANGRY}, + {"peaceful wolf", WolfState.PEACEFUL} + }); + private static final boolean VARIANTS_ENABLED; private static final Object[] VARIANTS; static { - EntityData.register(WolfData.class, "wolf", Wolf.class, 1, - "peaceful wolf", "wolf", "angry wolf", - "wild wolf", "tamed wolf"); + EntityData.register(WolfData.class, "wolf", Wolf.class, 0, PATTERNS.getPatterns()); if (Skript.classExists("org.bukkit.entity.Wolf$Variant")) { VARIANTS_ENABLED = true; VARIANTS = Iterators.toArray(Classes.getExactClassInfo(Wolf.Variant.class).getSupplier().get(), Wolf.Variant.class); @@ -33,21 +64,38 @@ public class WolfData extends EntityData { } } + private @Nullable Object variant = null; + private @Nullable DyeColor collarColor = null; + private Kleenean isAngry = Kleenean.UNKNOWN; + private Kleenean isTamed = Kleenean.UNKNOWN; + + public WolfData() {} - private @Nullable Object variant; - private @Nullable DyeColor collarColor; + public WolfData(@Nullable Kleenean isAngry, @Nullable Kleenean isTamed) { + this.isAngry = isAngry != null ? isAngry : Kleenean.UNKNOWN; + this.isTamed = isTamed != null ? isTamed : Kleenean.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(WolfState.getWolfState(this.isAngry, this.isTamed))[0]; + } - private int angry = 0; - private int tamed = 0; + public WolfData(@Nullable WolfState wolfState) { + if (wolfState != null) { + this.isAngry = wolfState.angry; + this.isTamed = wolfState.tamed; + super.dataCodeName = PATTERNS.getMatchedPatterns(wolfState)[0]; + } else { + this.isAngry = Kleenean.UNKNOWN; + this.isTamed = Kleenean.UNKNOWN; + super.dataCodeName = PATTERNS.getMatchedPatterns(WolfState.WOLF)[0]; + } + } @SuppressWarnings("unchecked") @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (matchedCodeName <= 2) { - angry = matchedCodeName - 1; - } else { - tamed = matchedCodeName == 3 ? -1 : 1; - } + WolfState state = PATTERNS.getInfo(matchedCodeName); + assert state != null; + isAngry = state.angry; + isTamed = state.tamed; if (exprs[0] != null && VARIANTS_ENABLED) variant = ((Literal) exprs[0]).getSingle(); if (exprs[1] != null) @@ -58,34 +106,38 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @Override protected boolean init(@Nullable Class entityClass, @Nullable Wolf wolf) { if (wolf != null) { - angry = wolf.isAngry() ? 1 : -1; - tamed = wolf.isTamed() ? 1 : -1; + isAngry = Kleenean.get(wolf.isAngry()); + isTamed = Kleenean.get(wolf.isTamed()); collarColor = wolf.getCollarColor(); if (VARIANTS_ENABLED) variant = wolf.getVariant(); + super.dataCodeName = PATTERNS.getMatchedPatterns(WolfState.getWolfState(isAngry, isTamed))[0]; } return true; } @Override - public void set(Wolf entity) { - if (angry != 0) - entity.setAngry(angry == 1); - if (tamed != 0) - entity.setTamed(tamed == 1); + public void set(Wolf wolf) { + wolf.setAngry(isAngry.isTrue()); + wolf.setTamed(isTamed.isTrue()); if (collarColor != null) - entity.setCollarColor(collarColor); - Object variantSet = null; + wolf.setCollarColor(collarColor); if (VARIANTS_ENABLED) { - variantSet = variant != null ? variant : CollectionUtils.getRandom(VARIANTS); - entity.setVariant((Wolf.Variant) variantSet); + Object variantSet = variant != null ? variant : CollectionUtils.getRandom(VARIANTS); + assert variantSet != null; + wolf.setVariant((Wolf.Variant) variantSet); } } @Override - public boolean match(Wolf entity) { - return (angry == 0 || entity.isAngry() == (angry == 1)) && (tamed == 0 || entity.isTamed() == (tamed == 1)) && - (collarColor == null || entity.getCollarColor() == collarColor) && (variant == null || entity.getVariant() == variant); + public boolean match(Wolf wolf) { + if (isAngry != Kleenean.UNKNOWN && isAngry != Kleenean.get(wolf.isAngry())) + return false; + if (isTamed != Kleenean.UNKNOWN && isTamed != Kleenean.get(wolf.isTamed())) + return false; + if (collarColor != null && collarColor != wolf.getCollarColor()) + return false; + return variant == null || variant == wolf.getVariant(); } @Override @@ -101,8 +153,8 @@ public Class getType() { @Override protected int hashCode_i() { int prime = 31, result = 1; - result = prime * result + angry; - result = prime * result + tamed; + result = prime * result + Objects.hashCode(isAngry); + result = prime * result + Objects.hashCode(isTamed);; result = prime * result + (collarColor == null ? 0 : collarColor.hashCode()); if (VARIANTS_ENABLED) result = prime * result + (variant == null ? 0 : Objects.hashCode(variant)); @@ -111,27 +163,28 @@ protected int hashCode_i() { @Override protected boolean equals_i(EntityData entityData) { - if (!(entityData instanceof WolfData)) + if (!(entityData instanceof WolfData other)) return false; - WolfData other = (WolfData) entityData; - if (angry != other.angry) + if (isAngry != other.isAngry) return false; - if (tamed != other.tamed) + if (isTamed != other.isTamed) return false; if (collarColor != other.collarColor) return false; - if (VARIANTS_ENABLED && variant != other.variant) - return false; - return true; + return variant == other.variant; } @Override public boolean isSupertypeOf(EntityData entityData) { - if (entityData instanceof WolfData) { - WolfData wolfData = (WolfData) entityData; - return (angry == 0 || wolfData.angry == angry) && (tamed == 0 || wolfData.tamed == tamed) && (wolfData.collarColor == collarColor) && (!VARIANTS_ENABLED || wolfData.variant == variant); - } - return false; + if (!(entityData instanceof WolfData other)) + return false; + if (isAngry != Kleenean.UNKNOWN && isAngry != other.isAngry) + return false; + if (isTamed != Kleenean.UNKNOWN && isTamed != other.isTamed) + return false; + if (collarColor != null && collarColor != other.collarColor) + return false; + return variant == null || variant == other.variant; } /** diff --git a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java index 407ad72d7fc..88f4a6352cc 100644 --- a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java +++ b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java @@ -98,14 +98,14 @@ protected int hashCode_i() { protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof ZombieVillagerData other)) return false; - return profession == null || profession.equals(other.profession); + return profession == other.profession; } @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof ZombieVillagerData other)) return false; - return profession == null || profession.equals(other.profession); + return profession == null || profession == other.profession; } } diff --git a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java index 9a201a7d8fc..e88cef59975 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java +++ b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java @@ -10,6 +10,7 @@ import ch.njol.skript.variables.Variables; import org.bukkit.Bukkit; import org.bukkit.Color; +import org.bukkit.World; import org.bukkit.block.data.BlockData; import org.bukkit.entity.BlockDisplay; import org.bukkit.entity.Display; @@ -38,8 +39,7 @@ private enum DisplayType { ITEM("org.bukkit.entity.ItemDisplay", "item display"), TEXT("org.bukkit.entity.TextDisplay", "text display"); - @Nullable - private Class displaySubClass; + private @Nullable Class displaySubClass; private final String codeName; @SuppressWarnings("unchecked") @@ -68,14 +68,11 @@ public String toString() { private DisplayType type = DisplayType.ANY; - @Nullable - private BlockData blockData; + private @Nullable BlockData blockData; - @Nullable - private ItemStack item; + private @Nullable ItemStack item; - @Nullable - private String text; + private @Nullable String text; public DisplayData() {} @@ -190,6 +187,11 @@ public Class getType() { return type.displaySubClass != null ? type.displaySubClass : Display.class; } + @Override + public @NotNull EntityData getSuperType() { + return new DisplayData(DisplayType.ANY); + } + @Override protected int hashCode_i() { return type.hashCode(); @@ -210,8 +212,8 @@ public boolean isSupertypeOf(EntityData entityData) { } @Override - public @NotNull EntityData getSuperType() { - return new DisplayData(DisplayType.ANY); + public boolean canSpawn(@Nullable World world) { + return type != DisplayType.ANY; } } diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index d0c750a2e8b..da0932a2fa6 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -477,34 +477,107 @@ entities: age adjectives: baby: baby adult: adult - entity: - name: entit¦y¦ies @an - pattern: entit(y|plural:ies) - living entity: - name: living entit¦y¦ies - pattern: living entit(y|plural:ies) - projectile: - name: projectile¦s - pattern: projectile[plural:s] - creature: - name: creature¦s - pattern: creature[plural:s] - human: - name: human¦s - pattern: human[plural:s] - tipped arrow: - name: tipped arrow¦s - pattern: tipped arrow[plural:s] - arrow: - name: arrow¦s @an - pattern: arrow[plural:s] - spectral arrow: - name: spectral arrow - pattern: spectral[ ]arrow[plural:s] - bat: - name: bat¦s - pattern: bat[plural:s] - # boats! + + # AxolotlData + axolotl: + name: axolotl¦s @an + patterns: + 0: axolotl[plural:s] + 1: baby:axolotl (kid[plural:s]|child[plural:ren]) + lucy axolotl: + name: axolotl¦s + patterns: + 0: lucy axolotl[plural:s] + 1: baby:lucy axolotl (kid[plural:s]|child[plural:ren]) + wild axolotl: + name: axolotl¦s + patterns: + 0: wild axolotl[plural:s] + 1: baby:wild axolotl (kid[plural:s]|child[plural:ren]) + gold axolotl: + name: axolotl¦s + patterns: + 0: gold axolotl[plural:s] + 1: baby:gold axolotl (kid[plural:s]|child[plural:ren]) + cyan axolotl: + name: axolotl¦s + patterns: + 0: cyan axolotl[plural:s] + 1: baby:cyan axolotl (kid[plural:s]|child[plural:ren]) + blue axolotl: + name: axolotl¦s + patterns: + 0: blue axolotl[plural:s] + 1: baby:blue axolotl (kid[plural:s]|child[plural:ren]) + + # BeeData + bee: + name: bee¦s + pattern: bee[plural:s] + no nectar bee: + name: no nectar bee¦s + pattern: bee[plural:s] with(out| no) nectar + nectar bee: + name: nectar bee¦s + pattern: bee[plural:s] with nectar + happy bee: + name: happy bee¦s + pattern: happy bee[plural:s] + happy nectar bee: + name: happy nectar bee¦s + pattern: happy bee[plural:s] with nectar + happy no nectar bee: + name: happy no nectar bee¦s + pattern: happy bee[plural:s] with(out| no) nectar + angry bee: + name: angry bee¦s + pattern: angry bee[plural:s] + angry no nectar bee: + name: angry no nectar bee¦s + pattern: angry bee[plural:s] with(out| no) nectar + angry nectar bee: + name: angry nectar bee¦s + pattern: angry bee[plural:s] with nectar + + # BoatChestData + chest boat: + name: chest boat¦s + pattern: chest boat[plural:s] + any chest boat: + name: chest boat¦s + pattern: any chest boat[plural:s] + oak chest boat: + name: oak chest boat¦s + pattern: oak chest boat[plural:s] + spruce chest boat: + name: spruce chest boat¦s + pattern: spruce chest boat[plural:s] + birch chest boat: + name: birch chest boat¦s + pattern: birch chest boat[plural:s] + jungle chest boat: + name: jungle chest boat¦s + pattern: jungle chest boat[plural:s] + acacia chest boat: + name: acacia chest boat¦s + pattern: acacia chest boat[plural:s] + dark oak chest boat: + name: dark oak chest boat¦s + pattern: dark oak chest boat[plural:s] + cherry chest boat: + name: cherry chest boat¦s + pattern: cherry chest boat[plural:s] + mangrove chest boat: + name: mangrove chest boat¦s + pattern: mangrove chest boat[plural:s] + bamboo chest raft: + name: bamboo chest raft¦s + pattern: bamboo chest (raft|boat)[plural:s] + pale oak chest boat: + name: pale oak chest boat¦s + pattern: pale oak chest boat[plural:s] + + # BoatData boat: name: boat¦s pattern: boat[plural:s] @@ -541,22 +614,30 @@ entities: pale oak boat: name: pale oak boat¦s pattern: pale oak boat[plural:s] - blaze: - name: blaze¦s - pattern: blaze[plural:s] + + # CatData + cat: + name: cat¦s + patterns: + 0: [%-cattype%] cat[plural:s] + 1: tamed ocelot[plural:s] + 2: baby:[%-cattype%] kitten[plural:s] + + # ChickenData chicken: name: chicken¦s patterns: 0: [%-chickenvariant%] chicken[plural:s] 1: baby:[%-chickenvariant%] chick[plural:s] + + # CowData cow: name: cow¦s patterns: 0: [%-cowvariant%] cow[plural:s] 1: baby:[%-cowvariant%] cal(f|plural:ves) - cave spider: - name: cave spider¦s - pattern: cave[ ]spider[plural:s] + + # CreeperData creeper: name: creeper¦s pattern: creeper[plural:s] @@ -566,126 +647,140 @@ entities: powered creeper: name: powered creeper¦s pattern: (powered|charged) creeper[plural:s] - egg: - name: egg¦s @an - pattern: egg[plural:s] + + # DroppedItemData + dropped item: + name: dropped item¦s + patterns: + 0: dropped item[plural:s] + 1: unknown_plural:dropped %-itemtypes% + 2: dropped item entit(y|plural:ies) + adjective: dropped + + # EndermanData enderman: name: ender¦man¦men @an pattern: enderm(a|plural:e)n [(carrying|holding) %-itemtype%] format: %1$s holding %2$s - ender crystal: - name: ender crystal¦s @an - pattern: end[er][ ]crystal[plural:s] - ender dragon: - name: ender dragon¦s @an - pattern: ender[ ]dragon[plural:s] - ender pearl: - name: ender pearl¦s @an - pattern: ender[ ]pearl[plural:s] - ender eye: - name: ender eye¦s @an - pattern: ender eye[plural:s]|eye[plural:s] of ender - fireball: - name: fireball¦s - pattern: [(ghast|big)] fire[ ]ball[plural:s] - dragon fireball: - name: dragon fireball¦s - pattern: dragon fire[ ]ball[plural:s] - small fireball: - name: small fireball¦s - pattern: (small|blaze) fire[ ]ball[plural:s] - large fireball: - name: large fireball¦s - pattern: large fire[ ]ball[plural:s] - any fireball: - name: any fireball¦s - pattern: any fire[ ]ball[plural:s] - fish: - name: fish¦es - pattern: fish[plural:es] - tropical fish: - name: tropical fish¦es + + # FallingBlockData + falling block: + name: falling block¦s patterns: - 0: [%-color%[-%-color%]] tropical fish[plural:es] - 1: fully %-color% tropical fish[plural:es] - kob: - name: kob¦s + 0: falling block[plural:s] + 1: unknown_plural:falling %-itemtype% [block[s]] + adjective: falling + not a block error: Falling blocks must be blocks, not items + + # FoxData + fox: + name: fox¦es patterns: - 0: [%-color%[-%-color%]] kob[plural:s] - 1: fully %-color% kob[plural:s] - sunstreak: - name: sunstreak¦s + 0: fox[plural:es] + 1: baby:fox (kid[plural:s]|child[plural:ren]) + red fox: + name: red fox¦es patterns: - 0: [%-color%[-%-color%]] sunstreak[plural:s] - 1: fully %-color% sunstreak[plural:s] - snooper: - name: snooper¦s + 0: red fox[plural:es] + 1: baby:red fox (kid[plural:s]|child[plural:ren]) + snow fox: + name: snow fox¦es patterns: - 0: [%-color%[-%-color%]] snooper[plural:s] - 1: fully %-color% snooper[plural:s] - dasher: - name: dasher¦s + 0: snow fox[plural:es] + 1: baby:snow fox (kid[plural:s]|child[plural:ren]) + + # FrogData + frog: + name: frog¦s patterns: - 0: [%-color%[-%-color%]] dasher[plural:s] - 1: fully %-color% dasher[plural:s] - brinely: - name: brinely¦s + 0: frog[plural:s] + 1: baby:frog (kid[plural:s]|child[plural:ren]) + temperate frog: + name: temperate frog¦s patterns: - 0: [%-color%[-%-color%]] brinely[plural:s] - 1: fully %-color% brinely[plural:s] - spotty: - name: spotty¦s + 0: temperate frog[plural:s] + 1: baby:temperate frog (kid[plural:s]|child[plural:ren]) + warm frog: + name: warm frog¦s patterns: - 0: [%-color%[-%-color%]] spotty[plural:s] - 1: fully %-color% spotty[plural:s] - flopper: - name: flopper¦s + 0: warm frog[plural:s] + 1: baby:warm frog (kid[plural:s]|child[plural:ren]) + cold frog: + name: cold frog¦s patterns: - 0: [%-color%[-%-color%]] flopper[plural:s] - 1: fully %-color% flopper[plural:s] - stripey: - name: stripey¦s + 0: cold frog[plural:s] + 1: baby:cold frog (kid[plural:s]|child[plural:ren]) + + # GoatData + goat: + name: goat¦s patterns: - 0: [%-color%[-%-color%]] stripey[plural:s] - 1: fully %-color% stripey[plural:s] - glitter: - name: glitter¦s + 0: goat[plural:s] + 1: baby:goat (kid[plural:s]|child[plural:ren]) + screaming goat: + name: goat¦s patterns: - 0: [%-color%[-%-color%]] glitter[plural:s] - 1: fully %-color% glitter[plural:s] - blockfish: - name: blockfish¦s + 0: screaming goat[plural:s] + 1: baby:screaming goat (kid[plural:s]|child[plural:ren]) + quiet goat: + name: goat¦s patterns: - 0: [%-color%[-%-color%]] blockfish[plural:[e]s] - 1: fully %-color% blockfish[plural:[e]s] - betty: - name: betty¦s + 0: quiet goat[plural:s] + 1: baby:quiet goat (kid[plural:s]|child[plural:ren]) + + # LlamaData + llama: + name: llama¦s patterns: - 0: [%-color%[-%-color%]] betty[plural:s] - 1: fully %-color% betty[plural:s] - clayfish: - name: clayfish¦s + 0: llama[plural:s] + 1: baby:llama cria[plural:s] + creamy llama: + name: creamy llama¦s patterns: - 0: [%-color%[-%-color%]] clayfish[plural:[e]s] - 1: fully %-color% clayfish[plural:[e]s] - ghast: - name: ghast¦s - pattern: ghast[plural:s] - giant: - name: giant¦s - pattern: giant[plural:s] - iron golem: - name: iron golem¦s @an - pattern: iron golem[plural:s] - lightning bolt: - name: lightning bolt¦s - pattern: lightning bolt[plural:s] - item frame: - name: item frame¦s @an - pattern: item[ ]frame[plural:s] - magma cube: - name: magma cube¦s - pattern: magma (cube|slime)[plural:s] + 0: creamy llama[plural:s] + 1: baby:creamy llama cria[plural:s] + white llama: + name: white llama¦s + patterns: + 0: white llama[plural:s] + 1: baby:white llama cria[plural:s] + brown llama: + name: brown llama¦s + patterns: + 0: brown llama[plural:s] + 1: baby:brown llama cria[plural:s] + gray llama: + name: gray llama¦s + patterns: + 0: gray llama[plural:s] + 1: baby:gray llama cria[plural:s] + trader llama: + name: trader llama¦s + patterns: + 0: trader llama[plural:s] + 1: baby:trader llama cria[plural:s] + creamy trader llama: + name: creamy trader llama¦s + patterns: + 0: creamy trader llama[plural:s] + 1: baby:creamy trader llama cria[plural:s] + white trader llama: + name: white trader llama¦s + patterns: + 0: white trader llama[plural:s] + 1: baby:white trader llama cria[plural:s] + brown trader llama: + name: brown trader llama¦s + patterns: + 0: brown trader llama[plural:s] + 1: baby:brown trader llama cria[plural:s] + gray trader llama: + name: gray trader llama¦s + patterns: + 0: gray trader llama[plural:s] + 1: baby:gray trader llama cria[plural:s] + + # MinecartData minecart: name: minecart¦s pattern: [mine]cart[plural:s] @@ -722,57 +817,137 @@ entities: patterns: 0: command [block] [mine]cart[plural:s] 1: [mine]cart[plural:s] with command block[s] + + # MooshroomData mooshroom: name: mooshroom¦s patterns: 0: (mooshroom[ cow]|mushroom cow)[plural:s] 1: baby:(mooshroom|mushroom) cal(f|plural:ves) + 2: baby:mooshroom (kid[plural:s]|child[plural:ren]) red mooshroom: name: red mooshroom¦s patterns: 0: red (mooshroom[ cow]|mushroom cow)[plural:s] - 1: baby:mooshroom (kid[plural:s]|child[plural:ren]) + 1: baby:red (mooshroom|mushroom) cal(f|plural:ves) + 2: baby:red mooshroom (kid[plural:s]|child[plural:ren]) brown mooshroom: name: brown mooshroom¦s patterns: 0: brown (mooshroom[ cow]|mushroom cow)[plural:s] - 1: baby:mooshroom (kid[plural:s]|child[plural:ren]) - ocelot: - name: ocelot¦s @an - pattern: ocelot[plural:s] - wild ocelot: - name: wild ocelot¦s - pattern: (wild|untamed) ocelot[plural:s] - cat: - name: cat¦s - patterns: - 0: [%-cattype%] cat[plural:s] - 1: tamed ocelot[plural:s] - 2: baby:[%-cattype%] kitten[plural:s] - painting: - name: painting¦s - pattern: painting[plural:s] + 1: baby:brown (mooshroom|mushroom) cal(f|plural:ves) + 2: baby:brown mooshroom (kid[plural:s]|child[plural:ren]) + + # PandaData + panda: + name: panda¦s + pattern: [%-gene%[[-]%-gene%]] panda[plural:s] + + # ParrotData + parrot: + name: parrot¦s + pattern: parrot[plural:s] + red parrot: + name: red parrot¦s + pattern: red parrot[plural:s] + blue parrot: + name: blue parrot¦s + pattern: blue parrot[plural:s] + green parrot: + name: green parrot¦s + pattern: green parrot[plural:s] + cyan parrot: + name: cyan parrot¦s + pattern: cyan parrot[plural:s] + gray parrot: + name: gray parrot¦s + pattern: gray parrot[plural:s] + + # PigData pig: name: pig¦s patterns: 0: [%-pigvariant%] pig[plural:s] - 1: baby:[%-pigvariant%] piglet[plural:s] + 1: [%-pigvariant%] pig[plural:s] + 2: baby:[%-pigvariant%] piglet[plural:s] saddled pig: name: saddled pig¦s - pattern: saddled [%-pigvariant%] pig[plural:s] + patterns: + 0: saddled [%-pigvariant%] pig[plural:s] + 1: [%-pigvariant%] saddled pig[plural:s] unsaddled pig: name: unsaddled pig¦s @an - pattern: unsaddled [%-pigvariant%] pig[plural:s] - player: - name: player¦s - pattern: player[plural:s] - zombie pigman: - name: zombie pig¦man¦men|zombified piglin patterns: - 0: zombie pigm(an|plural:en) - 1: zombified piglin[plural:s] - 2: baby:zombie pigletboy[plural:s] - 3: baby:zombified piglin (kid[plural:s]|child[plural:ren]) + 0: unsaddled [%-pigvariant%] pig[plural:s] + 1: [%-pigvariant%] unsaddled pig[plural:s] + + # RabbitData + rabbit: + name: rabbit¦s + patterns: + 0: rabbit[plural:s] + 1: rabbit [plural:s] + brown rabbit: + name: brown rabbit¦s + patterns: + 0: brown rabbit[plural:s] + 1: brown rabbit[plural:s] + 2: brown rabbit [plural:s] + black and white rabbit: + name: black and white rabbit¦s + patterns: + 0: black [and] white rabbit[plural:s] + 1: black [and] white rabbit[plural:s] + 2: black [and] white rabbit [plural:s] + white rabbit: + name: white rabbit¦s + patterns: + 0: white rabbit[plural:s] + 1: white rabbit[plural:s] + 2: white rabbit [plural:s] + black rabbit: + name: black rabbit¦s + patterns: + 0: black rabbit[plural:s] + 1: black rabbit[plural:s] + 2: black rabbit [plural:s] + gold rabbit: + name: gold rabbit¦s + patterns: + 0: gold rabbit[plural:s] + 1: gold rabbit[plural:s] + 2: gold rabbit [plural:s] + salt and pepper rabbit: + name: salt and pepper rabbit¦s + patterns: + 0: salt [and] pepper rabbit[plural:s] + 1: salt [and] pepper rabbit[plural:s] + 2: salt [and] pepper rabbit [plural:s] + killer rabbit: + name: killer rabbit¦s + patterns: + 0: killer rabbit[plural:s] + 1: killer rabbit[plural:s] + 2: killer rabbit [plural:s] + + # SalmonData + salmon: + name: salmon¦s + pattern: salmon[plural:s] + any salmon: + name: salmon¦s + pattern: any salmon[plural:s] + large salmon: + name: large salmon¦s + pattern: large salmon[plural:s] + medium salmon: + name: medium salmon¦s + pattern: medium salmon[plural:s] + small salmon: + name: small salmon¦s + pattern: small salmon[plural:s] + + # SheepData sheep: name: sheep # while sheep is ambiguous, sheeps is plural (even though it's wrong) @@ -782,74 +957,143 @@ entities: 2: baby:[%-colors%] lamb[plural:s] unsheared sheep: name: unsheared sheep @an - pattern: unsheared [%-colors%] sheep(unknown_plural:|plural:s) + patterns: + 0: unsheared [%-colors%] sheep(unknown_plural:|plural:s) + 1: [%-colors%] unsheared sheep(unknown_plural:|plural:s) sheared sheep: name: sheared sheep - pattern: sheared [%-colors%] sheep(unknown_plural:|plural:s) - silverfish: - name: silverfish¦es - pattern: silverfish[unknown_plural:|plural:es] - skeleton: - name: skeleton¦s - pattern: skeleton[plural:s] - slime: - name: slime¦s - pattern: slime[plural:s] - snowball: - name: snowball¦s - pattern: snowball[plural:s] - snow golem: - name: snow golem¦s - pattern: snow[ ](golem[plural:s]|m(an|plural:en)) - spider: - name: spider¦s - pattern: spider[plural:s] - squid: - name: squid¦s - pattern: squid[plural:s] - bottle of enchanting: - name: bottle¦ of enchanting¦s of enchanting - pattern: [thrown] bottle[plural:s] o(f|') enchanting|[e]xp[erience] bottle[plural:s] - tnt: - name: TNT - pattern: ([primed] TNT(unknown_plural:|plural:s)|TNT entit(y|plural:ies)) - villager: - name: villager¦s patterns: - 0: villager[plural:s] - 1: baby:[villager] (kid[plural:s]|child[plural:ren]) - normal: - name: villager¦s + 0: sheared [%-colors%] sheep(unknown_plural:|plural:s) + 1: [%-colors%] sheared sheep(unknown_plural:|plural:s) + + # StriderData + strider: + name: strider¦s patterns: - 0: [unemployed] villager[plural:s] - 1: baby:[[unemployed] villager] (kid[plural:s]|child[plural:ren]) - armorer: - name: armorer¦s + 0: strider[plural:s] + 1: baby:strider (kid[plural:s]|child[plural:ren]) + warm strider: + name: warm strider¦s patterns: - 0: armo[u]rer[plural:s] - 1: baby:armo[u]rer (kid[plural:s]|child[plural:ren]) - cartographer: - name: cartographer¦s + 0: warm strider[plural:s] + 1: baby:warm strider (kid[plural:s]|child[plural:ren]) + shivering strider: + name: shivering strider¦s, cold strider¦s patterns: - 0: cartographer[plural:s] - 1: baby:cartographer (kid[plural:s]|child[plural:ren]) - cleric: - name: cleric¦s + 0: (cold|shivering) strider[plural:s] + 1: baby:(cold|shivering) strider (kid[plural:s]|child[plural:ren]) + + # ThrownPotionData + thrown potion: + name: thrown potion¦s + pattern: thrown (potion[plural:s]|unknown_plural:%-itemtypes%) + adjective: thrown + + # TropicalFishData + tropical fish: + name: tropical fish¦es patterns: - 0: (priest|cleric)[plural:s] - 1: baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) - fisherman: - name: fisherman¦s + 0: [%-color%[-%-color%]] tropical fish[plural:es] + 1: fully %-color% tropical fish[plural:es] + kob: + name: kob¦s patterns: - 0: fisherman[plural:s] - 1: baby:fisherman (kid[plural:s]|child[plural:ren]) - fletcher: - name: fletcher¦s + 0: [%-color%[-%-color%]] kob[plural:s] + 1: fully %-color% kob[plural:s] + sunstreak: + name: sunstreak¦s patterns: - 0: fletcher[plural:s] - 1: baby:fletcher (kid[plural:s]|child[plural:ren]) - leatherworker: - name: leatherworker¦s + 0: [%-color%[-%-color%]] sunstreak[plural:s] + 1: fully %-color% sunstreak[plural:s] + snooper: + name: snooper¦s + patterns: + 0: [%-color%[-%-color%]] snooper[plural:s] + 1: fully %-color% snooper[plural:s] + dasher: + name: dasher¦s + patterns: + 0: [%-color%[-%-color%]] dasher[plural:s] + 1: fully %-color% dasher[plural:s] + brinely: + name: brinely¦s + patterns: + 0: [%-color%[-%-color%]] brinely[plural:s] + 1: fully %-color% brinely[plural:s] + spotty: + name: spotty¦s + patterns: + 0: [%-color%[-%-color%]] spotty[plural:s] + 1: fully %-color% spotty[plural:s] + flopper: + name: flopper¦s + patterns: + 0: [%-color%[-%-color%]] flopper[plural:s] + 1: fully %-color% flopper[plural:s] + stripey: + name: stripey¦s + patterns: + 0: [%-color%[-%-color%]] stripey[plural:s] + 1: fully %-color% stripey[plural:s] + glitter: + name: glitter¦s + patterns: + 0: [%-color%[-%-color%]] glitter[plural:s] + 1: fully %-color% glitter[plural:s] + blockfish: + name: blockfish¦s + patterns: + 0: [%-color%[-%-color%]] blockfish[plural:[e]s] + 1: fully %-color% blockfish[plural:[e]s] + betty: + name: betty¦s + patterns: + 0: [%-color%[-%-color%]] betty[plural:s] + 1: fully %-color% betty[plural:s] + clayfish: + name: clayfish¦s + patterns: + 0: [%-color%[-%-color%]] clayfish[plural:[e]s] + 1: fully %-color% clayfish[plural:[e]s] + + # VillagerData + villager: + name: villager¦s + patterns: + 0: villager[plural:s] + 1: baby:villager (kid[plural:s]|child[plural:ren]) + unemployed: + name: unemployed villager¦s + patterns: + 0: (unemployed|jobless) villager[plural:s] + 1: baby:(unemployed|jobless|normal) villager (kid[plural:s]|child[plural:ren]) + armorer: + name: armorer¦s + patterns: + 0: armo[u]rer[plural:s] + 1: baby:armo[u]rer (kid[plural:s]|child[plural:ren]) + cartographer: + name: cartographer¦s + patterns: + 0: cartographer[plural:s] + 1: baby:cartographer (kid[plural:s]|child[plural:ren]) + cleric: + name: cleric¦s + patterns: + 0: cleric[plural:s] + 1: baby:cleric (kid[plural:s]|child[plural:ren]) + fisherman: + name: fisherman¦s + patterns: + 0: fisherman[plural:s] + 1: baby:fisherman (kid[plural:s]|child[plural:ren]) + fletcher: + name: fletcher¦s + patterns: + 0: fletcher[plural:s] + 1: baby:fletcher (kid[plural:s]|child[plural:ren]) + leatherworker: + name: leatherworker¦s patterns: 0: leatherworker[plural:s] 1: baby:leatherworker (kid[plural:s]|child[plural:ren]) @@ -883,16 +1127,6 @@ entities: patterns: 0: librarian[plural:s] 1: baby:librarian (kid[plural:s]|child[plural:ren]) - priest: - name: priest¦s - patterns: - 0: (priest|cleric)[plural:s] - 1: baby:(priest|cleric) (kid[plural:s]|child[plural:ren]) - blacksmith: - name: blacksmith¦s - patterns: - 0: [black]smith[plural:s] - 1: baby:[black]smith (kid[plural:s]|child[plural:ren]) butcher: name: butcher¦s patterns: @@ -903,18 +1137,8 @@ entities: patterns: 0: nitwit[plural:s] 1: baby:nitwit (kid[plural:s]|child[plural:ren]) - witch: - name: witch¦es - pattern: witch[plural:es] - wither: - name: wither¦s - pattern: wither[plural:s] - wither skeleton: - name: wither skeleton¦s - pattern: wither skeleton[plural:s] - wither skull: - name: wither skull¦s - pattern: wither skull[ projectile][plural:s] + + # WolfData wolf: name: wol¦f¦ves pattern: [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] @@ -933,355 +1157,340 @@ entities: peaceful wolf: name: peaceful wol¦f¦ves pattern: (peaceful|neutral|unaggressive) [%-wolfvariant%] wol(f|plural:ves) [[with collar] colo[u]r[ed] %-color%] - zombie: - name: zombie¦s - patterns: - 0: zombie[plural:s] - 1: baby:zombie (kid[plural:s]|child[plural:ren]) + + # XpOrbData xp-orb: name: experience orb¦s @an pattern: ([e]xp|experience)( |-)orb[plural:s] format: %2$s-%1$s - firework: - name: firework rocket¦s - pattern: firework[ rocket][plural:s] - falling block: - name: falling block¦s - patterns: - 0: falling block[plural:s] - 1: unknown_plural:falling %-itemtype% [block[s]] - adjective: falling - not a block error: Falling blocks must be blocks, not items - thrown potion: - name: thrown potion¦s - pattern: thrown (potion[plural:s]|unknown_plural:%-itemtypes%) - adjective: thrown - dropped item: - name: dropped item¦s - patterns: - 0: dropped item[plural:s] - 1: unknown_plural:dropped %-itemtypes% - 2: dropped item entit(y|plural:ies) - adjective: dropped - horse: - name: horse¦s - pattern: horse[plural:s]|baby:foal[plural:s] - donkey: - name: donkey¦s - pattern: donkey[plural:s] - mule: - name: mule¦s - pattern: mule[plural:s] - chested horse: - name: chested horse¦s - pattern: chested horse[plural:s] - undead horse: - name: undead horse¦s @an - patterns: - 0: (zombie|undead) horse[plural:s] - 1: (zombie|undead) horse[plural:s] - 2: baby:(zombie|undead) foal[plural:s] - skeleton horse: - name: skeleton horse¦s - patterns: - 0: skeleton horse[plural:s] - 1: skeleton horse[plural:s] - 2: baby:skeleton foal[plural:s] - any horse: - name: any horse¦s - patterns: - 0: any horse[plural:s] - 1: baby:foal[plural:s] - llama: - name: llama¦s - patterns: - 0: llama[plural:s] - 1: baby:llama cria[plural:s] - creamy llama: - name: creamy llama¦s - patterns: - 0: creamy llama[plural:s] - 1: baby:creamy llama cria[plural:s] - white llama: - name: white llama¦s + + # ZombieVillagerData + zombie villager: + name: zombie villager¦s + pattern: zombie villager[plural:s] + zombie normal: + name: zombie villager¦s + pattern: (unemployed|jobless|normal) zombie villager[plural:s] + zombie farmer: + name: zombie farmer¦s + pattern: zombie farmer[plural:s] + zombie librarian: + name: zombie librarian¦s + pattern: zombie librarian[plural:s] + zombie butcher: + name: zombie butcher¦s + pattern: zombie butcher[plural:s] + zombie nitwit: + name: zombie nitwit¦s + pattern: zombie nitwit[plural:s] + zombie armorer: + name: zombie armorer¦s + pattern: zombie armo[u]rer[plural:s] + zombie cartographer: + name: zombie cartographer¦s + pattern: zombie cartographer[plural:s] + zombie cleric: + name: zombie cleric¦s + pattern: zombie cleric[plural:s] + zombie fisherman: + name: zombie fisher¦man¦men + pattern: zombie fisherm(an|plural:en) + zombie fletcher: + name: zombie fletcher¦s + pattern: zombie fletcher[plural:s] + zombie leatherworker: + name: zombie leatherworker¦s + pattern: zombie leatherworker[plural:s] + zombie mason: + name: zombie mason¦s + pattern: zombie mason[plural:s] + zombie shepherd: + name: zombie shepherd¦s + pattern: zombie shepherd[plural:s] + zombie toolsmith: + name: zombie toolsmith¦s + pattern: zombie toolsmith[plural:s] + zombie weaponsmith: + name: zombie weaponsmith¦s + pattern: zombie weaponsmith[plural:s] + + # DisplayData + display: + name: display¦s patterns: - 0: white llama[plural:s] - 1: baby:white llama cria[plural:s] - brown llama: - name: brown llama¦s + 0: display[plural:s] + 1: display entit(y|plural:ies) + block display: + name: block display¦s patterns: - 0: brown llama[plural:s] - 1: baby:brown llama cria[plural:s] - gray llama: - name: gray llama¦s + 0: block display[plural:s] [of %-blockdata/itemtype%] + 1: block display entit(y|plural:ies) [of %-blockdata/itemtype%] + 2: %-blockdata/itemtype% block display[plural:s] + 3: %-blockdata/itemtype% block display entit(y|plural:ies) + item display: + name: item display¦s patterns: - 0: gray llama[plural:s] - 1: baby:gray llama cria[plural:s] - trader llama: - name: trader llama¦s + 0: item display[plural:s] [of %-itemtype%] + 1: item display entit(y|plural:ies) [of %-itemtype%] + 2: %-itemtype% item display[plural:s] + 3: %-itemtype% item display entit(y|plural:ies) + text display: + name: text display¦s patterns: - 0: trader llama[plural:s] - 1: baby:trader llama cria[plural:s] - creamy trader llama: - name: creamy trader llama¦s + 0: text display[plural:s] + 1: text display entit(y|plural:ies) + + # SimpleEntityData + + # Alpha + Beta Entities + zombie: + name: zombie¦s patterns: - 0: creamy trader llama[plural:s] - 1: baby:creamy trader llama cria[plural:s] - white trader llama: - name: white trader llama¦s + 0: zombie[plural:s] + 1: baby:zombie (kid[plural:s]|child[plural:ren]) + skeleton: + name: skeleton¦s + pattern: skeleton[plural:s] + tnt: + name: TNT + pattern: ([primed] TNT(unknown_plural:|plural:s)|TNT entit(y|plural:ies)) + spider: + name: spider¦s + pattern: spider[plural:s] + player: + name: player¦s + pattern: player[plural:s] + lightning bolt: + name: lightning bolt¦s + pattern: lightning bolt[plural:s] + giant: + name: giant¦s + pattern: giant[plural:s] + ghast: + name: ghast¦s + pattern: ghast[plural:s] + fish hook: + name: fish hook¦s + pattern: fish[ ]hook[plural:s] + fireball: + name: fireball¦s + pattern: [(ghast|big)] fire[ ]ball[plural:s] + dragon fireball: + name: dragon fireball¦s + pattern: dragon fire[ ]ball[plural:s] + small fireball: + name: small fireball¦s + pattern: (small|blaze) fire[ ]ball[plural:s] + large fireball: + name: large fireball¦s + pattern: large fire[ ]ball[plural:s] + ender crystal: + name: ender crystal¦s @an + pattern: end[er][ ]crystal[plural:s] + ender dragon: + name: ender dragon¦s @an + pattern: ender[ ]dragon[plural:s] + ender pearl: + name: ender pearl¦s @an + pattern: ender[ ]pearl[plural:s] + egg: + name: egg¦s @an + pattern: egg[plural:s] + cave spider: + name: cave spider¦s + pattern: cave[ ]spider[plural:s] + arrow: + name: arrow¦s @an + pattern: arrow[plural:s] + squid: + name: squid¦s + pattern: squid[plural:s] + + # 1.0 Entities + snowball: + name: snowball¦s + pattern: snowball[plural:s] + snow golem: + name: snow golem¦s + pattern: snow[ ](golem[plural:s]|m(an|plural:en)) + slime: + name: slime¦s + pattern: slime[plural:s] + magma cube: + name: magma cube¦s + pattern: magma (cube|slime)[plural:s] + ender eye: + name: ender eye¦s @an + pattern: ender eye[plural:s]|eye[plural:s] of ender + blaze: + name: blaze¦s + pattern: blaze[plural:s] + + # 1.2 Entities + zombie pigman: + name: zombie pig¦man¦men|zombified piglin patterns: - 0: white trader llama[plural:s] - 1: baby:white trader llama cria[plural:s] - brown trader llama: - name: brown trader llama¦s + 0: zombie pigm(an|plural:en) + 1: zombified piglin[plural:s] + 2: baby:zombie pigletboy[plural:s] + 3: baby:zombified piglin (kid[plural:s]|child[plural:ren]) + bottle of enchanting: + name: bottle¦ of enchanting¦s of enchanting + pattern: [thrown] bottle[plural:s] o(f|') enchanting|[e]xp[erience] bottle[plural:s] + iron golem: + name: iron golem¦s @an + pattern: iron golem[plural:s] + ocelot: + name: ocelot¦s @an + pattern: [wild|untamed] ocelot[plural:s] + + # 1.4 Entities + wither: + name: wither¦s + pattern: wither[plural:s] + wither skeleton: + name: wither skeleton¦s + pattern: wither skeleton[plural:s] + wither skull: + name: wither skull¦s + pattern: wither skull[ projectile][plural:s] + firework: + name: firework rocket¦s + pattern: firework[ rocket][plural:s] + witch: + name: witch¦es + pattern: witch[plural:es] + bat: + name: bat¦s + pattern: bat[plural:s] + item frame: + name: item frame¦s @an + pattern: item[ ]frame[plural:s] + painting: + name: painting¦s + pattern: painting[plural:s] + + # 1.6 Entities + horse: + name: horse¦s + pattern: horse[plural:s]|baby:foal[plural:s] + donkey: + name: donkey¦s + pattern: donkey[plural:s] + mule: + name: mule¦s + pattern: mule[plural:s] + undead horse: + name: undead horse¦s @an patterns: - 0: brown trader llama[plural:s] - 1: baby:brown trader llama cria[plural:s] - gray trader llama: - name: gray trader llama¦s + 0: (zombie|undead) horse[plural:s] + 1: (zombie|undead) horse[plural:s] + 2: baby:(zombie|undead) foal[plural:s] + skeleton horse: + name: skeleton horse¦s patterns: - 0: gray trader llama[plural:s] - 1: baby:gray trader llama cria[plural:s] - llama spit: - name: llama spit¦s - pattern: llama spit[plural:s] + 0: skeleton horse[plural:s] + 1: skeleton horse[plural:s] + 2: baby:skeleton foal[plural:s] + leash hitch: + name: leash hitch¦es + pattern: leash hitch[plural:es] + + # 1.8 Entities elder guardian: name: elder guardian¦s pattern: elder guardian[plural:s] - guardian: - name: guardian¦s - pattern: guardian[plural:s] normal guardian: name: normal guardian¦s pattern: normal guardian[plural:s] - rabbit: - name: rabbit¦s - patterns: - 0: rabbit[plural:s] - 1: rabbit [plural:s] - brown rabbit: - name: brown rabbit¦s - patterns: - 0: brown rabbit[plural:s] - 1: brown rabbit [plural:s] - black and white rabbit: - name: black and white rabbit¦s - patterns: - 0: black [and] white rabbit[plural:s] - 1: black [and] white rabbit [plural:s] - white rabbit: - name: white rabbit¦s - patterns: - 0: white rabbit[plural:s] - 1: white rabbit [plural:s] - black rabbit: - name: black rabbit¦s - patterns: - 0: black rabbit[plural:s] - 1: black rabbit [plural:s] - gold rabbit: - name: gold rabbit¦s - patterns: - 0: gold rabbit[plural:s] - 1: gold rabbit [plural:s] - salt and pepper rabbit: - name: salt and pepper rabbit¦s - patterns: - 0: salt [and] pepper rabbit[plural:s] - 1: salt [and] pepper rabbit [plural:s] - killer rabbit: - name: killer rabbit¦s - patterns: - 0: killer rabbit[plural:s] - 1: killer rabbit [plural:s] - fish hook: - name: fish hook¦s - pattern: fish[ ]hook[plural:s] armor stand: name: armor stand¦s pattern: armo[u]r stand[plural:s] endermite: name: endermite¦s pattern: endermite[plural:s] - stray: - name: stray¦s - pattern: stray[plural:s] - golem: - name: golem¦s - pattern: golem[plural:s] + silverfish: + name: silverfish¦es + pattern: silverfish[unknown_plural:|plural:es] + tipped arrow: + name: tipped arrow¦s + pattern: tipped arrow[plural:s] + + # 1.9 Entities + area effect cloud: + name: area effect cloud¦s + pattern: area effect cloud[plural:s] shulker: name: shulker¦s pattern: shulker[plural:s] shulker bullet: name: shulker bullet¦s pattern: shulker bullet[plural:s] - polar bear: - name: polar bear¦s - pattern: polar bear[plural:s] - area effect cloud: - name: area effect cloud¦s - pattern: area effect cloud[plural:s] + spectral arrow: + name: spectral arrow + pattern: spectral[ ]arrow[plural:s] + + # 1.10 Entities husk: name: husk¦s pattern: husk[plural:s] - zombie villager: - name: zombie villager¦s - pattern: zombie villager[plural:s] - zombie normal: - name: zombie villager¦s - pattern: unemployed zombie villager[plural:s] - zombie farmer: - name: zombie farmer¦s - pattern: zombie farmer[plural:s] - zombie librarian: - name: zombie librarian¦s - pattern: zombie librarian[plural:s] - zombie priest: - name: zombie priest¦s - pattern: zombie priest[plural:s] - zombie blacksmith: - name: zombie blacksmith¦s - pattern: zombie blacksmith[plural:s] - zombie butcher: - name: zombie butcher¦s - pattern: zombie butcher[plural:s] - zombie nitwit: - name: zombie nitwit¦s - pattern: zombie nitwit[plural:s] - zombie armorer: - name: zombie armorer¦s - pattern: zombie armo[u]rer[plural:s] - zombie cartographer: - name: zombie cartographer¦s - pattern: zombie cartographer[plural:s] - zombie cleric: - name: zombie cleric¦s - pattern: zombie cleric[plural:s] - zombie fisherman: - name: zombie fisher¦man¦men - pattern: zombie fisherm(an|plural:en) - zombie fletcher: - name: zombie fletcher¦s - pattern: zombie fletcher[plural:s] - zombie leatherworker: - name: zombie leatherworker¦s - pattern: zombie leatherworker[plural:s] - zombie mason: - name: zombie mason¦s - pattern: zombie mason[plural:s] - zombie shepherd: - name: zombie shepherd¦s - pattern: zombie shepherd[plural:s] - zombie toolsmith: - name: zombie toolsmith¦s - pattern: zombie toolsmith[plural:s] - zombie weaponsmith: - name: zombie weaponsmith¦s - pattern: zombie weaponsmith[plural:s] + stray: + name: stray¦s + pattern: stray[plural:s] + polar bear: + name: polar bear¦s + pattern: polar bear[plural:s] + + # 1.11 Entities + llama spit: + name: llama spit¦s + pattern: llama spit[plural:s] + vindicator: + name: vindicator¦s + pattern: vindicator[plural:s] + vex: + name: vex¦es + pattern: vex[plural:es] evoker: name: evoker¦s pattern: evoker[plural:s] evoker fangs: name: evoker fangs pattern: evoker fangs + + # 1.12 Entities illusioner: name: illusioner¦s pattern: illusioner[plural:s] - vex: - name: vex¦es - pattern: vex[plural:es] - vindicator: - name: vindicator¦s - pattern: vindicator[plural:s] - illager: - name: illager¦s - pattern: illager[plural:s] - spellcaster: - name: spellcaster¦s - pattern: spellcaster[plural:s] - parrot: - name: parrot¦s - pattern: parrot[plural:s] - red parrot: - name: red parrot¦s - pattern: red parrot[plural:s] - blue parrot: - name: blue parrot¦s - pattern: blue parrot[plural:s] - green parrot: - name: green parrot¦s - pattern: green parrot[plural:s] - cyan parrot: - name: cyan parrot¦s - pattern: cyan parrot[plural:s] - gray parrot: - name: gray parrot¦s - pattern: gray parrot[plural:s] - monster: - name: monster¦s - pattern: monster[plural:s] - mob: - name: mob¦s - pattern: mob[plural:s] - animal: - name: animal¦s - pattern: animal[plural:s] - damageable: - name: damageable mob¦s - pattern: damageable mob[plural:s] - water mob: - name: water mob¦s - pattern: water mob[plural:s] + + # 1.13 Entities + trident: + name: trident¦s + pattern: trident[plural:s] cod: name: cod¦s pattern: cod[plural:s] - salmon: - name: salmon¦s - pattern: salmon[plural:s] puffer fish: name: puffer fish¦es pattern: puffer[ ]fish[plural:es] - tropical fish: - name: tropical fish¦es - pattern: tropical fish[plural:es] - drowned: - name: drowned¦s - patterns: - 0: drowned[plural:s] - 1: baby:drowned (kid[plural:s]|child[plural:ren]) - dolphin: - name: dolphin¦s - pattern: dolphin[plural:s] - phantom: - name: phantom¦s - pattern: phantom[plural:s] turtle: name: turtle¦s patterns: 0: turtle[plural:s] 1: baby:turtle (kid[plural:s]|child[plural:ren]) - trident: - name: trident¦s - pattern: trident[plural:s] - leash hitch: - name: leash hitch¦es - pattern: leash hitch[plural:es] - #1.14 entities - fox: - name: fox¦es - patterns: - 0: fox[plural:es] - 1: baby:fox (kid[plural:s]|child[plural:ren]) - red fox: - name: red fox¦es - patterns: - 0: red fox[plural:es] - 1: baby:red fox (kid[plural:s]|child[plural:ren]) - snow fox: - name: snow fox¦es + drowned: + name: drowned¦s patterns: - 0: snow fox[plural:es] - 1: baby:snow fox (kid[plural:s]|child[plural:ren]) + 0: drowned[plural:s] + 1: baby:drowned (kid[plural:s]|child[plural:ren]) + dolphin: + name: dolphin¦s + pattern: dolphin[plural:s] + phantom: + name: phantom¦s + pattern: phantom[plural:s] + + # 1.14 Entities pillager: name: pillager¦s pattern: pillager[plural:s] @@ -1293,32 +1502,8 @@ entities: patterns: 0: wandering trader[plural:s] 1: baby:wandering trader (kid[plural:s]|child[plural:ren]) - raider: - name: raider¦s - pattern: raider[plural:s] - panda: - name: panda¦s - pattern: [%-gene%[%-gene%]] panda[plural:s] - #1.15 entity - no nectar bee: - name: no nectar bee¦s - pattern: bee[plural:s] without nectar - happy bee: - name: happy bee¦s - pattern: happy bee[plural:s] - bee: - name: bee¦s - pattern: bee[plural:s] - nectar bee: - name: nectar bee¦s - pattern: bee[plural:s] with nectar - angry bee: - name: angry bee¦s - pattern: angry bee[plural:s] - angry nectar bee: - name: angry nectar bee¦s - pattern: angry bee[plural:s] with nectar - #1.16 entities + + # 1.16 Entities piglin: name: piglin¦s patterns: @@ -1334,139 +1519,24 @@ entities: patterns: 0: zoglin[plural:s] 1: baby:zoglin (kid[plural:s]|child[plural:ren]) - strider: - name: strider¦s - patterns: - 0: strider[plural:s] - 1: baby:strider (kid[plural:s]|child[plural:ren]) - warm strider: - name: warm strider¦s - patterns: - 0: warm strider[plural:s] - 1: baby:warm strider (kid[plural:s]|child[plural:ren]) - shivering strider: - name: shivering strider¦s, cold strider¦s - patterns: - 0: (cold|shivering) strider[plural:s] - 1: baby:(cold|shivering) strider (kid[plural:s]|child[plural:ren]) - #1.16.2 entity piglin brute: name: piglin brute¦s patterns: 0: piglin brute[plural:s] 1: baby:piglin brute (kid[plural:s]|child[plural:ren]) - #1.17 entities - goat: - name: goat¦s - patterns: - 0: goat[plural:s] - 1: baby:goat (kid[plural:s]|child[plural:ren]) - screaming goat: - name: goat¦s - patterns: - 0: screaming goat[plural:s] - 1: baby:screaming goat (kid[plural:s]|child[plural:ren]) - quiet goat: - name: goat¦s - patterns: - 0: quiet goat[plural:s] - 1: baby:quiet goat (kid[plural:s]|child[plural:ren]) + + # 1.17 Entities glow squid: name: glow squid¦s pattern: glow squid[plural:s] - axolotl: - name: axolotl¦s @an - patterns: - 0: axolotl[plural:s] - 1: baby:axolotl (kid[plural:s]|child[plural:ren]) - lucy axolotl: - name: axolotl¦s - patterns: - 0: lucy axolotl[plural:s] - 1: baby:lucy axolotl (kid[plural:s]|child[plural:ren]) - wild axolotl: - name: axolotl¦s - patterns: - 0: wild axolotl[plural:s] - 1: baby:wild axolotl (kid[plural:s]|child[plural:ren]) - gold axolotl: - name: axolotl¦s - patterns: - 0: gold axolotl[plural:s] - 1: baby:gold axolotl (kid[plural:s]|child[plural:ren]) - cyan axolotl: - name: axolotl¦s - patterns: - 0: cyan axolotl[plural:s] - 1: baby:cyan axolotl (kid[plural:s]|child[plural:ren]) - blue axolotl: - name: axolotl¦s - patterns: - 0: blue axolotl[plural:s] - 1: baby:blue axolotl (kid[plural:s]|child[plural:ren]) marker: name: marker¦s pattern: marker[plural:s] glow item frame: name: glow item frame¦s pattern: glow item[ ]frame[plural:s] + # 1.19 Entities - chest boat: - name: chest boat¦s - pattern: chest boat[plural:s] - any chest boat: - name: chest boat¦s - pattern: any chest boat[plural:s] - oak chest boat: - name: oak chest boat¦s - pattern: oak chest boat[plural:s] - spruce chest boat: - name: spruce chest boat¦s - pattern: spruce chest boat[plural:s] - birch chest boat: - name: birch chest boat¦s - pattern: birch chest boat[plural:s] - jungle chest boat: - name: jungle chest boat¦s - pattern: jungle chest boat[plural:s] - acacia chest boat: - name: acacia chest boat¦s - pattern: acacia chest boat[plural:s] - dark oak chest boat: - name: dark oak chest boat¦s - pattern: dark oak chest boat[plural:s] - cherry chest boat: - name: cherry chest boat¦s - pattern: cherry chest boat[plural:s] - mangrove chest boat: - name: mangrove chest boat¦s - pattern: mangrove chest boat[plural:s] - bamboo chest raft: - name: bamboo chest raft¦s - pattern: bamboo chest (raft|boat)[plural:s] - pale oak chest boat: - name: pale oak chest boat¦s - pattern: pale oak chest boat[plural:s] - frog: - name: frog¦s - patterns: - 0: frog[plural:s] - 1: baby:frog (kid[plural:s]|child[plural:ren]) - temperate frog: - name: temperate frog¦s - patterns: - 0: temperate frog[plural:s] - 1: baby:temperate frog (kid[plural:s]|child[plural:ren]) - warm frog: - name: warm frog¦s - patterns: - 0: warm frog[plural:s] - 1: baby:warm frog (kid[plural:s]|child[plural:ren]) - cold frog: - name: cold frog¦s - patterns: - 0: cold frog[plural:s] - 1: baby:cold frog (kid[plural:s]|child[plural:ren]) allay: name: allay¦s pattern: allay[plural:s] @@ -1476,44 +1546,16 @@ entities: warden: name: warden¦s pattern: warden[plural:s] - # 1.19.3 Entities - enemy: - name: enem¦y¦ies @an - pattern: enem(y|plural:ies) camel: name: camel¦s pattern: camel[plural:s] - # 1.19.4 Entities sniffer: name: sniffer¦s pattern: sniffer[plural:s] interaction: name: interaction¦s pattern: interaction[plural:s] - display: - name: display¦s - patterns: - 0: display[plural:s] - 1: display entit(y|plural:ies) - block display: - name: block display¦s - patterns: - 0: block display[plural:s] [of %-blockdata/itemtype%] - 1: block display entit(y|plural:ies) [of %-blockdata/itemtype%] - 2: %-blockdata/itemtype% block display[plural:s] - 3: %-blockdata/itemtype% block display entit(y|plural:ies) - item display: - name: item display¦s - patterns: - 0: item display[plural:s] [of %-itemtype%] - 1: item display entit(y|plural:ies) [of %-itemtype%] - 2: %-itemtype% item display[plural:s] - 3: %-itemtype% item display entit(y|plural:ies) - text display: - name: text display¦s - patterns: - 0: text display[plural:s] - 1: text display entit(y|plural:ies) + # 1.20.3 Entities breeze: name: breeze¦s @@ -1521,6 +1563,7 @@ entities: wind charge: name: wind charge¦s pattern: wind charge[plural:s] + # 1.20.5 Entities armadillo: name: armadillo¦s @an @@ -1530,23 +1573,12 @@ entities: bogged: name: bogged¦s pattern: bogged[plural:s] + # 1.21.2 Entities - any salmon: - name: salmon¦s - pattern: any salmon[plural:s] - large salmon: - name: large salmon¦s - pattern: large salmon[plural:s] - medium salmon: - name: medium salmon¦s - pattern: medium salmon[plural:s] - small salmon: - name: small salmon¦s - pattern: small salmon[plural:s] - # 1.21.3 Entities creaking: name: creaking¦s pattern: creaking[plural:s] + # 1.21.6 Entities happy ghast: name: happy ghast¦s @@ -1554,6 +1586,70 @@ entities: 0: happy ghast[plural:s] 1: baby:[happy] ghastling[plural:s] + # SuperTypes + human: + name: human¦s + pattern: human[plural:s] + damageable: + name: damageable mob¦s + pattern: damageable mob[plural:s] + monster: + name: monster¦s + pattern: monster[plural:s] + mob: + name: mob¦s + pattern: mob[plural:s] + creature: + name: creature¦s + pattern: creature[plural:s] + animal: + name: animal¦s + pattern: animal[plural:s] + fish: + name: fish¦es + pattern: fish[plural:es] + golem: + name: golem¦s + pattern: golem[plural:s] + projectile: + name: projectile¦s + pattern: projectile[plural:s] + living entity: + name: living entit¦y¦ies + pattern: living entit(y|plural:ies) + entity: + name: entit¦y¦ies @an + pattern: entit(y|plural:ies) + chested horse: + name: chested horse¦s + pattern: chested horse[plural:s] + any horse: + name: any horse¦s + patterns: + 0: any horse[plural:s] + 1: baby:foal[plural:s] + guardian: + name: guardian¦s + pattern: guardian[plural:s] + water mob: + name: water mob¦s + pattern: water mob[plural:s] + any fireball: + name: any fireball¦s + pattern: any fire[ ]ball[plural:s] + illager: + name: illager¦s + pattern: illager[plural:s] + spellcaster: + name: spellcaster¦s + pattern: spellcaster[plural:s] + raider: + name: raider¦s + pattern: raider[plural:s] + enemy: + name: enem¦y¦ies @an + pattern: enem(y|plural:ies) + # -- Heal Reasons -- heal reasons: custom: unknown, custom, plugin, a plugin diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk new file mode 100644 index 00000000000..c5563c351f8 --- /dev/null +++ b/src/test/skript/tests/misc/EntityData.sk @@ -0,0 +1,221 @@ + +local function compareData(data1: entity types, data2: entity types): + loop {_data1::*}: + if loop-value is spawnable: + spawn (loop-value) at test-location: + set {_entity} to event-entity + assert {_entity} is loop-value with "Spawned '%{_entity}%' should match against own EntityData '%loop-value%'" + loop {_data2::*}: + assert loop-value-1 is loop-value-2 with "EntityData '%loop-value-1%' should match against EntityData '%loop-value-2%'" + if {_entity} is set: + assert {_entity} is loop-value-2 with "Spawned '%{_entity}%' should match against EntityData '%loop-value-2%'" + clear entity within {_entity} + +test "axolotl data": + compareData((axolotl, lucy axolotl, wild axolotl, gold axolotl, cyan axolotl, blue axolotl) , (axolotl)) + compareData((baby axolotl, baby lucy axolotl, baby wild axolotl, baby gold axolotl, baby cyan axolotl, baby blue axolotl) , (axolotl, baby axolotl)) + compareData((adult axolotl, adult lucy axolotl, adult wild axolotl, adult gold axolotl, adult cyan axolotl, adult blue axolotl) , (axolotl, adult axolotl)) + compareData((axolotl kid, lucy axolotl kid, wild axolotl kid, gold axolotl kid, cyan axolotl kid, blue axolotl kid) , (axolotl, axolotl kid, baby axolotl)) + +test "bee data": + compareData((bee, bee without nectar, bee with nectar, happy bee, happy bee with nectar, happy bee without nectar, angry bee, angry bee without nectar, angry bee with nectar) , (bee)) + compareData((baby bee, baby bee without nectar, baby bee with nectar, baby happy bee, baby happy bee with nectar, baby happy bee without nectar, baby angry bee, baby angry bee without nectar, baby angry bee with nectar) , (bee, baby bee)) + compareData((adult bee, adult bee without nectar, adult bee with nectar, adult happy bee, adult happy bee with nectar, adult happy bee without nectar, adult angry bee, adult angry bee without nectar, adult angry bee with nectar) , (bee, adult bee)) + compareData((bee with nectar, angry bee with nectar, happy bee with nectar), (bee with nectar)) + compareData((bee without nectar, angry bee without nectar, happy bee without nectar), (bee without nectar)) + compareData((happy bee, happy bee with nectar, happy bee without nectar), (happy bee)) + compareData((angry bee, angry bee with nectar, angry bee without nectar) , (angry bee)) + +test "boat chest data": + compareData((chest boat, oak chest boat, spruce chest boat, birch chest boat, jungle chest boat, acacia chest boat, dark oak chest boat, cherry chest boat, mangrove chest boat, bamboo chest boat, pale oak chest boat), (any chest boat)) + +test "boat data": + compareData((boat, oak boat, spruce boat, birch boat, jungle boat, acacia boat, dark oak boat, cherry boat, mangrove boat, bamboo boat, pale oak boat), (any boat)) + +test "cat data": + compareData((cat, tabby cat, black cat, red cat, siamese cat, british shorthair cat, calico cat, persian cat, ragdoll cat, white cat, jellie cat, all black cat) , (cat)) + compareData((baby cat, baby tabby cat, baby black cat, baby red cat, baby siamese cat, baby british shorthair cat, baby calico cat, baby persian cat, baby ragdoll cat, baby white cat, baby jellie cat, baby all black cat) , (cat, baby cat)) + compareData((adult cat, adult tabby cat, adult black cat, adult red cat, adult siamese cat, adult british shorthair cat, adult calico cat, adult persian cat, adult ragdoll cat, adult white cat, adult jellie cat, adult all black cat) , (cat, adult cat)) + compareData((tamed ocelot, tamed baby ocelot, tamed adult ocelot) , (cat)) + compareData((tamed baby ocelot) , (cat, baby cat)) + compareData((tamed adult ocelot) , (cat, adult cat)) + compareData((kitten, tabby kitten, black kitten, red kitten, siamese kitten, british shorthair kitten, calico kitten, persian kitten, ragdoll kitten, white kitten, jellie kitten, all black kitten) , (cat, kitten, baby cat)) + +test "chicken data": + compareData((chicken, baby chicken, adult chicken, chick) , (chicken)) + parse if running minecraft "1.21.6": + compareData((chicken, warm chicken, temperate chicken, cold chicken) , (chicken)) + compareData((baby chicken, baby warm chicken, baby temperate chicken, baby cold chicken) , (chicken, baby chicken)) + compareData((adult chicken, adult warm chicken, adult temperate chicken, adult cold chicken) , (chicken, adult chicken)) + compareData((chick, warm chick, temperate chick, cold chick) , (chicken, chick, baby chicken)) + +test "cow data": + compareData((cow, baby cow, adult cow, calf) , (cow)) + parse if running minecraft "1.21.6": + compareData((cow, warm cow, temperate cow, cold cow) , (cow)) + compareData((baby cow, baby warm cow, baby temperate cow, baby cold cow) , (cow, baby cow)) + compareData((adult cow, adult warm cow, adult temperate cow, adult cold cow) , (cow, adult cow)) + compareData((calf, warm calf, temperate calf, cold calf) , (cow, calf, baby cow)) + +test "creeper data": + compareData((creeper, powered creeper, unpowered creeper) , (creeper)) + +test "dropped item data": + compareData((dropped item, dropped item entity, dropped stone) , (dropped item, dropped item entity)) + +test "enderman data": + compareData((enderman, enderman holding stone) , (enderman)) + +test "falling block data": + compareData((falling block, falling sand) , (falling block)) + +test "fox data": + compareData((fox, red fox, snow fox) , (fox)) + compareData((baby fox, baby red fox, baby snow fox) , (fox, baby fox)) + compareData((adult fox, adult red fox, adult snow fox) , (fox, adult fox)) + compareData((fox kid, red fox kid, snow fox kid) , (fox, fox kid, baby fox)) + +test "frog data": + compareData((frog, warm frog, temperate frog, cold frog) , (frog)) + compareData((baby frog, baby warm frog, baby temperate frog, baby cold frog) , (frog, baby frog)) + compareData((adult frog, adult warm frog, adult temperate frog, adult cold frog) , (frog, adult frog)) + compareData((frog kid, warm frog kid, temperate frog kid, cold frog kid) , (frog, frog kid, baby frog)) + +test "goat data": + compareData((goat, screaming goat, quiet goat) , (goat)) + compareData((baby goat, baby screaming goat, baby quiet goat) , (goat, baby goat)) + compareData((adult goat, adult screaming goat, adult quiet goat) , (goat, adult goat)) + compareData((goat kid, screaming goat kid, quiet goat kid) , (goat, goat kid, baby goat)) + +test "llama data": + compareData((llama, creamy llama, white llama, brown llama, gray llama, trader llama, creamy trader llama, white trader llama, brown trader llama, gray trader llama) , (llama)) + compareData((baby llama, baby creamy llama, baby white llama, baby brown llama, baby gray llama, baby trader llama, baby creamy trader llama, baby white trader llama, baby brown trader llama, baby gray trader llama) , (llama, baby llama)) + compareData((adult llama, adult creamy llama, adult white llama, adult brown llama, adult gray llama, adult trader llama, adult creamy trader llama, adult white trader llama, adult brown trader llama, adult gray trader llama) , (llama, adult llama)) + compareData((llama cria, creamy llama cria, white llama cria, brown llama cria, gray llama cria, trader llama cria, creamy trader llama cria, white trader llama cria, brown trader llama cria, gray trader llama cria) , (llama, llama cria, baby llama)) + + compareData((trader llama, creamy trader llama, white trader llama, brown trader llama, gray trader llama) , (trader llama)) + compareData((baby trader llama, baby creamy trader llama, baby white trader llama, baby brown trader llama, baby gray trader llama) , (trader llama, baby trader llama)) + compareData((adult trader llama, adult creamy trader llama, adult white trader llama, adult brown trader llama, adult gray trader llama) , (trader llama, adult trader llama)) + compareData((trader llama cria, creamy trader llama cria, white trader llama cria, brown trader llama cria, gray trader llama cria) , (trader llama, trader llama cria, baby trader llama)) + + compareData((creamy llama, baby creamy llama, creamy llama cria, creamy trader llama, baby creamy trader llama, creamy trader llama cria) , (creamy llama)) + compareData((white llama, baby white llama, white llama cria, white trader llama, baby white trader llama, white trader llama cria) , (white llama)) + compareData((brown llama, baby brown llama, brown llama cria, brown trader llama, baby brown trader llama, brown trader llama cria) , (brown llama)) + compareData((gray llama, baby gray llama, gray llama cria, gray trader llama, baby gray trader llama, gray trader llama cria) , (gray llama)) + +test "minecart data": + compareData((minecart, regular minecart, minecart with chest, minecart with furnace, minecart with hopper, minecart with tnt, minecart with spawner, minecart with command block) , (minecart)) + +test "mooshroom data": + compareData((mooshroom, red mooshroom, brown mooshroom) , (mooshroom)) + compareData((baby mooshroom, baby red mooshroom, baby brown mooshroom) , (mooshroom, baby mooshroom)) + compareData((adult mooshroom, adult red mooshroom, adult brown mooshroom) , (mooshroom, adult mooshroom)) + compareData((mooshroom calf, red mooshroom calf, brown mooshroom calf) , (mooshroom, mooshroom calf, baby mooshroom)) + compareData((mooshroom kid, red mooshroom kid, brown mooshroom kid) , (mooshroom, mooshroom calf, baby mooshroom, mooshroom kid)) + +test "panda data": + compareData((panda, normal panda, lazy panda, worried panda, playful panda, brown panda, weak panda, aggressive panda) , (panda)) + compareData((normal-normal panda, normal-lazy panda, normal-worried panda, normal-playful panda, normal-brown panda, normal-weak panda, normal-aggressive panda) , (panda, normal panda)) + compareData((lazy-normal panda, lazy-lazy panda, lazy-worried panda, lazy-playful panda, lazy-brown panda, lazy-weak panda, lazy-aggressive panda) , (panda, lazy panda)) + compareData((worried-normal panda, worried-lazy panda, worried-worried panda, worried-playful panda, worried-brown panda, worried-weak panda, worried-aggressive panda) , (panda, worried panda)) + compareData((playful-normal panda, playful-lazy panda, playful-worried panda, playful-playful panda, playful-brown panda, playful-weak panda, playful-aggressive panda) , (panda, playful panda)) + compareData((brown-normal panda, brown-lazy panda, brown-worried panda, brown-playful panda, brown-brown panda, brown-weak panda, brown-aggressive panda) , (panda, brown panda)) + compareData((weak-normal panda, weak-lazy panda, weak-worried panda, weak-playful panda, weak-brown panda, weak-weak panda, weak-aggressive panda) , (panda, weak panda)) + compareData((aggressive-normal panda, aggressive-lazy panda, aggressive-worried panda, aggressive-playful panda, aggressive-brown panda, aggressive-weak panda, aggressive-aggressive panda) , (panda, aggressive panda)) + + compareData((baby panda, baby normal panda, baby lazy panda, baby worried panda, baby playful panda, baby brown panda, baby weak panda, baby aggressive panda) , (panda, baby panda)) + compareData((baby normal-normal panda, baby normal-lazy panda, baby normal-worried panda, baby normal-playful panda, baby normal-brown panda, baby normal-weak panda, baby normal-aggressive panda) , (panda, normal panda, baby panda, baby normal panda)) + compareData((baby lazy-normal panda, baby lazy-lazy panda, baby lazy-worried panda, baby lazy-playful panda, baby lazy-brown panda, baby lazy-weak panda, baby lazy-aggressive panda) , (panda, lazy panda, baby panda, baby lazy panda)) + compareData((baby worried-normal panda, baby worried-lazy panda, baby worried-worried panda, baby worried-playful panda, baby worried-brown panda, baby worried-weak panda, baby worried-aggressive panda) , (panda, worried panda, baby panda, baby worried panda)) + compareData((baby playful-normal panda, baby playful-lazy panda, baby playful-worried panda, baby playful-playful panda, baby playful-brown panda, baby playful-weak panda, baby playful-aggressive panda) , (panda, playful panda, baby panda, baby playful panda)) + compareData((baby brown-normal panda, baby brown-lazy panda, baby brown-worried panda, baby brown-playful panda, baby brown-brown panda, baby brown-weak panda, baby brown-aggressive panda) , (panda, brown panda, baby panda, baby brown panda)) + compareData((baby weak-normal panda, baby weak-lazy panda, baby weak-worried panda, baby weak-playful panda, baby weak-brown panda, baby weak-weak panda, baby weak-aggressive panda) , (panda, weak panda, baby panda, baby weak panda)) + compareData((baby aggressive-normal panda, baby aggressive-lazy panda, baby aggressive-worried panda, baby aggressive-playful panda, baby aggressive-brown panda, baby aggressive-weak panda, baby aggressive-aggressive panda) , (panda, aggressive panda, baby panda, baby aggressive panda)) + + compareData((adult panda, adult normal panda, adult lazy panda, adult worried panda, adult playful panda, adult brown panda, adult weak panda, adult aggressive panda) , (panda, adult panda)) + compareData((adult normal-normal panda, adult normal-lazy panda, adult normal-worried panda, adult normal-playful panda, adult normal-brown panda, adult normal-weak panda, adult normal-aggressive panda) , (panda, normal panda, adult panda, adult normal panda)) + compareData((adult lazy-normal panda, adult lazy-lazy panda, adult lazy-worried panda, adult lazy-playful panda, adult lazy-brown panda, adult lazy-weak panda, adult lazy-aggressive panda) , (panda, lazy panda, adult panda, adult lazy panda)) + compareData((adult worried-normal panda, adult worried-lazy panda, adult worried-worried panda, adult worried-playful panda, adult worried-brown panda, adult worried-weak panda, adult worried-aggressive panda) , (panda, worried panda, adult panda, adult worried panda)) + compareData((adult playful-normal panda, adult playful-lazy panda, adult playful-worried panda, adult playful-playful panda, adult playful-brown panda, adult playful-weak panda, adult playful-aggressive panda) , (panda, playful panda, adult panda, adult playful panda)) + compareData((adult brown-normal panda, adult brown-lazy panda, adult brown-worried panda, adult brown-playful panda, adult brown-brown panda, adult brown-weak panda, adult brown-aggressive panda) , (panda, brown panda, adult panda, adult brown panda)) + compareData((adult weak-normal panda, adult weak-lazy panda, adult weak-worried panda, adult weak-playful panda, adult weak-brown panda, adult weak-weak panda, adult weak-aggressive panda) , (panda, weak panda, adult panda, adult weak panda)) + compareData((adult aggressive-normal panda, adult aggressive-lazy panda, adult aggressive-worried panda, adult aggressive-playful panda, adult aggressive-brown panda, adult aggressive-weak panda, adult aggressive-aggressive panda) , (panda, aggressive panda, adult panda, adult aggressive panda)) + +test "parrot data": + compareData((parrot, red parrot, blue parrot, green parrot, cyan parrot, gray parrot) , (parrot)) + +test "pig data": + compareData((pig, saddled pig, unsaddled pig) , (pig)) + compareData((baby pig, adult pig), (pig)) + compareData((piglet), (pig, baby pig)) + parse if running minecraft "1.21.5": + compareData((warm pig, warm saddled pig, warm unsaddled pig) , (pig, warm pig)) + compareData((temperate pig, temperate saddled pig, temperate unsaddled pig) , (pig, temperate pig)) + compareData((cold pig, cold saddled pig, cold unsaddled pig) , (pig, cold pig)) + compareData((warm baby pig, temperate baby pig, cold baby pig) , (pig, baby pig)) + compareData((warm adult pig, temperate adult pig, cold adult pig) , (pig, adult pig)) + compareData((warm piglet, temperate piglet, cold piglet) , (pig, piglet, baby pig)) + + compareData((saddled warm pig, saddled temperate pig, saddled cold pig) , (pig, saddled pig)) + compareData((unsaddled warm pig, unsaddled temperate pig, unsaddled cold pig) , (pig, unsaddled pig)) + +test "rabbit data": + compareData((rabbit, white rabbit, black rabbit, black white rabbit, brown rabbit, gold rabbit, salt pepper rabbit, killer rabbit) , (rabbit)) + compareData((baby rabbit, baby white rabbit, baby black rabbit, baby black white rabbit, baby brown rabbit, baby gold rabbit, baby salt pepper rabbit, baby killer rabbit) , (rabbit, baby rabbit)) + compareData((adult rabbit, adult white rabbit, adult black rabbit, adult black white rabbit, adult brown rabbit, adult gold rabbit, adult salt pepper rabbit, adult killer rabbit) , (rabbit, adult rabbit)) + +test "salmon data" when running minecraft "1.21.2": + compareData((salmon, small salmon, medium salmon, large salmon) , (any salmon)) + +test "sheep data": + compareData((sheep, unsheared sheep, sheared sheep) , (sheep)) + compareData((red sheep, red unsheared sheep, red sheared sheep) , (red sheep)) + +test "strider data": + compareData((strider, warm strider, cold strider) , (strider)) + compareData((baby strider, baby warm strider, baby cold strider) , (strider, baby strider)) + +test "thrown potion data": + compareData((thrown potion, thrown speed potion) , (thrown potion)) + +test "tropical fish data": + compareData((tropical fish, kob, sunstreak, snooper, dasher, brinely, spotty, flopper, stripey, glitter, blockfish, betty, clayfish) , (tropical fish)) + compareData((red tropical fish, red kob, red sunstreak, red snooper, red dasher, red brinely, red spotty, red flopper, red stripey, red glitter, red blockfish, red betty, red clayfish) , (tropical fish, red tropical fish)) + compareData((red-blue tropical fish, red-blue kob, red-blue sunstreak, red-blue snooper, red-blue dasher, red-blue brinely, red-blue spotty, red-blue flopper, red-blue stripey, red-blue glitter, red-blue blockfish, red-blue betty, red-blue clayfish) , (tropical fish, red tropical fish, red-blue tropical fish)) + +test "villager data": + compareData((villager, jobless villager, armorer, cartographer, cleric, fisherman, fletcher, leatherworker, mason, shepherd, toolsmith, weaponsmith, farmer, librarian, butcher, nitwit) , (villager)) + compareData((baby villager, baby jobless villager, baby armorer, baby cartographer, baby cleric, baby fisherman, baby fletcher, baby leatherworker, baby mason, baby shepherd, baby toolsmith, baby weaponsmith, baby farmer, baby librarian, baby butcher, baby nitwit) , (villager, baby villager)) + compareData((adult villager, adult jobless villager, adult armorer, adult cartographer, adult cleric, adult fisherman, adult fletcher, adult leatherworker, adult mason, adult shepherd, adult toolsmith, adult weaponsmith, adult farmer, adult librarian, adult butcher, adult nitwit) , (villager, adult villager)) + +test "wolf data": + compareData((wolf, dog, tamed wolf, wild wolf, angry wolf, peaceful wolf) , (wolf)) + compareData((baby wolf, baby dog, tamed baby wolf, pup, wild baby wolf, angry baby wolf, peaceful baby wolf) , (wolf, baby wolf)) + compareData((adult wolf, adult dog, tamed adult wolf, wild adult wolf, angry adult wolf, peaceful adult wolf) , (wolf, adult wolf)) + + compareData((wolf color red, dog color red, tamed wolf color red, wild wolf color red, angry wolf color red, peaceful wolf color red) , (wolf, wolf color red)) + compareData((baby wolf color red, baby dog color red, tamed baby wolf color red, pup color red, wild baby wolf color red, angry baby wolf color red, peaceful baby wolf color red) , (wolf color red, baby wolf color red)) + compareData((adult wolf color red, adult dog color red, tamed adult wolf color red, wild adult wolf color red, angry adult wolf color red, peaceful adult wolf color red) , (wolf color red, adult wolf color red)) + + parse if running minecraft "1.20.6": + compareData((ashen wolf, black wolf, chestnut wolf, pale wolf, rusty wolf, snowy wolf, spotted wolf, striped wolf, woods wolf) , (wolf)) + compareData((baby ashen wolf, baby black wolf, baby chestnut wolf, baby pale wolf, baby rusty wolf, baby snowy wolf, baby spotted wolf, baby striped wolf, baby woods wolf) , (wolf, baby wolf)) + compareData((adult ashen wolf, adult black wolf, adult chestnut wolf, adult pale wolf, adult rusty wolf, adult snowy wolf, adult spotted wolf, adult striped wolf, adult woods wolf) , (wolf, adult wolf)) + + compareData((ashen wolf, ashen dog, tamed ashen wolf, wild ashen wolf, angry ashen wolf, peaceful ashen wolf) , (wolf, ashen wolf)) + compareData((baby ashen wolf, baby ashen dog, tamed baby ashen wolf, ashen pup, wild baby ashen wolf, angry baby ashen wolf, peaceful baby ashen wolf) , (wolf, ashen wolf, baby wolf, baby ashen wolf)) + + compareData((ashen wolf color red, ashen dog color red, tamed ashen wolf color red, wild ashen wolf color red, angry ashen wolf color red, peaceful ashen wolf color red) , (wolf, ashen wolf, wolf color red, ashen wolf color red)) + compareData((baby ashen wolf color red, baby ashen dog color red, tamed baby ashen wolf color red, ashen pup color red, wild baby ashen wolf color red, angry baby ashen wolf color red, peaceful baby ashen wolf color red) , (wolf, ashen wolf, baby wolf, baby ashen wolf, wolf color red, ashen wolf color red, baby wolf color red, baby ashen wolf color red)) + +test "zombie villager data": + compareData((zombie villager, normal zombie villager, zombie farmer, zombie librarian, zombie butcher, zombie nitwit, zombie armorer, zombie cartographer, zombie cleric, zombie fisherman, zombie fletcher, zombie leatherworker, zombie mason, zombie shepherd, zombie toolsmith, zombie weaponsmith) , (zombie villager)) + compareData((baby zombie villager, baby normal zombie villager, baby zombie farmer, baby zombie librarian, baby zombie butcher, baby zombie nitwit, baby zombie armorer, baby zombie cartographer, baby zombie cleric, baby zombie fisherman, baby zombie fletcher, baby zombie leatherworker, baby zombie mason, baby zombie shepherd, baby zombie toolsmith, baby zombie weaponsmith) , (zombie villager, baby zombie villager)) + compareData((adult zombie villager, adult normal zombie villager, adult zombie farmer, adult zombie librarian, adult zombie butcher, adult zombie nitwit, adult zombie armorer, adult zombie cartographer, adult zombie cleric, adult zombie fisherman, adult zombie fletcher, adult zombie leatherworker, adult zombie mason, adult zombie shepherd, adult zombie toolsmith, adult zombie weaponsmith) , (zombie villager, adult zombie villager)) + +test "display data": + compareData((display, text display, block display, block display entity, block display of stone, stone block display, item display, item display entity, item display of stone, stone item display) , (display, display entity)) + compareData((block display, block display of sand, block display entity of sand, sand block display, sand block display entity) , (block display, block display entity)) + compareData((item display, item display of bedrock, item display entity of bedrock, bedrock item display, bedrock item display entity) , (item display, item display entity)) + +# TODO: simple entity data From 68f0144b1f6abeb29b8520c7a43d638e2d1f1d0f Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 3 Jul 2025 06:08:24 -0400 Subject: [PATCH 11/21] Update EntityData.java --- .../ch/njol/skript/entity/EntityData.java | 27 ++----------------- 1 file changed, 2 insertions(+), 25 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 84ca05a609e..bffaabc7687 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -117,29 +117,6 @@ protected EntityData deserialize(Fields fields) throws StreamCorruptedException, throw new StreamCorruptedException(); } -// return getInfo((Class>) d.getClass()).codeName + ":" + d.serialize(); - @SuppressWarnings("null") - @Override - @Deprecated(since = "2.3.0", forRemoval = true) - public @Nullable EntityData deserialize(String string) { - String[] split = string.split(":", 2); - if (split.length != 2) - return null; - EntityDataInfo entityDataInfo = getInfo(split[0]); - if (entityDataInfo == null) - return null; - EntityData entityData; - try { - entityData = entityDataInfo.getElementClass().newInstance(); - } catch (Exception e) { - Skript.exception(e, "Can't create an instance of " + entityDataInfo.getElementClass().getCanonicalName()); - return null; - } - if (!entityData.deserialize(split[1])) - return null; - return entityData; - } - @Override public boolean mustSyncDeserialization() { return false; @@ -267,7 +244,7 @@ public String[] getPatterns() { } /** - * Gets the {@code codeName} corresponding to the {@code matchedPattern} in {@link #init(Expression[], int, Kleenean, ParseResult)}. + * Gets the {@code codeName} corresponding to the {@code matchedPattern} in {@link #init(ch.njol.skript.lang.Expression[], int, Kleenean, ParseResult)}. * @param matchedPattern The placement of the pattern used. * @return The corresponding {@code codeName}. */ @@ -285,7 +262,7 @@ public int getCodeNamePlacement(String codeName) { } /** - * Gets the actual matched pattern from {@code matchedPattern} in {@link #init(Expression[], int, Kleenean, ParseResult)}. + * Gets the actual matched pattern from {@code matchedPattern} in {@link #init(ch.njol.skript.lang.Expression[], int, Kleenean, ParseResult)}. * @param matchedPattern The placement of the pattern used * @return The actual placement. */ From dc262e918f211144e17e20db35e14f61ebe694cf Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 3 Jul 2025 06:33:18 -0400 Subject: [PATCH 12/21] Update EntityData.sk --- src/test/skript/tests/misc/EntityData.sk | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index c5563c351f8..ae742d0aa52 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -26,11 +26,15 @@ test "bee data": compareData((happy bee, happy bee with nectar, happy bee without nectar), (happy bee)) compareData((angry bee, angry bee with nectar, angry bee without nectar) , (angry bee)) -test "boat chest data": - compareData((chest boat, oak chest boat, spruce chest boat, birch chest boat, jungle chest boat, acacia chest boat, dark oak chest boat, cherry chest boat, mangrove chest boat, bamboo chest boat, pale oak chest boat), (any chest boat)) +test "boat data": + compareData((chest boat, acacia chest boat, bamboo chest boat, birch chest boat, cherry chest boat, dark oak chest boat, jungle chest boat, mangrove chest boat, oak chest boat, spruce chest boat) , (any boat, any chest boat)) + parse if running minecraft "1.21.2": + compareData((pale oak chest boat), (any boat, any chest boat)) test "boat data": - compareData((boat, oak boat, spruce boat, birch boat, jungle boat, acacia boat, dark oak boat, cherry boat, mangrove boat, bamboo boat, pale oak boat), (any boat)) + compareData((boat, acacia boat, bamboo boat, birch boat, cherry boat, dark oak boat, jungle boat, mangrove boat, oak boat, spruce boat) , (any boat)) + parse if running minecraft "1.21.2": + compareData((pale oak boat), (any boat)) test "cat data": compareData((cat, tabby cat, black cat, red cat, siamese cat, british shorthair cat, calico cat, persian cat, ragdoll cat, white cat, jellie cat, all black cat) , (cat)) From 8c2566d3f9eedb72b260a252fe3595891d337d96 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 3 Jul 2025 06:51:35 -0400 Subject: [PATCH 13/21] Fix test --- src/main/java/ch/njol/skript/entity/EntityData.java | 7 ++++++- src/test/skript/tests/misc/EntityData.sk | 4 ++-- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index bffaabc7687..991c64e76c0 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -451,7 +451,12 @@ protected Noun getName() { } protected @Nullable Adjective getAgeAdjective() { - return baby.isTrue() ? m_baby : baby.isFalse() ? m_adult : null; + if (baby.isTrue()) { + return m_baby; + } else if (baby.isFalse()) { + return m_adult; + } + return null; } @SuppressWarnings("null") diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index ae742d0aa52..03d98cf66a5 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -27,9 +27,9 @@ test "bee data": compareData((angry bee, angry bee with nectar, angry bee without nectar) , (angry bee)) test "boat data": - compareData((chest boat, acacia chest boat, bamboo chest boat, birch chest boat, cherry chest boat, dark oak chest boat, jungle chest boat, mangrove chest boat, oak chest boat, spruce chest boat) , (any boat, any chest boat)) + compareData((chest boat, acacia chest boat, bamboo chest boat, birch chest boat, cherry chest boat, dark oak chest boat, jungle chest boat, mangrove chest boat, oak chest boat, spruce chest boat) , (any chest boat)) parse if running minecraft "1.21.2": - compareData((pale oak chest boat), (any boat, any chest boat)) + compareData((pale oak chest boat), (any chest boat)) test "boat data": compareData((boat, acacia boat, bamboo boat, birch boat, cherry boat, dark oak boat, jungle boat, mangrove boat, oak boat, spruce boat) , (any boat)) From 0a947fc4d18713d8c08fec7b3c26171989fb2eff Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Thu, 3 Jul 2025 07:19:44 -0400 Subject: [PATCH 14/21] Kleenean Changes --- .../java/ch/njol/skript/entity/BeeData.java | 10 ++--- .../ch/njol/skript/entity/CreeperData.java | 4 +- .../njol/skript/entity/DroppedItemData.java | 11 +++--- .../ch/njol/skript/entity/EndermanData.java | 5 ++- .../njol/skript/entity/FallingBlockData.java | 4 +- .../java/ch/njol/skript/entity/GoatData.java | 4 +- .../ch/njol/skript/entity/MinecartData.java | 38 +++++++++---------- .../java/ch/njol/skript/entity/PigData.java | 4 +- .../java/ch/njol/skript/entity/SheepData.java | 4 +- .../ch/njol/skript/entity/StriderData.java | 4 +- .../njol/skript/entity/ThrownPotionData.java | 2 +- .../ch/njol/skript/entity/VillagerData.java | 2 +- .../java/ch/njol/skript/entity/WolfData.java | 17 +++++---- 13 files changed, 56 insertions(+), 53 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/BeeData.java b/src/main/java/ch/njol/skript/entity/BeeData.java index 834845d0e38..613c0f9104b 100644 --- a/src/main/java/ch/njol/skript/entity/BeeData.java +++ b/src/main/java/ch/njol/skript/entity/BeeData.java @@ -92,7 +92,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @Override protected boolean init(@Nullable Class entityClass, @Nullable Bee bee) { if (bee != null) { - isAngry = bee.getAnger() > 0 ? Kleenean.TRUE : Kleenean.FALSE; + isAngry = Kleenean.get(bee.getAnger() > 0); hasNectar = Kleenean.get(bee.hasNectar()); super.dataCodeName = PATTERNS.getMatchedPatterns(BeeState.getBeeState(isAngry, hasNectar))[0]; } @@ -108,9 +108,9 @@ public void set(Bee bee) { @Override protected boolean match(Bee bee) { - if (isAngry != Kleenean.UNKNOWN && isAngry != (bee.getAnger() > 0 ? Kleenean.TRUE : Kleenean.FALSE)) + if (!isAngry.isUnknown() && isAngry != Kleenean.get(bee.getAnger() > 0)) return false; - return hasNectar == Kleenean.UNKNOWN || hasNectar == Kleenean.get(bee.hasNectar()); + return hasNectar.isUnknown() || hasNectar == Kleenean.get(bee.hasNectar()); } @Override @@ -143,9 +143,9 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof BeeData other)) return false; - if (isAngry != Kleenean.UNKNOWN && isAngry != other.isAngry) + if (!isAngry.isUnknown() && isAngry != other.isAngry) return false; - return hasNectar == Kleenean.UNKNOWN || hasNectar == other.hasNectar; + return hasNectar.isUnknown() || hasNectar == other.hasNectar; } } diff --git a/src/main/java/ch/njol/skript/entity/CreeperData.java b/src/main/java/ch/njol/skript/entity/CreeperData.java index 9ed79254c97..69ab4cc6731 100644 --- a/src/main/java/ch/njol/skript/entity/CreeperData.java +++ b/src/main/java/ch/njol/skript/entity/CreeperData.java @@ -53,7 +53,7 @@ public void set(Creeper creeper) { @Override public boolean match(Creeper creeper) { - return powered == Kleenean.UNKNOWN || powered == Kleenean.get(creeper.isPowered()); + return powered.isUnknown() || powered == Kleenean.get(creeper.isPowered()); } @Override @@ -82,7 +82,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof CreeperData other)) return false; - return powered == Kleenean.UNKNOWN || powered == other.powered; + return powered.isUnknown() || powered == other.powered; } } diff --git a/src/main/java/ch/njol/skript/entity/DroppedItemData.java b/src/main/java/ch/njol/skript/entity/DroppedItemData.java index 5a0fd8f85e5..f83fc834a3c 100644 --- a/src/main/java/ch/njol/skript/entity/DroppedItemData.java +++ b/src/main/java/ch/njol/skript/entity/DroppedItemData.java @@ -47,7 +47,8 @@ public DroppedItemData(ItemType @Nullable [] types) { @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (exprs.length > 0 && exprs[0] != null) { - types = (ItemType[]) exprs[0].getAll(); + //noinspection unchecked + types = ((Literal) exprs[0]).getAll(); for (ItemType type : types) { if (!type.getMaterial().isItem()) { Skript.error("'" + type + "' cannot represent a dropped item"); @@ -70,8 +71,8 @@ protected boolean init(@Nullable Class entityClass, @Nullable It @Override protected boolean match(Item item) { if (types != null) { - for (ItemType t : types) { - if (t.isOfType(item.getItemStack())) + for (ItemType itemType : types) { + if (itemType.isOfType(item.getItemStack())) return true; } return false; @@ -107,9 +108,9 @@ protected int hashCode_i() { @Override protected boolean equals_i(EntityData entityData) { - if (!(entityData instanceof DroppedItemData)) + if (!(entityData instanceof DroppedItemData other)) return false; - return Arrays.equals(types, ((DroppedItemData) entityData).types); + return Arrays.equals(types, other.types); } @Override diff --git a/src/main/java/ch/njol/skript/entity/EndermanData.java b/src/main/java/ch/njol/skript/entity/EndermanData.java index e6a24c6c92e..71efc0de694 100644 --- a/src/main/java/ch/njol/skript/entity/EndermanData.java +++ b/src/main/java/ch/njol/skript/entity/EndermanData.java @@ -32,11 +32,12 @@ public EndermanData(ItemType @Nullable [] hand) { this.hand = hand; } - @SuppressWarnings("unchecked") @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - if (exprs[0] != null) + if (exprs[0] != null) { + //noinspection unchecked hand = ((Literal) exprs[0]).getAll(); + } return true; } diff --git a/src/main/java/ch/njol/skript/entity/FallingBlockData.java b/src/main/java/ch/njol/skript/entity/FallingBlockData.java index 4ea7407c6e9..989d7cba51c 100644 --- a/src/main/java/ch/njol/skript/entity/FallingBlockData.java +++ b/src/main/java/ch/njol/skript/entity/FallingBlockData.java @@ -38,12 +38,12 @@ public FallingBlockData() {} public FallingBlockData(ItemType @Nullable [] types) { this.types = types; } - - @SuppressWarnings("unchecked") + @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { if (matchedPattern == 1) { assert exprs[0] != null; + //noinspection unchecked ItemType[] itemTypes = ((Literal) exprs[0]).getAll(); types = Converters.convert(itemTypes, ItemType.class, itemType -> { ItemType clone = itemType.getBlock().clone(); diff --git a/src/main/java/ch/njol/skript/entity/GoatData.java b/src/main/java/ch/njol/skript/entity/GoatData.java index b2c84ce7472..14e8755c4be 100644 --- a/src/main/java/ch/njol/skript/entity/GoatData.java +++ b/src/main/java/ch/njol/skript/entity/GoatData.java @@ -51,7 +51,7 @@ public void set(Goat goat) { @Override protected boolean match(Goat goat) { - return screaming == Kleenean.UNKNOWN || screaming == Kleenean.get(goat.isScreaming()); + return screaming.isUnknown() || screaming == Kleenean.get(goat.isScreaming()); } @Override @@ -80,7 +80,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof GoatData other)) return false; - return screaming == Kleenean.UNKNOWN || screaming == other.screaming; + return screaming.isUnknown() || screaming == other.screaming; } } diff --git a/src/main/java/ch/njol/skript/entity/MinecartData.java b/src/main/java/ch/njol/skript/entity/MinecartData.java index aea284c53eb..82564d286ef 100644 --- a/src/main/java/ch/njol/skript/entity/MinecartData.java +++ b/src/main/java/ch/njol/skript/entity/MinecartData.java @@ -18,8 +18,7 @@ import java.util.ArrayList; public class MinecartData extends EntityData { - - @SuppressWarnings("null") + private static enum MinecartType { ANY(Minecart.class, "minecart"), NORMAL(RideableMinecart.class, "regular minecart"), @@ -29,13 +28,12 @@ private static enum MinecartType { EXPLOSIVE(ExplosiveMinecart.class, "explosive minecart"), SPAWNER(SpawnerMinecart.class, "spawner minecart"), COMMAND(CommandMinecart.class, "command minecart"); - - @Nullable - final Class c; + + final @Nullable Class entityClass; private final String codeName; - MinecartType(final @Nullable Class c, final String codeName) { - this.c = c; + MinecartType(@Nullable Class entityClass, final String codeName) { + this.entityClass = entityClass; this.codeName = codeName; } @@ -48,12 +46,14 @@ public String toString() { static { final ArrayList cn = new ArrayList<>(); for (final MinecartType t : values()) { - if (t.c != null) + if (t.entityClass != null) cn.add(t.codeName); } codeNames = cn.toArray(new String[0]); } } + + private static final MinecartType[] TYPES = MinecartType.values(); static { EntityData.register(MinecartData.class, "minecart", Minecart.class, 0, MinecartType.codeNames); @@ -72,20 +72,18 @@ public MinecartData(MinecartType type) { @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - type = MinecartType.values()[matchedCodeName]; + type = TYPES[matchedCodeName]; return true; } - - @SuppressWarnings("null") + @Override protected boolean init(@Nullable Class entityClass, @Nullable Minecart minecart) { - final MinecartType[] ts = MinecartType.values(); - for (int i = ts.length - 1; i >= 0; i--) { - final Class mc = ts[i].c; - if (mc == null) + for (int i = TYPES.length - 1; i >= 0; i--) { + Class typeClass = TYPES[i].entityClass; + if (typeClass == null) continue; - if (minecart == null ? mc.isAssignableFrom(entityClass) : mc.isInstance(minecart)) { - type = ts[i]; + if (minecart == null ? typeClass.isAssignableFrom(entityClass) : typeClass.isInstance(minecart)) { + type = TYPES[i]; return true; } } @@ -98,15 +96,15 @@ public void set(Minecart minecart) {} @Override public boolean match(Minecart minecart) { - if (type == MinecartType.NORMAL && type.c == Minecart.class) // pre-1.5 + if (type == MinecartType.NORMAL && type.entityClass == Minecart.class) // pre-1.5 return !(minecart.getClass().equals(Utils.classForName("org.bukkit.entity.StorageMinecart")) || minecart.getClass().equals(Utils.classForName("org.bukkit.entity.PoweredMinecart"))); - return type.c != null && type.c.isInstance(minecart); + return type.entityClass != null && type.entityClass.isInstance(minecart); } @Override public Class getType() { - return type.c != null ? type.c : Minecart.class; + return type.entityClass != null ? type.entityClass : Minecart.class; } @Override diff --git a/src/main/java/ch/njol/skript/entity/PigData.java b/src/main/java/ch/njol/skript/entity/PigData.java index 6e6c2d0e7a3..9127da961d7 100644 --- a/src/main/java/ch/njol/skript/entity/PigData.java +++ b/src/main/java/ch/njol/skript/entity/PigData.java @@ -79,7 +79,7 @@ public void set(Pig pig) { @Override protected boolean match(Pig pig) { - if (saddled != Kleenean.UNKNOWN && saddled != Kleenean.get(pig.hasSaddle())) + if (!saddled.isUnknown() && saddled != Kleenean.get(pig.hasSaddle())) return false; return variant == null || variant == pig.getVariant(); } @@ -112,7 +112,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof PigData other)) return false; - if (saddled != Kleenean.UNKNOWN && saddled != other.saddled) + if (!saddled.isUnknown() && saddled != other.saddled) return false; return variant == null || variant == other.variant; } diff --git a/src/main/java/ch/njol/skript/entity/SheepData.java b/src/main/java/ch/njol/skript/entity/SheepData.java index 0bc81af8c15..3f233906b48 100644 --- a/src/main/java/ch/njol/skript/entity/SheepData.java +++ b/src/main/java/ch/njol/skript/entity/SheepData.java @@ -72,7 +72,7 @@ public void set(Sheep sheep) { @Override public boolean match(Sheep sheep) { - if (sheared != Kleenean.UNKNOWN && sheared != Kleenean.get(sheep.isSheared())) + if (!sheared.isUnknown() && sheared != Kleenean.get(sheep.isSheared())) return false; return colors == null || SimpleExpression.check(colors, c -> sheep.getColor() == c.asDyeColor(), false, false); } @@ -109,7 +109,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof SheepData other)) return false; - if (sheared != Kleenean.UNKNOWN && sheared != other.sheared) + if (!sheared.isUnknown() && sheared != other.sheared) return false; return colors == null || CollectionUtils.isSubset(colors, other.colors); } diff --git a/src/main/java/ch/njol/skript/entity/StriderData.java b/src/main/java/ch/njol/skript/entity/StriderData.java index 2c326cf31e6..0c954adadf4 100644 --- a/src/main/java/ch/njol/skript/entity/StriderData.java +++ b/src/main/java/ch/njol/skript/entity/StriderData.java @@ -52,7 +52,7 @@ public void set(Strider entity) { @Override protected boolean match(Strider strider) { - return shivering == Kleenean.UNKNOWN || shivering == Kleenean.get(strider.isShivering()); + return shivering.isUnknown() || shivering == Kleenean.get(strider.isShivering()); } @Override @@ -81,7 +81,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof StriderData other)) return false; - return shivering == Kleenean.UNKNOWN || shivering == other.shivering; + return shivering.isUnknown() || shivering == other.shivering; } } diff --git a/src/main/java/ch/njol/skript/entity/ThrownPotionData.java b/src/main/java/ch/njol/skript/entity/ThrownPotionData.java index edce6349def..c604776998a 100644 --- a/src/main/java/ch/njol/skript/entity/ThrownPotionData.java +++ b/src/main/java/ch/njol/skript/entity/ThrownPotionData.java @@ -132,7 +132,6 @@ public boolean isSupertypeOf(EntityData entityData) { } @Override - @SuppressWarnings({"unchecked", "rawtypes"}) public @Nullable ThrownPotion spawn(Location location, @Nullable Consumer consumer) { ItemType itemType = CollectionUtils.getRandom(types); assert itemType != null; @@ -140,6 +139,7 @@ public boolean isSupertypeOf(EntityData entityData) { if (itemStack == null) return null; + // noinspection unchecked,rawtypes Class thrownPotionClass = (Class) (itemStack.getType() == LINGER_POTION ? LINGERING_POTION_ENTITY_CLASS : ThrownPotion.class); ThrownPotion potion; if (consumer != null) { diff --git a/src/main/java/ch/njol/skript/entity/VillagerData.java b/src/main/java/ch/njol/skript/entity/VillagerData.java index 85e353eaa5c..c73d2a0b671 100644 --- a/src/main/java/ch/njol/skript/entity/VillagerData.java +++ b/src/main/java/ch/njol/skript/entity/VillagerData.java @@ -86,7 +86,7 @@ public void set(Villager villager) { @Override protected boolean match(Villager villager) { - return profession == null || villager.getProfession() == profession; + return profession == null || profession == villager.getProfession(); } @Override diff --git a/src/main/java/ch/njol/skript/entity/WolfData.java b/src/main/java/ch/njol/skript/entity/WolfData.java index 1c9e14c6724..e8dcd62e6ac 100644 --- a/src/main/java/ch/njol/skript/entity/WolfData.java +++ b/src/main/java/ch/njol/skript/entity/WolfData.java @@ -89,17 +89,20 @@ public WolfData(@Nullable WolfState wolfState) { } } - @SuppressWarnings("unchecked") @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { WolfState state = PATTERNS.getInfo(matchedCodeName); assert state != null; isAngry = state.angry; isTamed = state.tamed; - if (exprs[0] != null && VARIANTS_ENABLED) + if (exprs[0] != null && VARIANTS_ENABLED) { + //noinspection unchecked variant = ((Literal) exprs[0]).getSingle(); - if (exprs[1] != null) + } + if (exprs[1] != null) { + //noinspection unchecked collarColor = ((Literal) exprs[1]).getSingle().asDyeColor(); + } return true; } @@ -131,9 +134,9 @@ public void set(Wolf wolf) { @Override public boolean match(Wolf wolf) { - if (isAngry != Kleenean.UNKNOWN && isAngry != Kleenean.get(wolf.isAngry())) + if (!isAngry.isUnknown() && isAngry != Kleenean.get(wolf.isAngry())) return false; - if (isTamed != Kleenean.UNKNOWN && isTamed != Kleenean.get(wolf.isTamed())) + if (!isTamed.isUnknown() && isTamed != Kleenean.get(wolf.isTamed())) return false; if (collarColor != null && collarColor != wolf.getCollarColor()) return false; @@ -178,9 +181,9 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof WolfData other)) return false; - if (isAngry != Kleenean.UNKNOWN && isAngry != other.isAngry) + if (!isAngry.isUnknown() && isAngry != other.isAngry) return false; - if (isTamed != Kleenean.UNKNOWN && isTamed != other.isTamed) + if (!isTamed.isUnknown() && isTamed != other.isTamed) return false; if (collarColor != null && collarColor != other.collarColor) return false; From 3d4279e54764b3817480d9ad328161c75b7ee046 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Fri, 4 Jul 2025 05:03:19 -0400 Subject: [PATCH 15/21] Update EntityData.sk --- src/test/skript/tests/misc/EntityData.sk | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index 03d98cf66a5..45502b9167d 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -4,7 +4,7 @@ local function compareData(data1: entity types, data2: entity types): if loop-value is spawnable: spawn (loop-value) at test-location: set {_entity} to event-entity - assert {_entity} is loop-value with "Spawned '%{_entity}%' should match against own EntityData '%loop-value%'" + assert {_entity} is loop-value with "Spawned '%loop-value%' should match against own EntityData '%loop-value%'" loop {_data2::*}: assert loop-value-1 is loop-value-2 with "EntityData '%loop-value-1%' should match against EntityData '%loop-value-2%'" if {_entity} is set: @@ -188,9 +188,9 @@ test "tropical fish data": compareData((red-blue tropical fish, red-blue kob, red-blue sunstreak, red-blue snooper, red-blue dasher, red-blue brinely, red-blue spotty, red-blue flopper, red-blue stripey, red-blue glitter, red-blue blockfish, red-blue betty, red-blue clayfish) , (tropical fish, red tropical fish, red-blue tropical fish)) test "villager data": - compareData((villager, jobless villager, armorer, cartographer, cleric, fisherman, fletcher, leatherworker, mason, shepherd, toolsmith, weaponsmith, farmer, librarian, butcher, nitwit) , (villager)) - compareData((baby villager, baby jobless villager, baby armorer, baby cartographer, baby cleric, baby fisherman, baby fletcher, baby leatherworker, baby mason, baby shepherd, baby toolsmith, baby weaponsmith, baby farmer, baby librarian, baby butcher, baby nitwit) , (villager, baby villager)) - compareData((adult villager, adult jobless villager, adult armorer, adult cartographer, adult cleric, adult fisherman, adult fletcher, adult leatherworker, adult mason, adult shepherd, adult toolsmith, adult weaponsmith, adult farmer, adult librarian, adult butcher, adult nitwit) , (villager, adult villager)) + compareData((villager, jobless villager, armorer, cartographer, cleric, fisherman, fletcher, mason, shepherd, toolsmith, weaponsmith, farmer, librarian, butcher, nitwit) , (villager)) + compareData((baby villager, baby jobless villager, baby armorer, baby cartographer, baby cleric, baby fisherman, baby fletcher, baby mason, baby shepherd, baby toolsmith, baby weaponsmith, baby farmer, baby librarian, baby butcher, baby nitwit) , (villager, baby villager)) + compareData((adult villager, adult jobless villager, adult armorer, adult cartographer, adult cleric, adult fisherman, adult fletcher, adult mason, adult shepherd, adult toolsmith, adult weaponsmith, adult farmer, adult librarian, adult butcher, adult nitwit) , (villager, adult villager)) test "wolf data": compareData((wolf, dog, tamed wolf, wild wolf, angry wolf, peaceful wolf) , (wolf)) @@ -213,9 +213,9 @@ test "wolf data": compareData((baby ashen wolf color red, baby ashen dog color red, tamed baby ashen wolf color red, ashen pup color red, wild baby ashen wolf color red, angry baby ashen wolf color red, peaceful baby ashen wolf color red) , (wolf, ashen wolf, baby wolf, baby ashen wolf, wolf color red, ashen wolf color red, baby wolf color red, baby ashen wolf color red)) test "zombie villager data": - compareData((zombie villager, normal zombie villager, zombie farmer, zombie librarian, zombie butcher, zombie nitwit, zombie armorer, zombie cartographer, zombie cleric, zombie fisherman, zombie fletcher, zombie leatherworker, zombie mason, zombie shepherd, zombie toolsmith, zombie weaponsmith) , (zombie villager)) - compareData((baby zombie villager, baby normal zombie villager, baby zombie farmer, baby zombie librarian, baby zombie butcher, baby zombie nitwit, baby zombie armorer, baby zombie cartographer, baby zombie cleric, baby zombie fisherman, baby zombie fletcher, baby zombie leatherworker, baby zombie mason, baby zombie shepherd, baby zombie toolsmith, baby zombie weaponsmith) , (zombie villager, baby zombie villager)) - compareData((adult zombie villager, adult normal zombie villager, adult zombie farmer, adult zombie librarian, adult zombie butcher, adult zombie nitwit, adult zombie armorer, adult zombie cartographer, adult zombie cleric, adult zombie fisherman, adult zombie fletcher, adult zombie leatherworker, adult zombie mason, adult zombie shepherd, adult zombie toolsmith, adult zombie weaponsmith) , (zombie villager, adult zombie villager)) + compareData((zombie villager, normal zombie villager, zombie farmer, zombie librarian, zombie butcher, zombie nitwit, zombie armorer, zombie cartographer, zombie cleric, zombie fisherman, zombie fletcher, zombie mason, zombie shepherd, zombie toolsmith, zombie weaponsmith) , (zombie villager)) + compareData((baby zombie villager, baby normal zombie villager, baby zombie farmer, baby zombie librarian, baby zombie butcher, baby zombie nitwit, baby zombie armorer, baby zombie cartographer, baby zombie cleric, baby zombie fisherman, baby zombie fletcher, baby zombie mason, baby zombie shepherd, baby zombie toolsmith, baby zombie weaponsmith) , (zombie villager, baby zombie villager)) + compareData((adult zombie villager, adult normal zombie villager, adult zombie farmer, adult zombie librarian, adult zombie butcher, adult zombie nitwit, adult zombie armorer, adult zombie cartographer, adult zombie cleric, adult zombie fisherman, adult zombie fletcher, adult zombie mason, adult zombie shepherd, adult zombie toolsmith, adult zombie weaponsmith) , (zombie villager, adult zombie villager)) test "display data": compareData((display, text display, block display, block display entity, block display of stone, stone block display, item display, item display entity, item display of stone, stone item display) , (display, display entity)) From c4a045a7b4124f073424f38b5b861ce1f03fb88f Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Fri, 4 Jul 2025 08:36:33 -0400 Subject: [PATCH 16/21] Efy's Requested Changes --- .../skript/conditions/CondIsSpawnable.java | 78 ++++++++++++++----- .../ch/njol/skript/doc/Documentation.java | 4 +- .../ch/njol/skript/entity/EntityData.java | 8 +- .../ch/njol/skript/entity/EntityPatterns.java | 29 ++++--- src/main/resources/lang/default.lang | 2 + src/test/skript/tests/misc/EntityData.sk | 2 + 6 files changed, 90 insertions(+), 33 deletions(-) diff --git a/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java b/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java index 51503b9d511..c336763a7ac 100644 --- a/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java +++ b/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java @@ -1,22 +1,26 @@ package ch.njol.skript.conditions; import ch.njol.skript.Skript; -import ch.njol.skript.conditions.base.PropertyCondition; import ch.njol.skript.doc.Description; import ch.njol.skript.doc.Example; import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.entity.EntityData; import ch.njol.skript.entity.EntityType; +import ch.njol.skript.lang.Condition; +import ch.njol.skript.lang.Expression; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.lang.SyntaxStringBuilder; +import ch.njol.skript.lang.util.SimpleExpression; +import ch.njol.util.Kleenean; import org.bukkit.Bukkit; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; +import org.bukkit.World; +import org.bukkit.event.Event; +import org.jetbrains.annotations.Nullable; @Name("Is Spawnable") @Description(""" - Whether an entity type is spawnable. + Whether an entity type can be spawned in a world. If no world is provided, will default to the first world. Any general types such as 'monster, mob, entity, living entity' etc. will never be spawnable. """) @Example(""" @@ -24,30 +28,62 @@ if a monster can be spawned: # false """) @Since("INSERT VERSION") -@SuppressWarnings("rawtypes") -public class CondIsSpawnable extends PropertyCondition { +public class CondIsSpawnable extends Condition { static { - List patterns = new ArrayList<>(Arrays.stream(getPatterns(PropertyType.BE, "spawnable", "entitytypes")).toList()); - patterns.addAll(Arrays.stream(getPatterns(PropertyType.CAN, "be spawned", "entitytypes")).toList()); - Skript.registerCondition(CondIsSpawnable.class, patterns.toArray(String[]::new)); + Skript.registerCondition(CondIsSpawnable.class, ConditionType.COMBINED, + "%entitytypes% is spawnable [in [the [world]] %-world%]", + "%entitytypes% can be spawned [in [the [world]] %-world%]", + "%entitytypes% (isn't|is not) spawnable [in [the [world]] %-world%]", + "%entitytypes% (can't|can not) be spawned [in [the [world]] %-world%]"); } + private Expression types; + private @Nullable Expression world = null; + @Override - public boolean check(Object object) { - if (object instanceof EntityData entityData) { - return entityData.canSpawn(Bukkit.getWorlds().get(0)); - } else if (object instanceof EntityType entityType) { - EntityData entityData = entityType.data; - if (entityData != null) - return entityData.canSpawn(Bukkit.getWorlds().get(0)); + public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { + types = exprs[0]; + if (exprs[1] != null) { + //noinspection unchecked + world = (Expression) exprs[1]; } - return false; + setNegated(matchedPattern >= 2); + return true; + } + + @Override + public boolean check(Event event) { + World world = null; + if (this.world != null) { + world = this.world.getSingle(event); + } + if (world == null) + world = Bukkit.getWorlds().get(0); + + World finalWorld = world; + return SimpleExpression.check(types.getArray(event), object -> { + if (object instanceof EntityData entityData) { + return entityData.canSpawn(finalWorld); + } else if (object instanceof EntityType entityType) { + EntityData entityData = entityType.data; + if (entityData != null) + return entityData.canSpawn(finalWorld); + } + return false; + }, isNegated(), types.getAnd()); } @Override - protected String getPropertyName() { - return "spawnable"; + public String toString(@Nullable Event event, boolean debug) { + SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug); + builder.append(types, "is"); + if (isNegated()) + builder.append("not"); + builder.append("spawnable"); + if (world != null) + builder.append("in", world); + return builder.toString(); } } diff --git a/src/main/java/ch/njol/skript/doc/Documentation.java b/src/main/java/ch/njol/skript/doc/Documentation.java index a8139ee466e..662975f1293 100644 --- a/src/main/java/ch/njol/skript/doc/Documentation.java +++ b/src/main/java/ch/njol/skript/doc/Documentation.java @@ -309,7 +309,7 @@ private static void insertSyntaxElement(final PrintWriter pw, final SyntaxElemen Skript.warning("" + elementClass.getSimpleName() + "'s description or 'since' is invalid"); return; } - final String patterns = cleanPatterns(StringUtils.join(info.patterns, "\n", 0, elementClass == CondCompare.class ? 8 : info.getPatterns().length)); + String patterns = cleanPatterns(StringUtils.join(info.patterns, "\n", 0, elementClass == CondCompare.class ? 8 : info.getPatterns().length)); insertOnDuplicateKeyUpdate(pw, "syntax_elements", "id, name, type, patterns, description, examples, since", "patterns = TRIM(LEADING '\n' FROM CONCAT(patterns, '\n', '" + escapeSQL(patterns) + "'))", @@ -341,7 +341,7 @@ private static void insertEvent(final PrintWriter pw, final SkriptEventInfo i Skript.warning("description or 'since' of " + info.getName() + " (" + info.getElementClass().getSimpleName() + ") is invalid"); return; } - final String patterns = cleanPatterns(info.getName().startsWith("On ") ? "[on] " + StringUtils.join(info.getPatterns(), "\n[on] ") : StringUtils.join(info.patterns, "\n")); + String patterns = cleanPatterns(info.getName().startsWith("On ") ? "[on] " + StringUtils.join(info.getPatterns(), "\n[on] ") : StringUtils.join(info.patterns, "\n")); insertOnDuplicateKeyUpdate(pw, "syntax_elements", "id, name, type, patterns, description, examples, since", "patterns = '" + escapeSQL(patterns) + "'", diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index 991c64e76c0..a9fffaa726f 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -345,7 +345,13 @@ public EntityData() { @Override public final boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { this.plural = parseResult.hasTag("unknown_plural") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("plural")); - this.baby = parseResult.hasTag("unknown_age") ? Kleenean.UNKNOWN : Kleenean.get(parseResult.hasTag("baby")); + if (parseResult.hasTag("baby")) { + this.baby = Kleenean.TRUE; + } else if (parseResult.hasTag("adult")) { + this.baby = Kleenean.FALSE; + } else { + this.baby = Kleenean.UNKNOWN; + } String codeName = info.getCodeNameFromPattern(matchedPattern); int matchedCodeName = info.getCodeNamePlacement(codeName); int patternInCodeName = info.getPatternInCodeName(matchedPattern); diff --git a/src/main/java/ch/njol/skript/entity/EntityPatterns.java b/src/main/java/ch/njol/skript/entity/EntityPatterns.java index 16438a7a2e0..c117f93fd39 100644 --- a/src/main/java/ch/njol/skript/entity/EntityPatterns.java +++ b/src/main/java/ch/njol/skript/entity/EntityPatterns.java @@ -14,15 +14,19 @@ public class EntityPatterns { private final String[] patterns; - private final Object[] ts; + private final Object[] types; private final Map> matchedPatterns = new HashMap<>(); /** - * @param info An array which must be like {{String, T}, {String, T}, ...} + * Creates a new {@link EntityPatterns} with a provided {@link Object[][]} in the form of + * + * {{String, T}, {String, T}, ...} + * {{pattern, correlating object}} + * */ public EntityPatterns(Object[][] info) { patterns = new String[info.length]; - ts = new Object[info.length]; + types = new Object[info.length]; for (int i = 0; i < info.length; i++) { if (info[i].length != 2 || !(info[i][0] instanceof String)) throw new IllegalArgumentException("given array is not like {{String, T}, {String, T}, ...}"); @@ -30,22 +34,28 @@ public EntityPatterns(Object[][] info) { if (object == null) object = EntityPatternNone.NONE; patterns[i] = (String) info[i][0]; - ts[i] = object; + types[i] = object; matchedPatterns.computeIfAbsent(object, list -> new ArrayList<>()).add(i); } } + /** + * Returns an array of the registered patterns. + * @return An {@link java.lang.reflect.Array} of {@link String}s. + */ public String[] getPatterns() { return patterns; } /** + * Returns the typed object {@link T} correlating to {@code matchedPattern}. + * * @param matchedPattern The pattern to get the data to as given in {@link SyntaxElement#init(Expression[], int, Kleenean, ParseResult)} * @return The info associated with the matched pattern * @throws ClassCastException If the item in the source array is not of the requested type */ public @Nullable T getInfo(int matchedPattern) { - Object object = ts[matchedPattern]; + Object object = types[matchedPattern]; if (object == null || object == EntityPatternNone.NONE) return null; //noinspection unchecked @@ -53,12 +63,13 @@ public String[] getPatterns() { } /** - * Gets all pattern indices that correlate to {@code t}. - * @param t The typed object. + * Gets all pattern indices that correlate to {@code type}. + * + * @param type The typed object. * @return An array of pattern indices. */ - public Integer[] getMatchedPatterns(@Nullable T t) { - Object object = t; + public Integer[] getMatchedPatterns(@Nullable T type) { + Object object = type; if (object == null) object = EntityPatternNone.NONE; return matchedPatterns.get(object).toArray(Integer[]::new); diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index b054e7254b1..bd2ef015411 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -473,6 +473,8 @@ directions: # the tag "unknown_plural" is to indicate the pattern is grammatically correct for both singular and plural # without a suffix, such as "sheep" # the tag "baby" is to indicate the pattern is referencing the baby state of an entity +# the tag "adult" is to indicate the pattern is referencing the adult state of an entity +# the tag "unknown_age" is to indicate the pattern is not referencing a specific age state of an entity entities: age pattern: (unknown_age:|baby:(baby|young)|adult:(adult|grown(-| )up)) age adjectives: diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index 45502b9167d..5bdb66a6f30 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -4,12 +4,14 @@ local function compareData(data1: entity types, data2: entity types): if loop-value is spawnable: spawn (loop-value) at test-location: set {_entity} to event-entity + assert {_entity} is set with "Could not spawn '%loop-value%'" assert {_entity} is loop-value with "Spawned '%loop-value%' should match against own EntityData '%loop-value%'" loop {_data2::*}: assert loop-value-1 is loop-value-2 with "EntityData '%loop-value-1%' should match against EntityData '%loop-value-2%'" if {_entity} is set: assert {_entity} is loop-value-2 with "Spawned '%{_entity}%' should match against EntityData '%loop-value-2%'" clear entity within {_entity} + clear {_entity} test "axolotl data": compareData((axolotl, lucy axolotl, wild axolotl, gold axolotl, cyan axolotl, blue axolotl) , (axolotl)) From d6526c4c120f589731083ce1071b6f3413f0c94e Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Fri, 4 Jul 2025 13:06:22 -0400 Subject: [PATCH 17/21] Efy's Requested Changes -2 --- .../ch/njol/skript/entity/ChickenData.java | 2 +- .../ch/njol/skript/entity/MinecartData.java | 87 +++++++++---------- .../java/ch/njol/skript/entity/PigData.java | 2 +- .../ch/njol/skript/entity/SalmonData.java | 2 +- 4 files changed, 42 insertions(+), 51 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/ChickenData.java b/src/main/java/ch/njol/skript/entity/ChickenData.java index d7091378319..ce70dfe77f1 100644 --- a/src/main/java/ch/njol/skript/entity/ChickenData.java +++ b/src/main/java/ch/njol/skript/entity/ChickenData.java @@ -33,7 +33,7 @@ public class ChickenData extends EntityData { public ChickenData() {} - // TODO: When safe, 'variant' should have the type changed to 'Chicken.Variant' + // TODO: When safe, 'variant' should have the type changed to 'Chicken.Variant' when 1.21.6 is minimum supported version public ChickenData(@Nullable Object variant) { this.variant = variant; } diff --git a/src/main/java/ch/njol/skript/entity/MinecartData.java b/src/main/java/ch/njol/skript/entity/MinecartData.java index 82564d286ef..1baf9910fac 100644 --- a/src/main/java/ch/njol/skript/entity/MinecartData.java +++ b/src/main/java/ch/njol/skript/entity/MinecartData.java @@ -2,7 +2,6 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.skript.util.Utils; import ch.njol.skript.variables.Variables; import org.bukkit.entity.Minecart; import org.bukkit.entity.minecart.CommandMinecart; @@ -15,48 +14,39 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.ArrayList; - public class MinecartData extends EntityData { - private static enum MinecartType { - ANY(Minecart.class, "minecart"), - NORMAL(RideableMinecart.class, "regular minecart"), - STORAGE(StorageMinecart.class, "storage minecart"), - POWERED(PoweredMinecart.class, "powered minecart"), - HOPPER(HopperMinecart.class, "hopper minecart"), - EXPLOSIVE(ExplosiveMinecart.class, "explosive minecart"), - SPAWNER(SpawnerMinecart.class, "spawner minecart"), - COMMAND(CommandMinecart.class, "command minecart"); + public enum MinecartType { + ANY(Minecart.class), + NORMAL(RideableMinecart.class), + STORAGE(StorageMinecart.class), + POWERED(PoweredMinecart.class), + HOPPER(HopperMinecart.class), + EXPLOSIVE(ExplosiveMinecart.class), + SPAWNER(SpawnerMinecart.class), + COMMAND(CommandMinecart.class); - final @Nullable Class entityClass; - private final String codeName; + private final Class entityClass; - MinecartType(@Nullable Class entityClass, final String codeName) { + MinecartType(Class entityClass) { this.entityClass = entityClass; - this.codeName = codeName; - } - - @Override - public String toString() { - return codeName; - } - - public static String[] codeNames; - static { - final ArrayList cn = new ArrayList<>(); - for (final MinecartType t : values()) { - if (t.entityClass != null) - cn.add(t.codeName); - } - codeNames = cn.toArray(new String[0]); } } private static final MinecartType[] TYPES = MinecartType.values(); + private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + {"minecart", MinecartType.ANY}, + {"regular minecart", MinecartType.NORMAL}, + {"storage minecart", MinecartType.STORAGE}, + {"powered minecart", MinecartType.POWERED}, + {"hopper minecart", MinecartType.HOPPER}, + {"explosive minecart", MinecartType.EXPLOSIVE}, + {"spawner minecart", MinecartType.SPAWNER}, + {"command minecart", MinecartType.COMMAND} + }); static { - EntityData.register(MinecartData.class, "minecart", Minecart.class, 0, MinecartType.codeNames); + EntityData.register(MinecartData.class, "minecart", Minecart.class, 0, PATTERNS.getPatterns()); Variables.yggdrasil.registerSingleClass(MinecartType.class, "MinecartType"); } @@ -65,30 +55,32 @@ public String toString() { public MinecartData() {} - public MinecartData(MinecartType type) { - this.type = type; - this.dataCodeName = type.ordinal(); + public MinecartData(@Nullable MinecartType type) { + this.type = type != null ? type : MinecartType.ANY; + super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - type = TYPES[matchedCodeName]; + type = PATTERNS.getInfo(matchedCodeName); return true; } @Override protected boolean init(@Nullable Class entityClass, @Nullable Minecart minecart) { - for (int i = TYPES.length - 1; i >= 0; i--) { - Class typeClass = TYPES[i].entityClass; - if (typeClass == null) + for (MinecartType type : TYPES) { + if (type == MinecartType.ANY) continue; + Class typeClass = type.entityClass; if (minecart == null ? typeClass.isAssignableFrom(entityClass) : typeClass.isInstance(minecart)) { - type = TYPES[i]; - return true; + this.type = type; + break; } } - assert false; - return false; + if (this.type == null) + this.type = MinecartType.ANY; + super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + return true; } @Override @@ -96,15 +88,14 @@ public void set(Minecart minecart) {} @Override public boolean match(Minecart minecart) { - if (type == MinecartType.NORMAL && type.entityClass == Minecart.class) // pre-1.5 - return !(minecart.getClass().equals(Utils.classForName("org.bukkit.entity.StorageMinecart")) - || minecart.getClass().equals(Utils.classForName("org.bukkit.entity.PoweredMinecart"))); - return type.entityClass != null && type.entityClass.isInstance(minecart); + if (type == MinecartType.ANY) + return true; + return type.entityClass.isInstance(minecart); } @Override public Class getType() { - return type.entityClass != null ? type.entityClass : Minecart.class; + return type.entityClass; } @Override diff --git a/src/main/java/ch/njol/skript/entity/PigData.java b/src/main/java/ch/njol/skript/entity/PigData.java index 9127da961d7..2271f8c361a 100644 --- a/src/main/java/ch/njol/skript/entity/PigData.java +++ b/src/main/java/ch/njol/skript/entity/PigData.java @@ -39,7 +39,7 @@ public class PigData extends EntityData { public PigData() {} - // TODO: When safe, 'variant' should have the type changed to 'Pig.Variant' + // TODO: When safe, 'variant' should have the type changed to 'Pig.Variant' when 1.21.5 is minimum supported version public PigData(@Nullable Kleenean saddled, @Nullable Object variant) { this.saddled = saddled != null ? saddled : Kleenean.UNKNOWN; this.variant = variant; diff --git a/src/main/java/ch/njol/skript/entity/SalmonData.java b/src/main/java/ch/njol/skript/entity/SalmonData.java index b58af3643d0..5aa1cf88cc6 100644 --- a/src/main/java/ch/njol/skript/entity/SalmonData.java +++ b/src/main/java/ch/njol/skript/entity/SalmonData.java @@ -39,7 +39,7 @@ public class SalmonData extends EntityData { public SalmonData() {} - // TODO: When safe, 'variant' should have the type changed to 'Salmon.Variant' + // TODO: When safe, 'variant' should have the type changed to 'Salmon.Variant' when 1.21.2 is minimum supported version public SalmonData(@Nullable Object variant) { this.variant = variant; super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; From 45721aa403b70ad87acace0447e34687bd366019 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Mon, 7 Jul 2025 11:08:27 -0400 Subject: [PATCH 18/21] Sovdes Requested Changes Move EntityPatterns into Patterns Add getMatchedPattern to Patterns Add kleeneanMatch to EntityData add dataMatch to EntityData --- .../skript/conditions/CondIsSpawnable.java | 28 ++---- .../ch/njol/skript/entity/AxolotlData.java | 11 ++- .../java/ch/njol/skript/entity/BeeData.java | 68 ++++--------- .../ch/njol/skript/entity/BoatChestData.java | 22 ++--- .../java/ch/njol/skript/entity/BoatData.java | 24 ++--- .../java/ch/njol/skript/entity/CatData.java | 4 +- .../ch/njol/skript/entity/ChickenData.java | 2 +- .../java/ch/njol/skript/entity/CowData.java | 2 +- .../ch/njol/skript/entity/CreeperData.java | 16 ++-- .../ch/njol/skript/entity/EntityData.java | 51 ++++++++-- .../ch/njol/skript/entity/EntityPatterns.java | 82 ---------------- .../java/ch/njol/skript/entity/FoxData.java | 11 ++- .../java/ch/njol/skript/entity/FrogData.java | 11 ++- .../java/ch/njol/skript/entity/GoatData.java | 10 +- .../java/ch/njol/skript/entity/LlamaData.java | 51 ++++++---- .../ch/njol/skript/entity/MinecartData.java | 7 +- .../ch/njol/skript/entity/MooshroomData.java | 11 ++- .../java/ch/njol/skript/entity/PandaData.java | 13 ++- .../ch/njol/skript/entity/ParrotData.java | 11 ++- .../java/ch/njol/skript/entity/PigData.java | 11 ++- .../ch/njol/skript/entity/RabbitData.java | 11 ++- .../ch/njol/skript/entity/SalmonData.java | 15 +-- .../java/ch/njol/skript/entity/SheepData.java | 11 ++- .../njol/skript/entity/SimpleEntityData.java | 6 +- .../ch/njol/skript/entity/StriderData.java | 11 ++- .../njol/skript/entity/TropicalFishData.java | 19 ++-- .../ch/njol/skript/entity/VillagerData.java | 11 ++- .../java/ch/njol/skript/entity/WolfData.java | 64 ++++--------- .../skript/entity/ZombieVillagerData.java | 11 ++- .../java/ch/njol/skript/util/Patterns.java | 95 ++++++++++++++++--- .../skript/bukkit/displays/DisplayData.java | 2 +- 31 files changed, 350 insertions(+), 352 deletions(-) delete mode 100644 src/main/java/ch/njol/skript/entity/EntityPatterns.java diff --git a/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java b/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java index c336763a7ac..b08d5765ad2 100644 --- a/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java +++ b/src/main/java/ch/njol/skript/conditions/CondIsSpawnable.java @@ -6,12 +6,10 @@ import ch.njol.skript.doc.Name; import ch.njol.skript.doc.Since; import ch.njol.skript.entity.EntityData; -import ch.njol.skript.entity.EntityType; import ch.njol.skript.lang.Condition; import ch.njol.skript.lang.Expression; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.SyntaxStringBuilder; -import ch.njol.skript.lang.util.SimpleExpression; import ch.njol.util.Kleenean; import org.bukkit.Bukkit; import org.bukkit.World; @@ -32,18 +30,19 @@ public class CondIsSpawnable extends Condition { static { Skript.registerCondition(CondIsSpawnable.class, ConditionType.COMBINED, - "%entitytypes% is spawnable [in [the [world]] %-world%]", - "%entitytypes% can be spawned [in [the [world]] %-world%]", - "%entitytypes% (isn't|is not) spawnable [in [the [world]] %-world%]", - "%entitytypes% (can't|can not) be spawned [in [the [world]] %-world%]"); + "%entitydatas% is spawnable [in [the [world]] %-world%]", + "%entitydatas% can be spawned [in [the [world]] %-world%]", + "%entitydatas% (isn't|is not) spawnable [in [the [world]] %-world%]", + "%entitydatas% (can't|can not) be spawned [in [the [world]] %-world%]"); } - private Expression types; + private Expression> datas; private @Nullable Expression world = null; @Override public boolean init(Expression[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) { - types = exprs[0]; + //noinspection unchecked + datas = (Expression>) exprs[0]; if (exprs[1] != null) { //noinspection unchecked world = (Expression) exprs[1]; @@ -62,22 +61,13 @@ public boolean check(Event event) { world = Bukkit.getWorlds().get(0); World finalWorld = world; - return SimpleExpression.check(types.getArray(event), object -> { - if (object instanceof EntityData entityData) { - return entityData.canSpawn(finalWorld); - } else if (object instanceof EntityType entityType) { - EntityData entityData = entityType.data; - if (entityData != null) - return entityData.canSpawn(finalWorld); - } - return false; - }, isNegated(), types.getAnd()); + return datas.check(event, entityData -> entityData.canSpawn(finalWorld), isNegated()); } @Override public String toString(@Nullable Event event, boolean debug) { SyntaxStringBuilder builder = new SyntaxStringBuilder(event, debug); - builder.append(types, "is"); + builder.append(datas, "is"); if (isNegated()) builder.append("not"); builder.append("spawnable"); diff --git a/src/main/java/ch/njol/skript/entity/AxolotlData.java b/src/main/java/ch/njol/skript/entity/AxolotlData.java index dc5319088e8..6d48e642d4b 100644 --- a/src/main/java/ch/njol/skript/entity/AxolotlData.java +++ b/src/main/java/ch/njol/skript/entity/AxolotlData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Axolotl; import org.bukkit.entity.Axolotl.Variant; @@ -12,7 +13,7 @@ public class AxolotlData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"axolotl", null}, {"lucy axolotl", Variant.LUCY}, {"wild axolotl", Variant.WILD}, @@ -32,7 +33,7 @@ public AxolotlData() {} public AxolotlData(@Nullable Variant variant) { this.variant = variant; - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } @Override @@ -45,7 +46,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Axolotl axolotl) { if (axolotl != null) { variant = axolotl.getVariant(); - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } return true; } @@ -61,7 +62,7 @@ public void set(Axolotl axolotl) { @Override protected boolean match(Axolotl axolotl) { - return variant == null || variant == axolotl.getVariant(); + return dataMatch(variant, axolotl.getVariant()); } @Override @@ -90,7 +91,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof AxolotlData other)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } } diff --git a/src/main/java/ch/njol/skript/entity/BeeData.java b/src/main/java/ch/njol/skript/entity/BeeData.java index 613c0f9104b..c44285029f0 100644 --- a/src/main/java/ch/njol/skript/entity/BeeData.java +++ b/src/main/java/ch/njol/skript/entity/BeeData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.Kleenean; import org.bukkit.entity.Bee; import org.jetbrains.annotations.NotNull; @@ -12,45 +13,18 @@ public class BeeData extends EntityData { - public enum BeeState { - BEE(Kleenean.UNKNOWN, Kleenean.UNKNOWN), - NO_NECTAR(Kleenean.UNKNOWN, Kleenean.FALSE), - NECTAR(Kleenean.UNKNOWN, Kleenean.TRUE), - HAPPY(Kleenean.FALSE, Kleenean.UNKNOWN), - HAPPY_NECTAR(Kleenean.FALSE, Kleenean.TRUE), - HAPPY_NO_NECTAR(Kleenean.FALSE, Kleenean.FALSE), - ANGRY(Kleenean.TRUE, Kleenean.UNKNOWN), - ANGRY_NO_NECTAR(Kleenean.TRUE, Kleenean.FALSE), - ANGRY_NECTAR(Kleenean.TRUE, Kleenean.TRUE); - - private final Kleenean angry; - private final Kleenean nectar; - - BeeState(Kleenean angry, Kleenean nectar) { - this.angry = angry; - this.nectar = nectar; - } - - public static BeeState getBeeState(Kleenean angry, Kleenean nectar) { - for (BeeState beeState : BeeState.values()) { - if (beeState.angry == angry && beeState.nectar == nectar) - return beeState; - } - return null; - } - - } - - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"bee", BeeState.BEE}, - {"no nectar bee", BeeState.NO_NECTAR}, - {"nectar bee", BeeState.NECTAR}, - {"happy bee", BeeState.HAPPY}, - {"happy nectar bee", BeeState.HAPPY_NECTAR}, - {"happy no nectar bee", BeeState.HAPPY_NO_NECTAR}, - {"angry bee", BeeState.ANGRY}, - {"angry no nectar bee", BeeState.ANGRY_NO_NECTAR}, - {"angry nectar bee", BeeState.ANGRY_NECTAR} + public record BeeState(Kleenean angry, Kleenean nectar) {} + + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ + {"bee", new BeeState(Kleenean.UNKNOWN, Kleenean.UNKNOWN)}, + {"no nectar bee", new BeeState(Kleenean.UNKNOWN, Kleenean.FALSE)}, + {"nectar bee", new BeeState(Kleenean.UNKNOWN, Kleenean.TRUE)}, + {"happy bee", new BeeState(Kleenean.FALSE, Kleenean.UNKNOWN)}, + {"happy nectar bee", new BeeState(Kleenean.FALSE, Kleenean.TRUE)}, + {"happy no nectar bee", new BeeState(Kleenean.FALSE, Kleenean.FALSE)}, + {"angry bee", new BeeState(Kleenean.TRUE, Kleenean.UNKNOWN)}, + {"angry no nectar bee", new BeeState(Kleenean.TRUE, Kleenean.FALSE)}, + {"angry nectar bee", new BeeState(Kleenean.TRUE, Kleenean.TRUE)} }); static { @@ -65,18 +39,18 @@ public BeeData() {} public BeeData(@Nullable Kleenean isAngry, @Nullable Kleenean hasNectar) { this.isAngry = isAngry != null ? isAngry : Kleenean.UNKNOWN; this.hasNectar = hasNectar != null ? hasNectar : Kleenean.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(BeeState.getBeeState(this.isAngry, this.hasNectar))[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(this.isAngry, this.hasNectar), 0); } public BeeData(@Nullable BeeState beeState) { if (beeState != null) { this.isAngry = beeState.angry; this.hasNectar = beeState.nectar; - super.dataCodeName = PATTERNS.getMatchedPatterns(beeState)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(beeState, 0); } else { this.isAngry = Kleenean.UNKNOWN; this.hasNectar = Kleenean.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(BeeState.BEE)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(Kleenean.UNKNOWN, Kleenean.UNKNOWN), 0); } } @@ -94,7 +68,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable Bee if (bee != null) { isAngry = Kleenean.get(bee.getAnger() > 0); hasNectar = Kleenean.get(bee.hasNectar()); - super.dataCodeName = PATTERNS.getMatchedPatterns(BeeState.getBeeState(isAngry, hasNectar))[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(isAngry, hasNectar), 0); } return true; } @@ -108,9 +82,9 @@ public void set(Bee bee) { @Override protected boolean match(Bee bee) { - if (!isAngry.isUnknown() && isAngry != Kleenean.get(bee.getAnger() > 0)) + if (!kleeneanMatch(isAngry, bee.getAnger() > 0)) return false; - return hasNectar.isUnknown() || hasNectar == Kleenean.get(bee.hasNectar()); + return kleeneanMatch(hasNectar, bee.hasNectar()); } @Override @@ -143,9 +117,9 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof BeeData other)) return false; - if (!isAngry.isUnknown() && isAngry != other.isAngry) + if (!kleeneanMatch(isAngry, other.isAngry)) return false; - return hasNectar.isUnknown() || hasNectar == other.hasNectar; + return kleeneanMatch(hasNectar, other.hasNectar); } } diff --git a/src/main/java/ch/njol/skript/entity/BoatChestData.java b/src/main/java/ch/njol/skript/entity/BoatChestData.java index 9474c975c1d..8a9c11a59d4 100644 --- a/src/main/java/ch/njol/skript/entity/BoatChestData.java +++ b/src/main/java/ch/njol/skript/entity/BoatChestData.java @@ -51,7 +51,7 @@ public BoatChestData(@Nullable Boat.Type type) { } private BoatChestData(int type) { - dataCodeName = type; + codeNameIndex = type; } @Override @@ -62,21 +62,21 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @Override protected boolean init(@Nullable Class entityClass, @Nullable ChestBoat chestBoat) { if (chestBoat != null) - dataCodeName = 2 + chestBoat.getBoatType().ordinal(); + codeNameIndex = 2 + chestBoat.getBoatType().ordinal(); return true; } @Override public void set(ChestBoat chestBoat) { - if (dataCodeName == 1) // If the type is 'any boat'. - dataCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. - if (dataCodeName > 1) // 0 and 1 are excluded - chestBoat.setBoatType(types[dataCodeName - 2]); // Removes 2 to fix the index. + if (codeNameIndex == 1) // If the type is 'any boat'. + codeNameIndex += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. + if (codeNameIndex > 1) // 0 and 1 are excluded + chestBoat.setBoatType(types[codeNameIndex - 2]); // Removes 2 to fix the index. } @Override protected boolean match(ChestBoat chestBoat) { - return dataCodeName <= 1 || chestBoat.getBoatType().ordinal() == dataCodeName - 2; + return codeNameIndex <= 1 || chestBoat.getBoatType().ordinal() == codeNameIndex - 2; } @Override @@ -91,20 +91,20 @@ public Class getType() { @Override protected int hashCode_i() { - return dataCodeName <= 1 ? 0 : dataCodeName; + return codeNameIndex <= 1 ? 0 : codeNameIndex; } @Override protected boolean equals_i(EntityData entityData) { if (entityData instanceof BoatChestData other) - return dataCodeName == other.dataCodeName; + return codeNameIndex == other.codeNameIndex; return false; } @Override public boolean isSupertypeOf(EntityData entityData) { if (entityData instanceof BoatChestData other) - return dataCodeName <= 1 || dataCodeName == other.dataCodeName; + return codeNameIndex <= 1 || codeNameIndex == other.codeNameIndex; return false; } @@ -130,7 +130,7 @@ public boolean isOfItemType(ItemType itemType) { // material is a boat AND (data matches any boat OR material and data are same) if (type != null) { ordinal = type.ordinal(); - if (dataCodeName <= 1 || dataCodeName == ordinal + 2) + if (codeNameIndex <= 1 || codeNameIndex == ordinal + 2) return true; } } diff --git a/src/main/java/ch/njol/skript/entity/BoatData.java b/src/main/java/ch/njol/skript/entity/BoatData.java index c5321d0d450..de1872fbe13 100644 --- a/src/main/java/ch/njol/skript/entity/BoatData.java +++ b/src/main/java/ch/njol/skript/entity/BoatData.java @@ -49,7 +49,7 @@ public BoatData(@Nullable Boat.Type type){ } private BoatData(int type) { - dataCodeName = type; + codeNameIndex = type; } @Override @@ -60,21 +60,21 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte @Override protected boolean init(@Nullable Class entityClass, @Nullable Boat boat) { if (boat != null) - dataCodeName = 2 + boat.getBoatType().ordinal(); + codeNameIndex = 2 + boat.getBoatType().ordinal(); return true; } @Override public void set(Boat boat) { - if (dataCodeName == 1) // If the type is 'any boat'. - dataCodeName += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. - if (dataCodeName > 1) // 0 and 1 are excluded - boat.setBoatType(types[dataCodeName - 2]); // Removes 2 to fix the index. + if (codeNameIndex == 1) // If the type is 'any boat'. + codeNameIndex += new Random().nextInt(Boat.Type.values().length); // It will spawn a random boat type in case is 'any boat'. + if (codeNameIndex > 1) // 0 and 1 are excluded + boat.setBoatType(types[codeNameIndex - 2]); // Removes 2 to fix the index. } @Override protected boolean match(Boat boat) { - return dataCodeName <= 1 || boat.getBoatType().ordinal() == dataCodeName - 2; + return codeNameIndex <= 1 || boat.getBoatType().ordinal() == codeNameIndex - 2; } @Override @@ -84,25 +84,25 @@ public Class getType() { @Override public @NotNull EntityData getSuperType() { - return new BoatData(dataCodeName); + return new BoatData(codeNameIndex); } @Override protected int hashCode_i() { - return dataCodeName <= 1 ? 0 : dataCodeName; + return codeNameIndex <= 1 ? 0 : codeNameIndex; } @Override protected boolean equals_i(EntityData entityData) { if (entityData instanceof BoatData other) - return dataCodeName == other.dataCodeName; + return codeNameIndex == other.codeNameIndex; return false; } @Override public boolean isSupertypeOf(EntityData entityData) { if (entityData instanceof BoatData other) - return dataCodeName <= 1 || dataCodeName == other.dataCodeName; + return codeNameIndex <= 1 || codeNameIndex == other.codeNameIndex; return false; } @@ -137,7 +137,7 @@ public boolean isOfItemType(ItemType itemType) { // material is a boat AND (data matches any boat OR material and data are same) if (type != null) { ordinal = type.ordinal(); - if (dataCodeName <= 1 || dataCodeName == ordinal + 2) + if (codeNameIndex <= 1 || codeNameIndex == ordinal + 2) return true; } } diff --git a/src/main/java/ch/njol/skript/entity/CatData.java b/src/main/java/ch/njol/skript/entity/CatData.java index f077a109fc6..80f8de94525 100644 --- a/src/main/java/ch/njol/skript/entity/CatData.java +++ b/src/main/java/ch/njol/skript/entity/CatData.java @@ -50,7 +50,7 @@ public void set(Cat cat) { @Override protected boolean match(Cat cat) { - return type == null || cat.getCatType() == type; + return dataMatch(type, cat.getCatType()); } @Override @@ -79,7 +79,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof CatData other)) return false; - return type == null || type == other.type; + return dataMatch(type, other.type); } } diff --git a/src/main/java/ch/njol/skript/entity/ChickenData.java b/src/main/java/ch/njol/skript/entity/ChickenData.java index ce70dfe77f1..95bd56efe8d 100644 --- a/src/main/java/ch/njol/skript/entity/ChickenData.java +++ b/src/main/java/ch/njol/skript/entity/ChickenData.java @@ -97,7 +97,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof ChickenData other)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } /** diff --git a/src/main/java/ch/njol/skript/entity/CowData.java b/src/main/java/ch/njol/skript/entity/CowData.java index 6faf87f40fe..c59af00f78d 100644 --- a/src/main/java/ch/njol/skript/entity/CowData.java +++ b/src/main/java/ch/njol/skript/entity/CowData.java @@ -119,7 +119,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof CowData other)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } /** diff --git a/src/main/java/ch/njol/skript/entity/CreeperData.java b/src/main/java/ch/njol/skript/entity/CreeperData.java index 69ab4cc6731..cfaace08b31 100644 --- a/src/main/java/ch/njol/skript/entity/CreeperData.java +++ b/src/main/java/ch/njol/skript/entity/CreeperData.java @@ -1,18 +1,18 @@ package ch.njol.skript.entity; +import ch.njol.skript.lang.Literal; +import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.Kleenean; import org.bukkit.entity.Creeper; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import ch.njol.skript.lang.Literal; -import ch.njol.skript.lang.SkriptParser.ParseResult; - import java.util.Objects; public class CreeperData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"creeper", Kleenean.UNKNOWN}, {"powered creeper", Kleenean.TRUE}, {"unpowered creeper", Kleenean.FALSE} @@ -28,7 +28,7 @@ public CreeperData() {} public CreeperData(@Nullable Kleenean powered) { this.powered = powered != null ? powered : Kleenean.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(this.powered)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(this.powered, 0); } @Override @@ -41,7 +41,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Creeper creeper) { if (creeper != null) { powered = Kleenean.get(creeper.isPowered()); - super.dataCodeName = PATTERNS.getMatchedPatterns(powered)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(powered, 0); } return true; } @@ -53,7 +53,7 @@ public void set(Creeper creeper) { @Override public boolean match(Creeper creeper) { - return powered.isUnknown() || powered == Kleenean.get(creeper.isPowered()); + return kleeneanMatch(powered, creeper.isPowered()); } @Override @@ -82,7 +82,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof CreeperData other)) return false; - return powered.isUnknown() || powered == other.powered; + return kleeneanMatch(powered, other.powered); } } diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index a9fffaa726f..c8028069eec 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -318,7 +318,7 @@ public static > void register( /** * References the corresponding code name in the order they're registered. */ - protected int dataCodeName = 0; + protected int codeNameIndex = 0; private Kleenean plural = Kleenean.UNKNOWN; private Kleenean baby = Kleenean.UNKNOWN; @@ -326,7 +326,7 @@ public EntityData() { for (EntityDataInfo info : infos) { if (getClass() == info.getElementClass()) { this.info = info; - dataCodeName = info.defaultName; + codeNameIndex = info.defaultName; return; } } @@ -355,7 +355,7 @@ public final boolean init(Expression[] exprs, int matchedPattern, Kleenean is String codeName = info.getCodeNameFromPattern(matchedPattern); int matchedCodeName = info.getCodeNamePlacement(codeName); int patternInCodeName = info.getPatternInCodeName(matchedPattern); - this.dataCodeName = matchedCodeName; + this.codeNameIndex = matchedCodeName; return init(Arrays.copyOf(exprs, exprs.length, Literal[].class), matchedCodeName, patternInCodeName, parseResult); } @@ -453,7 +453,7 @@ public final String toString() { @SuppressWarnings("null") protected Noun getName() { - return info.names[dataCodeName]; + return info.names[codeNameIndex]; } protected @Nullable Adjective getAgeAdjective() { @@ -467,7 +467,7 @@ protected Noun getName() { @SuppressWarnings("null") public String toString(int flags) { - Noun name = info.names[dataCodeName]; + Noun name = info.names[codeNameIndex]; if (baby.isTrue()) { return m_baby.toString(name, flags); } else if (baby.isFalse()) { @@ -504,7 +504,7 @@ public final int hashCode() { int result = 1; result = prime * result + baby.hashCode(); result = prime * result + plural.hashCode(); - result = prime * result + dataCodeName; + result = prime * result + codeNameIndex; result = prime * result + info.hashCode(); result = prime * result + hashCode_i(); return result; @@ -531,7 +531,7 @@ public final boolean equals(@Nullable Object obj) { return false; if (plural != other.plural) return false; - if (dataCodeName != other.dataCodeName) + if (codeNameIndex != other.codeNameIndex) return false; if (!info.equals(other.info)) return false; @@ -910,4 +910,41 @@ protected boolean deserialize(String string) { return world.createEntity(location, type); } + /** + * Checks if {@code from} is {@link Kleenean#UNKNOWN} or is equal to {@code to}. + * + * @param from The {@link Kleenean} to compare to. + * @param to The {@link boolean} to compare against. + * @return {@code true} if {@code from} is {@link Kleenean#UNKNOWN} or is equal to {@code to}, otherwise {@code false}. + */ + protected boolean kleeneanMatch(Kleenean from, boolean to) { + return kleeneanMatch(from, Kleenean.get(to)); + } + + /** + * Checks if {@code from} is {@link Kleenean#UNKNOWN} or is equal to {@code to}. + * + * @param from The {@link Kleenean} to compare to. + * @param to The {@link boolean} to compare against. + * @return {@code true} if {@code from} is {@link Kleenean#UNKNOWN} or is equal to {@code to}, otherwise {@code false}. + */ + protected boolean kleeneanMatch(Kleenean from, Kleenean to) { + if (from.isUnknown()) + return true; + return from == to; + } + + /** + * Checks if {@code from} is {@code null} or is equal to {@code to}. + * + * @param from The object to compare to. + * @param to The object to compare against. + * @return {@code true} if {@code from} is {@code null} or is equal to {@code to}, otherwise {@code false}. + */ + protected boolean dataMatch(@Nullable T from, T to) { + if (from == null) + return true; + return from == to; + } + } diff --git a/src/main/java/ch/njol/skript/entity/EntityPatterns.java b/src/main/java/ch/njol/skript/entity/EntityPatterns.java deleted file mode 100644 index c117f93fd39..00000000000 --- a/src/main/java/ch/njol/skript/entity/EntityPatterns.java +++ /dev/null @@ -1,82 +0,0 @@ -package ch.njol.skript.entity; - -import ch.njol.skript.lang.Expression; -import ch.njol.skript.lang.SkriptParser.ParseResult; -import ch.njol.skript.lang.SyntaxElement; -import ch.njol.util.Kleenean; -import org.jetbrains.annotations.Nullable; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -public class EntityPatterns { - - private final String[] patterns; - private final Object[] types; - private final Map> matchedPatterns = new HashMap<>(); - - /** - * Creates a new {@link EntityPatterns} with a provided {@link Object[][]} in the form of - * - * {{String, T}, {String, T}, ...} - * {{pattern, correlating object}} - * - */ - public EntityPatterns(Object[][] info) { - patterns = new String[info.length]; - types = new Object[info.length]; - for (int i = 0; i < info.length; i++) { - if (info[i].length != 2 || !(info[i][0] instanceof String)) - throw new IllegalArgumentException("given array is not like {{String, T}, {String, T}, ...}"); - Object object = info[i][1]; - if (object == null) - object = EntityPatternNone.NONE; - patterns[i] = (String) info[i][0]; - types[i] = object; - matchedPatterns.computeIfAbsent(object, list -> new ArrayList<>()).add(i); - } - } - - /** - * Returns an array of the registered patterns. - * @return An {@link java.lang.reflect.Array} of {@link String}s. - */ - public String[] getPatterns() { - return patterns; - } - - /** - * Returns the typed object {@link T} correlating to {@code matchedPattern}. - * - * @param matchedPattern The pattern to get the data to as given in {@link SyntaxElement#init(Expression[], int, Kleenean, ParseResult)} - * @return The info associated with the matched pattern - * @throws ClassCastException If the item in the source array is not of the requested type - */ - public @Nullable T getInfo(int matchedPattern) { - Object object = types[matchedPattern]; - if (object == null || object == EntityPatternNone.NONE) - return null; - //noinspection unchecked - return (T) object; - } - - /** - * Gets all pattern indices that correlate to {@code type}. - * - * @param type The typed object. - * @return An array of pattern indices. - */ - public Integer[] getMatchedPatterns(@Nullable T type) { - Object object = type; - if (object == null) - object = EntityPatternNone.NONE; - return matchedPatterns.get(object).toArray(Integer[]::new); - } - - private enum EntityPatternNone { - NONE - } - -} diff --git a/src/main/java/ch/njol/skript/entity/FoxData.java b/src/main/java/ch/njol/skript/entity/FoxData.java index f849eeaba84..89610d1615c 100644 --- a/src/main/java/ch/njol/skript/entity/FoxData.java +++ b/src/main/java/ch/njol/skript/entity/FoxData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Fox; import org.bukkit.entity.Fox.Type; @@ -12,7 +13,7 @@ public class FoxData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"fox", null}, {"red fox", Type.RED}, {"snow fox", Type.SNOW} @@ -29,7 +30,7 @@ public FoxData() {} public FoxData(@Nullable Type type) { this.type = type; - super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); } @Override @@ -42,7 +43,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Fox fox) { if (fox != null) { type = fox.getFoxType(); - super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); } return true; } @@ -58,7 +59,7 @@ public void set(Fox fox) { @Override protected boolean match(Fox fox) { - return type == null || type == fox.getFoxType(); + return dataMatch(type, fox.getFoxType()); } @Override @@ -87,7 +88,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof FoxData other)) return false; - return type == null || type == other.type; + return dataMatch(type, other.type); } } diff --git a/src/main/java/ch/njol/skript/entity/FrogData.java b/src/main/java/ch/njol/skript/entity/FrogData.java index 39c030e05b5..5d5daf1e556 100644 --- a/src/main/java/ch/njol/skript/entity/FrogData.java +++ b/src/main/java/ch/njol/skript/entity/FrogData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Frog; import org.bukkit.entity.Frog.Variant; @@ -13,7 +14,7 @@ public class FrogData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"frog", null}, {"temperate frog", Variant.TEMPERATE}, {"warm frog", Variant.WARM}, @@ -33,7 +34,7 @@ public FrogData() {} public FrogData(@Nullable Variant variant) { this.variant = variant; - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } @Override @@ -46,7 +47,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Frog frog) { if (frog != null) { variant = frog.getVariant(); - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } return true; } @@ -62,7 +63,7 @@ public void set(Frog frog) { @Override protected boolean match(Frog frog) { - return variant == null || variant == frog.getVariant(); + return dataMatch(variant, frog.getVariant()); } @Override @@ -91,7 +92,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof FrogData other)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } } diff --git a/src/main/java/ch/njol/skript/entity/GoatData.java b/src/main/java/ch/njol/skript/entity/GoatData.java index 14e8755c4be..03777616d5a 100644 --- a/src/main/java/ch/njol/skript/entity/GoatData.java +++ b/src/main/java/ch/njol/skript/entity/GoatData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.Kleenean; import org.bukkit.entity.Goat; import org.jetbrains.annotations.NotNull; @@ -11,7 +12,7 @@ public class GoatData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"goat", Kleenean.UNKNOWN}, {"screaming goat", Kleenean.TRUE}, {"quiet goat", Kleenean.FALSE} @@ -27,6 +28,7 @@ public GoatData() {} public GoatData(@Nullable Kleenean screaming) { this.screaming = screaming != null ? screaming : Kleenean.UNKNOWN; + super.codeNameIndex = PATTERNS.getMatchedPattern(this.screaming, 0); } @Override @@ -39,7 +41,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Goat goat) { if (goat != null) { screaming = Kleenean.get(goat.isScreaming()); - super.dataCodeName = PATTERNS.getMatchedPatterns(screaming)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(screaming, 0); } return true; } @@ -51,7 +53,7 @@ public void set(Goat goat) { @Override protected boolean match(Goat goat) { - return screaming.isUnknown() || screaming == Kleenean.get(goat.isScreaming()); + return kleeneanMatch(screaming, goat.isScreaming()); } @Override @@ -80,7 +82,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof GoatData other)) return false; - return screaming.isUnknown() || screaming == other.screaming; + return kleeneanMatch(screaming, other.screaming); } } diff --git a/src/main/java/ch/njol/skript/entity/LlamaData.java b/src/main/java/ch/njol/skript/entity/LlamaData.java index 7b9709aebe4..2f19fc8bb6e 100644 --- a/src/main/java/ch/njol/skript/entity/LlamaData.java +++ b/src/main/java/ch/njol/skript/entity/LlamaData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Llama; import org.bukkit.entity.Llama.Color; @@ -13,17 +14,19 @@ public class LlamaData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"llama", null}, - {"creamy llama", Color.CREAMY}, - {"white llama", Color.WHITE}, - {"brown llama", Color.BROWN}, - {"gray llama", Color.GRAY}, - {"trader llama", null}, - {"creamy trader llama", Color.CREAMY}, - {"white trader llama", Color.WHITE}, - {"brown trader llama", Color.BROWN}, - {"gray trader llama", Color.GRAY} + public record LlamaState(Color color, boolean trader) {} + + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ + {"llama", new LlamaState(null, false)}, + {"creamy llama", new LlamaState(Color.CREAMY, false)}, + {"white llama", new LlamaState(Color.WHITE, false)}, + {"brown llama", new LlamaState(Color.BROWN, false)}, + {"gray llama", new LlamaState(Color.GRAY, false)}, + {"trader llama", new LlamaState(null, true)}, + {"creamy trader llama", new LlamaState(Color.CREAMY, true)}, + {"white trader llama", new LlamaState(Color.WHITE, true)}, + {"brown trader llama", new LlamaState(Color.BROWN, true)}, + {"gray trader llama", new LlamaState(Color.GRAY, true)} }); private static final Color[] LLAMA_COLORS = Color.values(); @@ -39,13 +42,27 @@ public LlamaData() {} public LlamaData(@Nullable Color color, boolean isTrader) { this.color = color; this.isTrader = isTrader; - super.dataCodeName = PATTERNS.getMatchedPatterns(color)[!isTrader ? 0 : 1]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(color, isTrader), 0); + } + + public LlamaData(@Nullable LlamaState llamaState) { + if (llamaState != null) { + this.color = llamaState.color; + this.isTrader = llamaState.trader; + super.codeNameIndex = PATTERNS.getMatchedPattern(llamaState, 0); + } else { + this.color = null; + this.isTrader = false; + super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(null, false), 0); + } } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - isTrader = matchedCodeName > 4; - color = PATTERNS.getInfo(matchedCodeName); + LlamaState llamaState = PATTERNS.getInfo(matchedCodeName); + assert llamaState != null; + color = llamaState.color; + isTrader = llamaState.trader; return true; } @@ -56,7 +73,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable L if (llama != null) { color = llama.getColor(); isTrader = llama instanceof TraderLlama; - super.dataCodeName = PATTERNS.getMatchedPatterns(color)[!isTrader ? 0 : 1]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(color, isTrader), 0); } return true; } @@ -74,7 +91,7 @@ public void set(Llama llama) { protected boolean match(Llama llama) { if (isTrader && !(llama instanceof TraderLlama)) return false; - return color == null || color == llama.getColor(); + return dataMatch(color, llama.getColor()); } @Override @@ -110,7 +127,7 @@ public boolean isSupertypeOf(EntityData entityData) { if (isTrader && !other.isTrader) return false; - return color == null || color == other.color; + return dataMatch(color, other.color); } } diff --git a/src/main/java/ch/njol/skript/entity/MinecartData.java b/src/main/java/ch/njol/skript/entity/MinecartData.java index 1baf9910fac..6c5ca718f87 100644 --- a/src/main/java/ch/njol/skript/entity/MinecartData.java +++ b/src/main/java/ch/njol/skript/entity/MinecartData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.skript.variables.Variables; import org.bukkit.entity.Minecart; import org.bukkit.entity.minecart.CommandMinecart; @@ -34,7 +35,7 @@ public enum MinecartType { } private static final MinecartType[] TYPES = MinecartType.values(); - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"minecart", MinecartType.ANY}, {"regular minecart", MinecartType.NORMAL}, {"storage minecart", MinecartType.STORAGE}, @@ -57,7 +58,7 @@ public MinecartData() {} public MinecartData(@Nullable MinecartType type) { this.type = type != null ? type : MinecartType.ANY; - super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(this.type, 0); } @Override @@ -79,7 +80,7 @@ protected boolean init(@Nullable Class entityClass, @Nullabl } if (this.type == null) this.type = MinecartType.ANY; - super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); return true; } diff --git a/src/main/java/ch/njol/skript/entity/MooshroomData.java b/src/main/java/ch/njol/skript/entity/MooshroomData.java index 0a915bf52c2..8f169f4a4b7 100644 --- a/src/main/java/ch/njol/skript/entity/MooshroomData.java +++ b/src/main/java/ch/njol/skript/entity/MooshroomData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.MushroomCow; import org.bukkit.entity.MushroomCow.Variant; @@ -12,7 +13,7 @@ public class MooshroomData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"mooshroom", null}, {"red mooshroom", Variant.RED}, {"brown mooshroom", Variant.BROWN} @@ -29,7 +30,7 @@ public MooshroomData() {} public MooshroomData(@Nullable Variant variant) { this.variant = variant; - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant,0); } @Override @@ -42,7 +43,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable MushroomCow mushroomCow) { if (mushroomCow != null) { variant = mushroomCow.getVariant(); - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant,0); } return true; } @@ -58,7 +59,7 @@ public void set(MushroomCow mushroomCow) { @Override protected boolean match(MushroomCow mushroomCow) { - return variant == null || variant == mushroomCow.getVariant(); + return dataMatch(variant, mushroomCow.getVariant()); } @Override @@ -87,7 +88,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof MooshroomData other)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } } diff --git a/src/main/java/ch/njol/skript/entity/PandaData.java b/src/main/java/ch/njol/skript/entity/PandaData.java index bc1607af379..4d8a9fa11c2 100644 --- a/src/main/java/ch/njol/skript/entity/PandaData.java +++ b/src/main/java/ch/njol/skript/entity/PandaData.java @@ -60,12 +60,9 @@ public void set(Panda panda) { @Override protected boolean match(Panda panda) { - boolean matched = true; - if (mainGene != null) - matched &= (mainGene == panda.getMainGene()); - if (hiddenGene != null) - matched &= (hiddenGene == panda.getHiddenGene()); - return matched; + if (!dataMatch(mainGene, panda.getMainGene())) + return false; + return dataMatch(hiddenGene, panda.getHiddenGene()); } @Override @@ -98,7 +95,9 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof PandaData other)) return false; - return (mainGene == null || mainGene == other.mainGene) && (hiddenGene == null || hiddenGene == other.hiddenGene); + if (!dataMatch(mainGene, other.mainGene)) + return false; + return dataMatch(hiddenGene, other.hiddenGene); } @Override diff --git a/src/main/java/ch/njol/skript/entity/ParrotData.java b/src/main/java/ch/njol/skript/entity/ParrotData.java index 6d455813d29..06a49bf50da 100644 --- a/src/main/java/ch/njol/skript/entity/ParrotData.java +++ b/src/main/java/ch/njol/skript/entity/ParrotData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Parrot; import org.bukkit.entity.Parrot.Variant; @@ -11,7 +12,7 @@ public class ParrotData extends EntityData { private static final Variant[] VARIANTS = Variant.values(); - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"parrot", null}, {"red parrot", Variant.RED}, {"blue parrot", Variant.BLUE}, @@ -31,7 +32,7 @@ public ParrotData() {} public ParrotData(@Nullable Variant variant) { this.variant = variant; - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } @Override @@ -44,7 +45,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Parrot parrot) { if (parrot != null) { variant = parrot.getVariant(); - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } return true; } @@ -60,7 +61,7 @@ public void set(Parrot parrot) { @Override protected boolean match(Parrot parrot) { - return variant == null || variant == parrot.getVariant(); + return dataMatch(variant, parrot.getVariant()); } @Override @@ -89,7 +90,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof ParrotData other)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } } diff --git a/src/main/java/ch/njol/skript/entity/PigData.java b/src/main/java/ch/njol/skript/entity/PigData.java index 2271f8c361a..d917b00e131 100644 --- a/src/main/java/ch/njol/skript/entity/PigData.java +++ b/src/main/java/ch/njol/skript/entity/PigData.java @@ -4,6 +4,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.registrations.Classes; +import ch.njol.skript.util.Patterns; import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; @@ -17,7 +18,7 @@ public class PigData extends EntityData { private static final boolean VARIANTS_ENABLED; private static final Object[] VARIANTS; - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"pig", Kleenean.UNKNOWN}, {"saddled pig", Kleenean.TRUE}, {"unsaddled pig", Kleenean.FALSE} @@ -43,7 +44,7 @@ public PigData() {} public PigData(@Nullable Kleenean saddled, @Nullable Object variant) { this.saddled = saddled != null ? saddled : Kleenean.UNKNOWN; this.variant = variant; - super.dataCodeName = PATTERNS.getMatchedPatterns(saddled)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(this.saddled, 0); } @Override @@ -60,7 +61,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Pig pig) { if (pig != null) { saddled = Kleenean.get(pig.hasSaddle()); - super.dataCodeName = PATTERNS.getMatchedPatterns(saddled)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(saddled, 0); if (VARIANTS_ENABLED) variant = pig.getVariant(); } @@ -79,7 +80,7 @@ public void set(Pig pig) { @Override protected boolean match(Pig pig) { - if (!saddled.isUnknown() && saddled != Kleenean.get(pig.hasSaddle())) + if (!kleeneanMatch(saddled, pig.hasSaddle())) return false; return variant == null || variant == pig.getVariant(); } @@ -112,7 +113,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof PigData other)) return false; - if (!saddled.isUnknown() && saddled != other.saddled) + if (!kleeneanMatch(saddled, other.saddled)) return false; return variant == null || variant == other.variant; } diff --git a/src/main/java/ch/njol/skript/entity/RabbitData.java b/src/main/java/ch/njol/skript/entity/RabbitData.java index abab1c875a8..3b7c917f05b 100644 --- a/src/main/java/ch/njol/skript/entity/RabbitData.java +++ b/src/main/java/ch/njol/skript/entity/RabbitData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Rabbit; import org.bukkit.entity.Rabbit.Type; @@ -12,7 +13,7 @@ public class RabbitData extends EntityData { private static final Type[] TYPES = Type.values(); - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"rabbit", null}, {"white rabbit", Type.WHITE}, {"black rabbit", Type.BLACK}, @@ -33,7 +34,7 @@ public RabbitData() {} public RabbitData(@Nullable Type type) { this.type = type; - super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); } @Override @@ -46,7 +47,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Rabbit rabbit) { if (rabbit != null) { type = rabbit.getRabbitType(); - super.dataCodeName = PATTERNS.getMatchedPatterns(type)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); } return true; } @@ -62,7 +63,7 @@ public void set(Rabbit rabbit) { @Override protected boolean match(Rabbit rabbit) { - return type == null || type == rabbit.getRabbitType(); + return dataMatch(type, rabbit.getRabbitType()); } @Override @@ -91,7 +92,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof RabbitData other)) return false; - return type == null || type == other.type; + return dataMatch(type, other.type); } } diff --git a/src/main/java/ch/njol/skript/entity/SalmonData.java b/src/main/java/ch/njol/skript/entity/SalmonData.java index 5aa1cf88cc6..2215a2c86fe 100644 --- a/src/main/java/ch/njol/skript/entity/SalmonData.java +++ b/src/main/java/ch/njol/skript/entity/SalmonData.java @@ -3,6 +3,7 @@ import ch.njol.skript.Skript; import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Salmon; import org.bukkit.entity.Salmon.Variant; @@ -13,12 +14,12 @@ public class SalmonData extends EntityData { private static final boolean SUPPORT_SALMON_VARIANTS = Skript.classExists("org.bukkit.entity.Salmon$Variant"); private static final Object[] VARIANTS; - private static final EntityPatterns PATTERNS; + private static final Patterns PATTERNS; static { if (SUPPORT_SALMON_VARIANTS) { VARIANTS = Salmon.Variant.values(); - PATTERNS = new EntityPatterns<>(new Object[][]{ + PATTERNS = new Patterns<>(new Object[][]{ {"salmon", null}, {"any salmon", null}, {"small salmon", Variant.SMALL}, @@ -27,7 +28,7 @@ public class SalmonData extends EntityData { }); } else { VARIANTS = null; - PATTERNS = new EntityPatterns<>(new Object[][]{ + PATTERNS = new Patterns<>(new Object[][]{ {"salmon", null} }); } @@ -42,7 +43,7 @@ public SalmonData() {} // TODO: When safe, 'variant' should have the type changed to 'Salmon.Variant' when 1.21.2 is minimum supported version public SalmonData(@Nullable Object variant) { this.variant = variant; - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } @Override @@ -55,7 +56,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Salmon salmon) { if (salmon != null && SUPPORT_SALMON_VARIANTS) { variant = salmon.getVariant(); - super.dataCodeName = PATTERNS.getMatchedPatterns(variant)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); } return true; } @@ -95,14 +96,14 @@ protected int hashCode_i() { protected boolean equals_i(EntityData entityData) { if (!(entityData instanceof SalmonData other)) return false; - return variant == null || variant == other.variant; + return variant == other.variant; } @Override public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof SalmonData other)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } } diff --git a/src/main/java/ch/njol/skript/entity/SheepData.java b/src/main/java/ch/njol/skript/entity/SheepData.java index 3f233906b48..9d95affb1f2 100644 --- a/src/main/java/ch/njol/skript/entity/SheepData.java +++ b/src/main/java/ch/njol/skript/entity/SheepData.java @@ -7,6 +7,7 @@ import ch.njol.skript.localization.Language; import ch.njol.skript.localization.Noun; import ch.njol.skript.util.Color; +import ch.njol.skript.util.Patterns; import ch.njol.skript.util.SkriptColor; import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; @@ -18,7 +19,7 @@ public class SheepData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"sheep", Kleenean.UNKNOWN}, {"sheared sheep", Kleenean.TRUE}, {"unsheared sheep", Kleenean.FALSE} @@ -37,7 +38,7 @@ public SheepData() {} public SheepData(@Nullable Kleenean sheared, Color @Nullable [] colors) { this.sheared = sheared != null ? sheared : Kleenean.UNKNOWN; this.colors = colors; - super.dataCodeName = PATTERNS.getMatchedPatterns(this.sheared)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(this.sheared, 0); } @Override @@ -55,7 +56,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable S if (sheep != null) { sheared = Kleenean.get(sheep.isSheared()); colors = CollectionUtils.array(SkriptColor.fromDyeColor(sheep.getColor())); - super.dataCodeName = PATTERNS.getMatchedPatterns(sheared)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(sheared, 0); } return true; } @@ -72,7 +73,7 @@ public void set(Sheep sheep) { @Override public boolean match(Sheep sheep) { - if (!sheared.isUnknown() && sheared != Kleenean.get(sheep.isSheared())) + if (!kleeneanMatch(sheared, sheep.isSheared())) return false; return colors == null || SimpleExpression.check(colors, c -> sheep.getColor() == c.asDyeColor(), false, false); } @@ -109,7 +110,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof SheepData other)) return false; - if (!sheared.isUnknown() && sheared != other.sheared) + if (!kleeneanMatch(sheared, other.sheared)) return false; return colors == null || CollectionUtils.isSubset(colors, other.colors); } diff --git a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java index 509107a1fe2..e6ef26794e6 100644 --- a/src/main/java/ch/njol/skript/entity/SimpleEntityData.java +++ b/src/main/java/ch/njol/skript/entity/SimpleEntityData.java @@ -283,7 +283,7 @@ public SimpleEntityData() { private SimpleEntityData(SimpleEntityDataInfo simpleInfo) { assert simpleInfo != null; this.simpleInfo = simpleInfo; - dataCodeName = types.indexOf(simpleInfo); + codeNameIndex = types.indexOf(simpleInfo); } public SimpleEntityData(Class entityClass) { @@ -302,7 +302,7 @@ public SimpleEntityData(Class entityClass) { } if (closestInfo != null) { this.simpleInfo = closestInfo; - this.dataCodeName = closestPattern; + this.codeNameIndex = closestPattern; return; } throw new IllegalStateException(); @@ -323,7 +323,7 @@ public SimpleEntityData(Entity entity) { } if (closestInfo != null) { this.simpleInfo = closestInfo; - this.dataCodeName = closestPattern; + this.codeNameIndex = closestPattern; return; } throw new IllegalStateException(); diff --git a/src/main/java/ch/njol/skript/entity/StriderData.java b/src/main/java/ch/njol/skript/entity/StriderData.java index 0c954adadf4..51868a49dbf 100644 --- a/src/main/java/ch/njol/skript/entity/StriderData.java +++ b/src/main/java/ch/njol/skript/entity/StriderData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.Kleenean; import org.bukkit.entity.Strider; import org.jetbrains.annotations.NotNull; @@ -11,7 +12,7 @@ public class StriderData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"strider", Kleenean.UNKNOWN}, {"warm strider", Kleenean.FALSE}, {"shivering strider", Kleenean.TRUE} @@ -27,7 +28,7 @@ public StriderData() {} public StriderData(@Nullable Kleenean shivering) { this.shivering = shivering != null ? shivering : Kleenean.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(shivering)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(this.shivering, 0); } @Override @@ -40,7 +41,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Strider strider) { if (strider != null) { shivering = Kleenean.get(strider.isShivering()); - super.dataCodeName = PATTERNS.getMatchedPatterns(shivering)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(shivering, 0); } return true; } @@ -52,7 +53,7 @@ public void set(Strider entity) { @Override protected boolean match(Strider strider) { - return shivering.isUnknown() || shivering == Kleenean.get(strider.isShivering()); + return kleeneanMatch(shivering, strider.isShivering()); } @Override @@ -81,7 +82,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof StriderData other)) return false; - return shivering.isUnknown() || shivering == other.shivering; + return kleeneanMatch(shivering, other.shivering); } } diff --git a/src/main/java/ch/njol/skript/entity/TropicalFishData.java b/src/main/java/ch/njol/skript/entity/TropicalFishData.java index 78b071c6831..641db9b10b0 100644 --- a/src/main/java/ch/njol/skript/entity/TropicalFishData.java +++ b/src/main/java/ch/njol/skript/entity/TropicalFishData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Color; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.DyeColor; import org.bukkit.entity.TropicalFish; @@ -14,7 +15,7 @@ public class TropicalFishData extends EntityData { - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"tropical fish", null}, {"kob", Pattern.KOB}, {"sunstreak", Pattern.SUNSTREAK}, @@ -45,7 +46,7 @@ public TropicalFishData(@Nullable Pattern fishPattern, @Nullable DyeColor bodyCo this.fishPattern = fishPattern; this.bodyColor = bodyColor; this.patternColor = patternColor; - super.dataCodeName = PATTERNS.getMatchedPatterns(fishPattern)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(fishPattern, 0); } @Override @@ -78,7 +79,7 @@ protected boolean init(@Nullable Class entityClass, @Nul bodyColor = tropicalFish.getBodyColor(); patternColor = tropicalFish.getPatternColor(); fishPattern = tropicalFish.getPattern(); - super.dataCodeName = PATTERNS.getMatchedPatterns(fishPattern)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(fishPattern, 0); } return true; } @@ -99,11 +100,11 @@ public void set(TropicalFish tropicalFish) { @Override protected boolean match(TropicalFish tropicalFish) { - if (bodyColor != null && bodyColor != tropicalFish.getBodyColor()) + if (!dataMatch(bodyColor, tropicalFish.getBodyColor())) return false; - if (patternColor != null && patternColor != tropicalFish.getPatternColor()) + if (!dataMatch(patternColor, tropicalFish.getPatternColor())) return false; - return fishPattern == null || fishPattern == tropicalFish.getPattern(); + return dataMatch(fishPattern, tropicalFish.getPattern()); } @Override @@ -136,11 +137,11 @@ public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof TropicalFishData other)) return false; - if (bodyColor != null && bodyColor != other.bodyColor) + if (!dataMatch(bodyColor, other.bodyColor)) return false; - if (patternColor != null && patternColor != other.patternColor) + if (!dataMatch(patternColor, other.patternColor)) return false; - return fishPattern == null || fishPattern == other.fishPattern; + return dataMatch(fishPattern, other.fishPattern); } } diff --git a/src/main/java/ch/njol/skript/entity/VillagerData.java b/src/main/java/ch/njol/skript/entity/VillagerData.java index c73d2a0b671..96c36306cd2 100644 --- a/src/main/java/ch/njol/skript/entity/VillagerData.java +++ b/src/main/java/ch/njol/skript/entity/VillagerData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Villager; @@ -20,7 +21,7 @@ public class VillagerData extends EntityData { * for villagers. */ private static final Profession[] PROFESSIONS; - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"villager", null}, {"unemployed", Profession.NONE}, {"armorer", Profession.ARMORER}, @@ -55,7 +56,7 @@ public VillagerData() {} public VillagerData(@Nullable Profession profession) { this.profession = profession; - super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); } @Override @@ -68,7 +69,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class villagerClass, @Nullable Villager villager) { if (villager != null) { profession = villager.getProfession(); - super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); } return true; } @@ -86,7 +87,7 @@ public void set(Villager villager) { @Override protected boolean match(Villager villager) { - return profession == null || profession == villager.getProfession(); + return dataMatch(profession, villager.getProfession()); } @Override @@ -115,7 +116,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof VillagerData other)) return false; - return profession == null || profession.equals(other.profession); + return dataMatch(profession, other.profession); } } diff --git a/src/main/java/ch/njol/skript/entity/WolfData.java b/src/main/java/ch/njol/skript/entity/WolfData.java index e8dcd62e6ac..1522f71983b 100644 --- a/src/main/java/ch/njol/skript/entity/WolfData.java +++ b/src/main/java/ch/njol/skript/entity/WolfData.java @@ -5,6 +5,7 @@ import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.registrations.Classes; import ch.njol.skript.util.Color; +import ch.njol.skript.util.Patterns; import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import com.google.common.collect.Iterators; @@ -17,42 +18,19 @@ public class WolfData extends EntityData { - public enum WolfState { - WOLF(Kleenean.UNKNOWN, Kleenean.UNKNOWN), - WILD(Kleenean.UNKNOWN, Kleenean.FALSE), - TAMED(Kleenean.UNKNOWN, Kleenean.TRUE), - ANGRY(Kleenean.TRUE, Kleenean.UNKNOWN), - PEACEFUL(Kleenean.FALSE, Kleenean.UNKNOWN); + public record WolfStates(Kleenean angry, Kleenean tamed) {} - private final Kleenean angry; - private final Kleenean tamed; - - WolfState(Kleenean angry, Kleenean tamed) { - this.angry = angry; - this.tamed = tamed; - } - - public static WolfState getWolfState(Kleenean angry, Kleenean tamed) { - for (WolfState wolfState : values()) { - if (wolfState.angry == angry && wolfState.tamed == tamed) - return wolfState; - } - return null; - } - } - - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ - {"wolf", WolfState.WOLF}, - {"wild wolf", WolfState.WILD}, - {"tamed wolf", WolfState.TAMED}, - {"angry wolf", WolfState.ANGRY}, - {"peaceful wolf", WolfState.PEACEFUL} + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ + {"wolf", new WolfStates(Kleenean.UNKNOWN, Kleenean.UNKNOWN)}, + {"wild wolf", new WolfStates(Kleenean.UNKNOWN, Kleenean.FALSE)}, + {"tamed wolf", new WolfStates(Kleenean.UNKNOWN, Kleenean.TRUE)}, + {"angry wolf", new WolfStates(Kleenean.TRUE, Kleenean.UNKNOWN)}, + {"peaceful wolf", new WolfStates(Kleenean.FALSE, Kleenean.UNKNOWN)} }); private static final boolean VARIANTS_ENABLED; private static final Object[] VARIANTS; - static { EntityData.register(WolfData.class, "wolf", Wolf.class, 0, PATTERNS.getPatterns()); if (Skript.classExists("org.bukkit.entity.Wolf$Variant")) { @@ -74,24 +52,24 @@ public WolfData() {} public WolfData(@Nullable Kleenean isAngry, @Nullable Kleenean isTamed) { this.isAngry = isAngry != null ? isAngry : Kleenean.UNKNOWN; this.isTamed = isTamed != null ? isTamed : Kleenean.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(WolfState.getWolfState(this.isAngry, this.isTamed))[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(this.isAngry, this.isTamed), 0); } - public WolfData(@Nullable WolfState wolfState) { + public WolfData(@Nullable WolfStates wolfState) { if (wolfState != null) { this.isAngry = wolfState.angry; this.isTamed = wolfState.tamed; - super.dataCodeName = PATTERNS.getMatchedPatterns(wolfState)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(wolfState, 0); } else { this.isAngry = Kleenean.UNKNOWN; this.isTamed = Kleenean.UNKNOWN; - super.dataCodeName = PATTERNS.getMatchedPatterns(WolfState.WOLF)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(Kleenean.UNKNOWN, Kleenean.UNKNOWN), 0); } } @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { - WolfState state = PATTERNS.getInfo(matchedCodeName); + WolfStates state = PATTERNS.getInfo(matchedCodeName); assert state != null; isAngry = state.angry; isTamed = state.tamed; @@ -114,7 +92,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable Wo collarColor = wolf.getCollarColor(); if (VARIANTS_ENABLED) variant = wolf.getVariant(); - super.dataCodeName = PATTERNS.getMatchedPatterns(WolfState.getWolfState(isAngry, isTamed))[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(isAngry, isTamed), 0); } return true; } @@ -134,11 +112,11 @@ public void set(Wolf wolf) { @Override public boolean match(Wolf wolf) { - if (!isAngry.isUnknown() && isAngry != Kleenean.get(wolf.isAngry())) + if (!kleeneanMatch(isAngry, wolf.isAngry())) return false; - if (!isTamed.isUnknown() && isTamed != Kleenean.get(wolf.isTamed())) + if (!kleeneanMatch(isTamed, wolf.isTamed())) return false; - if (collarColor != null && collarColor != wolf.getCollarColor()) + if (!dataMatch(collarColor, wolf.getCollarColor())) return false; return variant == null || variant == wolf.getVariant(); } @@ -181,13 +159,13 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof WolfData other)) return false; - if (!isAngry.isUnknown() && isAngry != other.isAngry) + if (!kleeneanMatch(isAngry, other.isAngry)) return false; - if (!isTamed.isUnknown() && isTamed != other.isTamed) + if (!kleeneanMatch(isTamed, other.isTamed)) return false; - if (collarColor != null && collarColor != other.collarColor) + if (!dataMatch(collarColor, other.collarColor)) return false; - return variant == null || variant == other.variant; + return dataMatch(variant, other.variant); } /** diff --git a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java index 88f4a6352cc..151e04cce6b 100644 --- a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java +++ b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java @@ -2,6 +2,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; +import ch.njol.skript.util.Patterns; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Villager.Profession; import org.bukkit.entity.ZombieVillager; @@ -14,7 +15,7 @@ public class ZombieVillagerData extends EntityData { private static final Profession[] PROFESSIONS; - private static final EntityPatterns PATTERNS = new EntityPatterns<>(new Object[][]{ + private static final Patterns PATTERNS = new Patterns<>(new Object[][]{ {"zombie villager", null}, {"zombie normal", Profession.NONE}, {"zombie armorer", Profession.ARMORER}, @@ -47,7 +48,7 @@ public ZombieVillagerData() {} public ZombieVillagerData(@Nullable Profession profession) { this.profession = profession; - super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); } @Override @@ -60,7 +61,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable ZombieVillager zombieVillager) { if (zombieVillager != null) { profession = zombieVillager.getVillagerProfession(); - super.dataCodeName = PATTERNS.getMatchedPatterns(profession)[0]; + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); } return true; } @@ -76,7 +77,7 @@ public void set(ZombieVillager zombieVillager) { @Override protected boolean match(ZombieVillager zombieVillager) { - return profession == null || profession == zombieVillager.getVillagerProfession(); + return dataMatch(profession, zombieVillager.getVillagerProfession()); } @Override @@ -105,7 +106,7 @@ protected boolean equals_i(EntityData entityData) { public boolean isSupertypeOf(EntityData entityData) { if (!(entityData instanceof ZombieVillagerData other)) return false; - return profession == null || profession == other.profession; + return dataMatch(profession, other.profession); } } diff --git a/src/main/java/ch/njol/skript/util/Patterns.java b/src/main/java/ch/njol/skript/util/Patterns.java index 2239a921723..641bae4333a 100644 --- a/src/main/java/ch/njol/skript/util/Patterns.java +++ b/src/main/java/ch/njol/skript/util/Patterns.java @@ -4,43 +4,112 @@ import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.lang.SyntaxElement; import ch.njol.util.Kleenean; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; /** * A helper class useful when an expression/condition/effect/etc. needs to associate additional data with each pattern. - * - * @author Peter Güttinger */ public class Patterns { private final String[] patterns; - private final Object[] ts; - + private final Object[] types; + private final Map> matchedPatterns = new HashMap<>(); + /** - * @param info An array which must be like {{String, T}, {String, T}, ...} + * Creates a new {@link Patterns} with a provided {@link Object[][]} in the form of + * + * {{String, T}, {String, T}, ...} + * {{pattern, correlating object}} + * */ - public Patterns(final Object[][] info) { + public Patterns(Object[][] info) { patterns = new String[info.length]; - ts = new Object[info.length]; + types = new Object[info.length]; for (int i = 0; i < info.length; i++) { - if (info[i].length != 2 || !(info[i][0] instanceof String) || info[i][1] == null) + if (info[i].length != 2 || !(info[i][0] instanceof String)) throw new IllegalArgumentException("given array is not like {{String, T}, {String, T}, ...}"); + Optional optional = Optional.ofNullable(info[i][1]); patterns[i] = (String) info[i][0]; - ts[i] = info[i][1]; + types[i] = optional; + matchedPatterns.computeIfAbsent(optional, list -> new ArrayList<>()).add(i); } } - + + /** + * Returns an array of the registered patterns. + * @return An {@link java.lang.reflect.Array} of {@link String}s. + */ public String[] getPatterns() { return patterns; } /** + * Returns the typed object {@link T} correlating to {@code matchedPattern}. + * * @param matchedPattern The pattern to get the data to as given in {@link SyntaxElement#init(Expression[], int, Kleenean, ParseResult)} * @return The info associated with the matched pattern * @throws ClassCastException If the item in the source array is not of the requested type */ - @SuppressWarnings({"unchecked", "null"}) - public T getInfo(final int matchedPattern) { - return (T) ts[matchedPattern]; + public @Nullable T getInfo(int matchedPattern) { + Optional optional = (Optional) types[matchedPattern]; + Object object = optional.orElse(null); + if (object == null) + return null; + //noinspection unchecked + return (T) object; + } + + /** + * Gets all pattern indices that correlate to {@code type}. + * + * @param type The typed object. + * @return An array of pattern indices. + */ + public Integer @Nullable [] getMatchedPatterns(@Nullable T type) { + Optional optional = Optional.ofNullable(type); + if (matchedPatterns.containsKey(optional)) + return matchedPatterns.get(optional).toArray(Integer[]::new); + return null; + } + + /** + * Gets an {@link java.lang.reflect.Array} of all patterns + * registered to {@code type} and the index of the pattern using {@code placement}. + * If there are no patterns registered to {@code type} or the array size is less than {@code placement} + * returns {@code 0}. + * + * @param type The typed object to grab all patterns registered to. + * @param placement The placement of the array for the index of the pattern. + * @return The index of the pattern or {@code 0} if no registered patterns for {@code type} + * or array size is less than {@code placement}. + */ + public int getMatchedPattern(@Nullable T type, int placement) { + return getMatchedPattern(type, placement, 0); + } + + /** + * Gets an {@link java.lang.reflect.Array} of all patterns + * registered to {@code type} and the index of the pattern using {@code placement}. + * If there are no patterns registered to {@code type} or the array size is less than {@code placement} + * returns {@code fallback}. + * + * @param type The typed object to grab all patterns registered to. + * @param placement The placement of the array for the index of the pattern. + * @param fallback The value to fall back to. + * @return The index of the pattern or {@code null} if no registered patterns for {@code type} + * or array size is less than {@code placement}. + */ + public int getMatchedPattern(@Nullable T type, int placement, int fallback) { + Integer[] placements = getMatchedPatterns(type); + if (placements == null || placements.length < placement + 1) + return fallback; + return placements[placement]; } } diff --git a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java index e88cef59975..f8a20c99d27 100644 --- a/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java +++ b/src/main/java/org/skriptlang/skript/bukkit/displays/DisplayData.java @@ -78,7 +78,7 @@ public DisplayData() {} public DisplayData(DisplayType type) { this.type = type; - this.dataCodeName = type.ordinal(); + this.codeNameIndex = type.ordinal(); } @Override From 22e7165de889ccca11fff4890a40b205ab0d4907 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Mon, 7 Jul 2025 20:33:02 -0400 Subject: [PATCH 19/21] FieldHandler --- .../java/ch/njol/skript/entity/BeeData.java | 6 +-- .../ch/njol/skript/entity/EntityData.java | 38 ++++++++++++++++--- src/test/skript/tests/misc/EntityData.sk | 2 + 3 files changed, 37 insertions(+), 9 deletions(-) diff --git a/src/main/java/ch/njol/skript/entity/BeeData.java b/src/main/java/ch/njol/skript/entity/BeeData.java index c44285029f0..c8b0cac5cef 100644 --- a/src/main/java/ch/njol/skript/entity/BeeData.java +++ b/src/main/java/ch/njol/skript/entity/BeeData.java @@ -57,8 +57,8 @@ public BeeData(@Nullable BeeState beeState) { @Override protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPattern, ParseResult parseResult) { BeeState state = PATTERNS.getInfo(matchedCodeName); - assert state != null; - hasNectar = state.nectar; + assert state != null; + hasNectar = state.nectar; isAngry = state.angry; return true; } @@ -85,7 +85,7 @@ protected boolean match(Bee bee) { if (!kleeneanMatch(isAngry, bee.getAnger() > 0)) return false; return kleeneanMatch(hasNectar, bee.hasNectar()); - } + } @Override public Class getType() { diff --git a/src/main/java/ch/njol/skript/entity/EntityData.java b/src/main/java/ch/njol/skript/entity/EntityData.java index c8028069eec..b010e84f8bb 100644 --- a/src/main/java/ch/njol/skript/entity/EntityData.java +++ b/src/main/java/ch/njol/skript/entity/EntityData.java @@ -21,10 +21,13 @@ import ch.njol.skript.localization.Message; import ch.njol.skript.localization.Noun; import ch.njol.skript.registrations.Classes; +import ch.njol.skript.variables.Variables; import ch.njol.util.Kleenean; import ch.njol.util.coll.CollectionUtils; import ch.njol.util.coll.iterator.SingleItemIterator; +import ch.njol.yggdrasil.FieldHandler; import ch.njol.yggdrasil.Fields; +import ch.njol.yggdrasil.Fields.FieldContext; import ch.njol.yggdrasil.YggdrasilSerializable.YggdrasilExtendedSerializable; import org.bukkit.Bukkit; import org.bukkit.Chunk; @@ -40,6 +43,7 @@ import java.io.NotSerializableException; import java.io.StreamCorruptedException; import java.lang.reflect.Array; +import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.ArrayList; @@ -52,7 +56,7 @@ import java.util.stream.Collectors; @SuppressWarnings("rawtypes") -public abstract class EntityData implements SyntaxElement, YggdrasilExtendedSerializable {// TODO extended horse support, zombie villagers // REMIND unit +public abstract class EntityData implements SyntaxElement, YggdrasilExtendedSerializable { /* * In 1.20.2 Spigot deprecated org.bukkit.util.Consumer. @@ -151,6 +155,33 @@ public String toVariableNameString(EntityData entityData) { return "entitydata:" + entityData.toString(); } }).serializer(serializer)); + + Variables.yggdrasil.registerFieldHandler(new FieldHandler() { + @Override + public boolean excessiveField(Object object, FieldContext field) throws StreamCorruptedException { + if (!(object instanceof EntityData entityData)) + return false; + if (field.getID().equals("matchedPattern")) { + //noinspection DataFlowIssue + entityData.codeNameIndex = (int) field.getObject(); + return true; + } + // Typically do not experience any drastic changes in field names or types + // If this becomes a recurrent issue, should create a method that takes FieldContext + // and override on any necessary classes + return false; + } + + @Override + public boolean missingField(Object object, Field field) throws StreamCorruptedException { + return object instanceof EntityData; + } + + @Override + public boolean incompatibleField(Object object, Field field, FieldContext context) throws StreamCorruptedException { + return false; + } + }); } public static void onRegistrationStop() { @@ -853,11 +884,6 @@ public void deserialize(Fields fields) throws StreamCorruptedException, NotSeria fields.setFields(this); } - @Deprecated(since = "2.3.0", forRemoval = true) - protected boolean deserialize(String string) { - return false; - } - @Override public @NotNull String getSyntaxTypeName() { return "entity data"; diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index 5bdb66a6f30..4d50d5dbb99 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -1,6 +1,8 @@ local function compareData(data1: entity types, data2: entity types): loop {_data1::*}: + set {testDataSave} to loop-value + clear {testDataSave} if loop-value is spawnable: spawn (loop-value) at test-location: set {_entity} to event-entity From 0ea837c45787582a6ff52ada33dc9d638e96baa5 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Tue, 8 Jul 2025 03:07:20 -0400 Subject: [PATCH 20/21] Massive Fixes/Changes --- .../skript/classes/data/BukkitClasses.java | 16 + .../ch/njol/skript/entity/AxolotlData.java | 7 +- .../java/ch/njol/skript/entity/BeeData.java | 8 +- .../ch/njol/skript/entity/CreeperData.java | 4 +- .../njol/skript/entity/DroppedItemData.java | 28 +- .../java/ch/njol/skript/entity/FoxData.java | 7 +- .../java/ch/njol/skript/entity/FrogData.java | 4 +- .../java/ch/njol/skript/entity/GoatData.java | 4 +- .../java/ch/njol/skript/entity/LlamaData.java | 11 +- .../ch/njol/skript/entity/MinecartData.java | 4 +- .../ch/njol/skript/entity/MooshroomData.java | 7 +- .../ch/njol/skript/entity/ParrotData.java | 7 +- .../java/ch/njol/skript/entity/PigData.java | 4 +- .../ch/njol/skript/entity/RabbitData.java | 7 +- .../ch/njol/skript/entity/SalmonData.java | 7 +- .../java/ch/njol/skript/entity/SheepData.java | 4 +- .../ch/njol/skript/entity/StriderData.java | 4 +- .../njol/skript/entity/TropicalFishData.java | 8 +- .../ch/njol/skript/entity/VillagerData.java | 4 +- .../java/ch/njol/skript/entity/WolfData.java | 8 +- .../skript/entity/ZombieVillagerData.java | 4 +- .../java/ch/njol/skript/util/Patterns.java | 55 +- .../java/ch/njol/skript/util/SkriptColor.java | 2 + .../njol/yggdrasil/SimpleClassResolver.java | 28 +- src/main/resources/lang/default.lang | 7 + src/test/skript/tests/misc/EntityData.sk | 1209 +++++++++++++++-- 26 files changed, 1219 insertions(+), 239 deletions(-) diff --git a/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java b/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java index d860e5dc169..efa8e1d918e 100644 --- a/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java +++ b/src/main/java/ch/njol/skript/classes/data/BukkitClasses.java @@ -1632,6 +1632,22 @@ public String toVariableNameString(WorldBorder border) { .since("2.12") ); + ClassInfo frogVariantClassInfo = getRegistryClassInfo( + "org.bukkit.entity.Frog$Variant", + "FROG_VARIANT", + "frogvariant", + "frog variants" + ); + assert frogVariantClassInfo != null; + Classes.registerClass(frogVariantClassInfo + .user("frog ?variants?") + .name("Frog Variant") + .description("Represents the variant of a frog entity.", + "NOTE: Minecraft namespaces are supported, ex: 'minecraft:warm'.") + .since("INSERT VERSION") + .documentationId("FrogVariant") + ); + } /** diff --git a/src/main/java/ch/njol/skript/entity/AxolotlData.java b/src/main/java/ch/njol/skript/entity/AxolotlData.java index 6d48e642d4b..dd983950198 100644 --- a/src/main/java/ch/njol/skript/entity/AxolotlData.java +++ b/src/main/java/ch/njol/skript/entity/AxolotlData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Axolotl; import org.bukkit.entity.Axolotl.Variant; @@ -25,6 +26,8 @@ public class AxolotlData extends EntityData { static { EntityData.register(AxolotlData.class, "axolotl", Axolotl.class, 0, PATTERNS.getPatterns()); + + Variables.yggdrasil.registerSingleClass(Variant.class, "Axolotl.Variant"); } private @Nullable Variant variant = null; @@ -33,7 +36,7 @@ public AxolotlData() {} public AxolotlData(@Nullable Variant variant) { this.variant = variant; - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } @Override @@ -46,7 +49,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Axolotl axolotl) { if (axolotl != null) { variant = axolotl.getVariant(); - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/BeeData.java b/src/main/java/ch/njol/skript/entity/BeeData.java index c8b0cac5cef..50c901790a1 100644 --- a/src/main/java/ch/njol/skript/entity/BeeData.java +++ b/src/main/java/ch/njol/skript/entity/BeeData.java @@ -39,18 +39,18 @@ public BeeData() {} public BeeData(@Nullable Kleenean isAngry, @Nullable Kleenean hasNectar) { this.isAngry = isAngry != null ? isAngry : Kleenean.UNKNOWN; this.hasNectar = hasNectar != null ? hasNectar : Kleenean.UNKNOWN; - super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(this.isAngry, this.hasNectar), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(this.isAngry, this.hasNectar), 0).orElse(0); } public BeeData(@Nullable BeeState beeState) { if (beeState != null) { this.isAngry = beeState.angry; this.hasNectar = beeState.nectar; - super.codeNameIndex = PATTERNS.getMatchedPattern(beeState, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(beeState, 0).orElse(0); } else { this.isAngry = Kleenean.UNKNOWN; this.hasNectar = Kleenean.UNKNOWN; - super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(Kleenean.UNKNOWN, Kleenean.UNKNOWN), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(Kleenean.UNKNOWN, Kleenean.UNKNOWN), 0).orElse(0); } } @@ -68,7 +68,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable Bee if (bee != null) { isAngry = Kleenean.get(bee.getAnger() > 0); hasNectar = Kleenean.get(bee.hasNectar()); - super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(isAngry, hasNectar), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new BeeState(isAngry, hasNectar), 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/CreeperData.java b/src/main/java/ch/njol/skript/entity/CreeperData.java index cfaace08b31..932216bc9dc 100644 --- a/src/main/java/ch/njol/skript/entity/CreeperData.java +++ b/src/main/java/ch/njol/skript/entity/CreeperData.java @@ -28,7 +28,7 @@ public CreeperData() {} public CreeperData(@Nullable Kleenean powered) { this.powered = powered != null ? powered : Kleenean.UNKNOWN; - super.codeNameIndex = PATTERNS.getMatchedPattern(this.powered, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(this.powered, 0).orElse(0); } @Override @@ -41,7 +41,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Creeper creeper) { if (creeper != null) { powered = Kleenean.get(creeper.isPowered()); - super.codeNameIndex = PATTERNS.getMatchedPattern(powered, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(powered, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/DroppedItemData.java b/src/main/java/ch/njol/skript/entity/DroppedItemData.java index f83fc834a3c..0e05efe7efe 100644 --- a/src/main/java/ch/njol/skript/entity/DroppedItemData.java +++ b/src/main/java/ch/njol/skript/entity/DroppedItemData.java @@ -36,7 +36,7 @@ public class DroppedItemData extends EntityData { private final static Adjective m_adjective = new Adjective("entities.dropped item.adjective"); - private ItemType @Nullable [] types; + private ItemType @Nullable [] types = null; public DroppedItemData() {} @@ -67,7 +67,18 @@ protected boolean init(@Nullable Class entityClass, @Nullable It } return true; } - + + @Override + public void set(Item item) { + if (types == null) + return; + ItemType itemType = CollectionUtils.getRandom(types); + assert itemType != null; + ItemStack stack = itemType.getItem().getRandom(); + assert stack != null; // should be true by init checks + item.setItemStack(stack); + } + @Override protected boolean match(Item item) { if (types != null) { @@ -79,18 +90,7 @@ protected boolean match(Item item) { } return true; } - - @Override - public void set(Item item) { - if (types == null) - return; - ItemType itemType = CollectionUtils.getRandom(types); - assert itemType != null; - ItemStack stack = itemType.getItem().getRandom(); - assert stack != null; // should be true by init checks - item.setItemStack(stack); - } - + @Override public Class getType() { return Item.class; diff --git a/src/main/java/ch/njol/skript/entity/FoxData.java b/src/main/java/ch/njol/skript/entity/FoxData.java index 89610d1615c..0162e92a421 100644 --- a/src/main/java/ch/njol/skript/entity/FoxData.java +++ b/src/main/java/ch/njol/skript/entity/FoxData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Fox; import org.bukkit.entity.Fox.Type; @@ -22,6 +23,8 @@ public class FoxData extends EntityData { static { EntityData.register(FoxData.class, "fox", Fox.class, 0, PATTERNS.getPatterns()); + + Variables.yggdrasil.registerSingleClass(Type.class, "Fox.Type"); } private @Nullable Type type = null; @@ -30,7 +33,7 @@ public FoxData() {} public FoxData(@Nullable Type type) { this.type = type; - super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0).orElse(0); } @Override @@ -43,7 +46,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Fox fox) { if (fox != null) { type = fox.getFoxType(); - super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/FrogData.java b/src/main/java/ch/njol/skript/entity/FrogData.java index 5d5daf1e556..3f2a8cfc369 100644 --- a/src/main/java/ch/njol/skript/entity/FrogData.java +++ b/src/main/java/ch/njol/skript/entity/FrogData.java @@ -34,7 +34,7 @@ public FrogData() {} public FrogData(@Nullable Variant variant) { this.variant = variant; - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } @Override @@ -47,7 +47,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Frog frog) { if (frog != null) { variant = frog.getVariant(); - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/GoatData.java b/src/main/java/ch/njol/skript/entity/GoatData.java index 03777616d5a..75540f1fa34 100644 --- a/src/main/java/ch/njol/skript/entity/GoatData.java +++ b/src/main/java/ch/njol/skript/entity/GoatData.java @@ -28,7 +28,7 @@ public GoatData() {} public GoatData(@Nullable Kleenean screaming) { this.screaming = screaming != null ? screaming : Kleenean.UNKNOWN; - super.codeNameIndex = PATTERNS.getMatchedPattern(this.screaming, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(this.screaming, 0).orElse(0); } @Override @@ -41,7 +41,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Goat goat) { if (goat != null) { screaming = Kleenean.get(goat.isScreaming()); - super.codeNameIndex = PATTERNS.getMatchedPattern(screaming, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(screaming, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/LlamaData.java b/src/main/java/ch/njol/skript/entity/LlamaData.java index 2f19fc8bb6e..5bc314cbc51 100644 --- a/src/main/java/ch/njol/skript/entity/LlamaData.java +++ b/src/main/java/ch/njol/skript/entity/LlamaData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Llama; import org.bukkit.entity.Llama.Color; @@ -32,6 +33,8 @@ public record LlamaState(Color color, boolean trader) {} static { EntityData.register(LlamaData.class, "llama", Llama.class, 0, PATTERNS.getPatterns()); + + Variables.yggdrasil.registerSingleClass(Color.class, "Llama.Color"); } private @Nullable Color color = null; @@ -42,18 +45,18 @@ public LlamaData() {} public LlamaData(@Nullable Color color, boolean isTrader) { this.color = color; this.isTrader = isTrader; - super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(color, isTrader), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(color, isTrader), 0).orElse(0); } public LlamaData(@Nullable LlamaState llamaState) { if (llamaState != null) { this.color = llamaState.color; this.isTrader = llamaState.trader; - super.codeNameIndex = PATTERNS.getMatchedPattern(llamaState, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(llamaState, 0).orElse(0); } else { this.color = null; this.isTrader = false; - super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(null, false), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(null, false), 0).orElse(0); } } @@ -73,7 +76,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable L if (llama != null) { color = llama.getColor(); isTrader = llama instanceof TraderLlama; - super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(color, isTrader), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new LlamaState(color, isTrader), 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/MinecartData.java b/src/main/java/ch/njol/skript/entity/MinecartData.java index 6c5ca718f87..2c1cd94d622 100644 --- a/src/main/java/ch/njol/skript/entity/MinecartData.java +++ b/src/main/java/ch/njol/skript/entity/MinecartData.java @@ -58,7 +58,7 @@ public MinecartData() {} public MinecartData(@Nullable MinecartType type) { this.type = type != null ? type : MinecartType.ANY; - super.codeNameIndex = PATTERNS.getMatchedPattern(this.type, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(this.type, 0).orElse(0); } @Override @@ -80,7 +80,7 @@ protected boolean init(@Nullable Class entityClass, @Nullabl } if (this.type == null) this.type = MinecartType.ANY; - super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0).orElse(0); return true; } diff --git a/src/main/java/ch/njol/skript/entity/MooshroomData.java b/src/main/java/ch/njol/skript/entity/MooshroomData.java index 8f169f4a4b7..a96b850b4a5 100644 --- a/src/main/java/ch/njol/skript/entity/MooshroomData.java +++ b/src/main/java/ch/njol/skript/entity/MooshroomData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.MushroomCow; import org.bukkit.entity.MushroomCow.Variant; @@ -22,6 +23,8 @@ public class MooshroomData extends EntityData { static { EntityData.register(MooshroomData.class, "mooshroom", MushroomCow.class, 0, PATTERNS.getPatterns()); + + Variables.yggdrasil.registerSingleClass(Variant.class, "MushroomCow.Variant"); } private @Nullable Variant variant = null; @@ -30,7 +33,7 @@ public MooshroomData() {} public MooshroomData(@Nullable Variant variant) { this.variant = variant; - super.codeNameIndex = PATTERNS.getMatchedPattern(variant,0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } @Override @@ -43,7 +46,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable MushroomCow mushroomCow) { if (mushroomCow != null) { variant = mushroomCow.getVariant(); - super.codeNameIndex = PATTERNS.getMatchedPattern(variant,0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/ParrotData.java b/src/main/java/ch/njol/skript/entity/ParrotData.java index 06a49bf50da..06fa99cd0d8 100644 --- a/src/main/java/ch/njol/skript/entity/ParrotData.java +++ b/src/main/java/ch/njol/skript/entity/ParrotData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Parrot; import org.bukkit.entity.Parrot.Variant; @@ -24,6 +25,8 @@ public class ParrotData extends EntityData { static { EntityData.register(ParrotData.class, "parrot", Parrot.class, 0, PATTERNS.getPatterns()); + + Variables.yggdrasil.registerSingleClass(Variant.class, "Parrot.Variant"); } private @Nullable Variant variant = null; @@ -32,7 +35,7 @@ public ParrotData() {} public ParrotData(@Nullable Variant variant) { this.variant = variant; - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } @Override @@ -45,7 +48,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Parrot parrot) { if (parrot != null) { variant = parrot.getVariant(); - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/PigData.java b/src/main/java/ch/njol/skript/entity/PigData.java index d917b00e131..b0ebea586e2 100644 --- a/src/main/java/ch/njol/skript/entity/PigData.java +++ b/src/main/java/ch/njol/skript/entity/PigData.java @@ -44,7 +44,7 @@ public PigData() {} public PigData(@Nullable Kleenean saddled, @Nullable Object variant) { this.saddled = saddled != null ? saddled : Kleenean.UNKNOWN; this.variant = variant; - super.codeNameIndex = PATTERNS.getMatchedPattern(this.saddled, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(this.saddled, 0).orElse(0); } @Override @@ -61,7 +61,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Pig pig) { if (pig != null) { saddled = Kleenean.get(pig.hasSaddle()); - super.codeNameIndex = PATTERNS.getMatchedPattern(saddled, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(saddled, 0).orElse(0); if (VARIANTS_ENABLED) variant = pig.getVariant(); } diff --git a/src/main/java/ch/njol/skript/entity/RabbitData.java b/src/main/java/ch/njol/skript/entity/RabbitData.java index 3b7c917f05b..25a79be4d12 100644 --- a/src/main/java/ch/njol/skript/entity/RabbitData.java +++ b/src/main/java/ch/njol/skript/entity/RabbitData.java @@ -3,6 +3,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Rabbit; import org.bukkit.entity.Rabbit.Type; @@ -26,6 +27,8 @@ public class RabbitData extends EntityData { static { EntityData.register(RabbitData.class, "rabbit", Rabbit.class, 0, PATTERNS.getPatterns()); + + Variables.yggdrasil.registerSingleClass(Type.class, "Rabbit.Type"); } private @Nullable Type type = null; @@ -34,7 +37,7 @@ public RabbitData() {} public RabbitData(@Nullable Type type) { this.type = type; - super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0).orElse(0); } @Override @@ -47,7 +50,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Rabbit rabbit) { if (rabbit != null) { type = rabbit.getRabbitType(); - super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(type, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/SalmonData.java b/src/main/java/ch/njol/skript/entity/SalmonData.java index 2215a2c86fe..0eb1d0787f5 100644 --- a/src/main/java/ch/njol/skript/entity/SalmonData.java +++ b/src/main/java/ch/njol/skript/entity/SalmonData.java @@ -4,6 +4,7 @@ import ch.njol.skript.lang.Literal; import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.entity.Salmon; import org.bukkit.entity.Salmon.Variant; @@ -26,6 +27,8 @@ public class SalmonData extends EntityData { {"medium salmon", Variant.MEDIUM}, {"large salmon", Variant.LARGE} }); + + Variables.yggdrasil.registerSingleClass(Variant.class, "Salmon.Variant"); } else { VARIANTS = null; PATTERNS = new Patterns<>(new Object[][]{ @@ -43,7 +46,7 @@ public SalmonData() {} // TODO: When safe, 'variant' should have the type changed to 'Salmon.Variant' when 1.21.2 is minimum supported version public SalmonData(@Nullable Object variant) { this.variant = variant; - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } @Override @@ -56,7 +59,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Salmon salmon) { if (salmon != null && SUPPORT_SALMON_VARIANTS) { variant = salmon.getVariant(); - super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(variant, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/SheepData.java b/src/main/java/ch/njol/skript/entity/SheepData.java index 9d95affb1f2..41cf072338e 100644 --- a/src/main/java/ch/njol/skript/entity/SheepData.java +++ b/src/main/java/ch/njol/skript/entity/SheepData.java @@ -38,7 +38,7 @@ public SheepData() {} public SheepData(@Nullable Kleenean sheared, Color @Nullable [] colors) { this.sheared = sheared != null ? sheared : Kleenean.UNKNOWN; this.colors = colors; - super.codeNameIndex = PATTERNS.getMatchedPattern(this.sheared, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(this.sheared, 0).orElse(0); } @Override @@ -56,7 +56,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable S if (sheep != null) { sheared = Kleenean.get(sheep.isSheared()); colors = CollectionUtils.array(SkriptColor.fromDyeColor(sheep.getColor())); - super.codeNameIndex = PATTERNS.getMatchedPattern(sheared, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(sheared, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/StriderData.java b/src/main/java/ch/njol/skript/entity/StriderData.java index 51868a49dbf..f3a886f40d1 100644 --- a/src/main/java/ch/njol/skript/entity/StriderData.java +++ b/src/main/java/ch/njol/skript/entity/StriderData.java @@ -28,7 +28,7 @@ public StriderData() {} public StriderData(@Nullable Kleenean shivering) { this.shivering = shivering != null ? shivering : Kleenean.UNKNOWN; - super.codeNameIndex = PATTERNS.getMatchedPattern(this.shivering, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(this.shivering, 0).orElse(0); } @Override @@ -41,7 +41,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable Strider strider) { if (strider != null) { shivering = Kleenean.get(strider.isShivering()); - super.codeNameIndex = PATTERNS.getMatchedPattern(shivering, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(shivering, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/TropicalFishData.java b/src/main/java/ch/njol/skript/entity/TropicalFishData.java index 641db9b10b0..59ac84b0f39 100644 --- a/src/main/java/ch/njol/skript/entity/TropicalFishData.java +++ b/src/main/java/ch/njol/skript/entity/TropicalFishData.java @@ -4,6 +4,7 @@ import ch.njol.skript.lang.SkriptParser.ParseResult; import ch.njol.skript.util.Color; import ch.njol.skript.util.Patterns; +import ch.njol.skript.variables.Variables; import ch.njol.util.coll.CollectionUtils; import org.bukkit.DyeColor; import org.bukkit.entity.TropicalFish; @@ -34,6 +35,9 @@ public class TropicalFishData extends EntityData { static { register(TropicalFishData.class, "tropical fish", TropicalFish.class, 0, PATTERNS.getPatterns()); + + Variables.yggdrasil.registerSingleClass(Pattern.class, "TropicalFish.Pattern"); + Variables.yggdrasil.registerSingleClass(DyeColor.class, "DyeColor"); } private @Nullable DyeColor bodyColor = null; @@ -46,7 +50,7 @@ public TropicalFishData(@Nullable Pattern fishPattern, @Nullable DyeColor bodyCo this.fishPattern = fishPattern; this.bodyColor = bodyColor; this.patternColor = patternColor; - super.codeNameIndex = PATTERNS.getMatchedPattern(fishPattern, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(fishPattern, 0).orElse(0); } @Override @@ -79,7 +83,7 @@ protected boolean init(@Nullable Class entityClass, @Nul bodyColor = tropicalFish.getBodyColor(); patternColor = tropicalFish.getPatternColor(); fishPattern = tropicalFish.getPattern(); - super.codeNameIndex = PATTERNS.getMatchedPattern(fishPattern, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(fishPattern, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/VillagerData.java b/src/main/java/ch/njol/skript/entity/VillagerData.java index 96c36306cd2..d2e2eacc9ef 100644 --- a/src/main/java/ch/njol/skript/entity/VillagerData.java +++ b/src/main/java/ch/njol/skript/entity/VillagerData.java @@ -56,7 +56,7 @@ public VillagerData() {} public VillagerData(@Nullable Profession profession) { this.profession = profession; - super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0).orElse(0); } @Override @@ -69,7 +69,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class villagerClass, @Nullable Villager villager) { if (villager != null) { profession = villager.getProfession(); - super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/WolfData.java b/src/main/java/ch/njol/skript/entity/WolfData.java index 1522f71983b..90811c94c72 100644 --- a/src/main/java/ch/njol/skript/entity/WolfData.java +++ b/src/main/java/ch/njol/skript/entity/WolfData.java @@ -52,18 +52,18 @@ public WolfData() {} public WolfData(@Nullable Kleenean isAngry, @Nullable Kleenean isTamed) { this.isAngry = isAngry != null ? isAngry : Kleenean.UNKNOWN; this.isTamed = isTamed != null ? isTamed : Kleenean.UNKNOWN; - super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(this.isAngry, this.isTamed), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(this.isAngry, this.isTamed), 0).orElse(0); } public WolfData(@Nullable WolfStates wolfState) { if (wolfState != null) { this.isAngry = wolfState.angry; this.isTamed = wolfState.tamed; - super.codeNameIndex = PATTERNS.getMatchedPattern(wolfState, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(wolfState, 0).orElse(0); } else { this.isAngry = Kleenean.UNKNOWN; this.isTamed = Kleenean.UNKNOWN; - super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(Kleenean.UNKNOWN, Kleenean.UNKNOWN), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(Kleenean.UNKNOWN, Kleenean.UNKNOWN), 0).orElse(0); } } @@ -92,7 +92,7 @@ protected boolean init(@Nullable Class entityClass, @Nullable Wo collarColor = wolf.getCollarColor(); if (VARIANTS_ENABLED) variant = wolf.getVariant(); - super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(isAngry, isTamed), 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(new WolfStates(isAngry, isTamed), 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java index 151e04cce6b..73b1a30d1f4 100644 --- a/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java +++ b/src/main/java/ch/njol/skript/entity/ZombieVillagerData.java @@ -48,7 +48,7 @@ public ZombieVillagerData() {} public ZombieVillagerData(@Nullable Profession profession) { this.profession = profession; - super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0).orElse(0); } @Override @@ -61,7 +61,7 @@ protected boolean init(Literal[] exprs, int matchedCodeName, int matchedPatte protected boolean init(@Nullable Class entityClass, @Nullable ZombieVillager zombieVillager) { if (zombieVillager != null) { profession = zombieVillager.getVillagerProfession(); - super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0); + super.codeNameIndex = PATTERNS.getMatchedPattern(profession, 0).orElse(0); } return true; } diff --git a/src/main/java/ch/njol/skript/util/Patterns.java b/src/main/java/ch/njol/skript/util/Patterns.java index 641bae4333a..8d175105ea0 100644 --- a/src/main/java/ch/njol/skript/util/Patterns.java +++ b/src/main/java/ch/njol/skript/util/Patterns.java @@ -66,10 +66,14 @@ public String[] getPatterns() { } /** - * Gets all pattern indices that correlate to {@code type}. + * Retrieves all pattern indices that are associated with {@code type}. + *

+ * These indices represent the positions of matched patterns registered + * for the provided typed object. + *

* - * @param type The typed object. - * @return An array of pattern indices. + * @param type The typed object to look up. + * @return An array of matched pattern indices, or {@code null} if no patterns are registered for the given type. */ public Integer @Nullable [] getMatchedPatterns(@Nullable T type) { Optional optional = Optional.ofNullable(type); @@ -79,37 +83,24 @@ public String[] getPatterns() { } /** - * Gets an {@link java.lang.reflect.Array} of all patterns - * registered to {@code type} and the index of the pattern using {@code placement}. - * If there are no patterns registered to {@code type} or the array size is less than {@code placement} - * returns {@code 0}. + * Retrieves the index of a specific matched pattern for the give {@code type}, based on the provided {@code arrayIndex}. + *

+ * This method looks up all matched pattern indices for the specified type and returns the index at {@code arrayIndex}, + * if it exists. + *

* - * @param type The typed object to grab all patterns registered to. - * @param placement The placement of the array for the index of the pattern. - * @return The index of the pattern or {@code 0} if no registered patterns for {@code type} - * or array size is less than {@code placement}. + * @param type The object whose registered patterns should be retrieved. + * @param arrayIndex The position in the matched pattern array to retrieve/ + * @return An {@link Optional} containing the matched pattern index at the specified position, + * or {@link Optional#empty()} if no patterns are registered for {@code type} + * or if the array does not contain enough elements. + * @see #getMatchedPatterns(Object) */ - public int getMatchedPattern(@Nullable T type, int placement) { - return getMatchedPattern(type, placement, 0); - } - - /** - * Gets an {@link java.lang.reflect.Array} of all patterns - * registered to {@code type} and the index of the pattern using {@code placement}. - * If there are no patterns registered to {@code type} or the array size is less than {@code placement} - * returns {@code fallback}. - * - * @param type The typed object to grab all patterns registered to. - * @param placement The placement of the array for the index of the pattern. - * @param fallback The value to fall back to. - * @return The index of the pattern or {@code null} if no registered patterns for {@code type} - * or array size is less than {@code placement}. - */ - public int getMatchedPattern(@Nullable T type, int placement, int fallback) { - Integer[] placements = getMatchedPatterns(type); - if (placements == null || placements.length < placement + 1) - return fallback; - return placements[placement]; + public Optional getMatchedPattern(@Nullable T type, int arrayIndex) { + Integer[] patternIndices = getMatchedPatterns(type); + if (patternIndices == null || patternIndices.length < arrayIndex + 1) + return Optional.empty(); + return Optional.of(patternIndices[arrayIndex]); } } diff --git a/src/main/java/ch/njol/skript/util/SkriptColor.java b/src/main/java/ch/njol/skript/util/SkriptColor.java index e17a7e3175a..cbfd4714cbc 100644 --- a/src/main/java/ch/njol/skript/util/SkriptColor.java +++ b/src/main/java/ch/njol/skript/util/SkriptColor.java @@ -61,6 +61,8 @@ public enum SkriptColor implements Color { BY_CHAR.put(color.asChatColor().getChar(), color); } }); + + Variables.yggdrasil.registerSingleClass(SkriptColor.class, "SkriptColor"); } private ChatColor chat; diff --git a/src/main/java/ch/njol/yggdrasil/SimpleClassResolver.java b/src/main/java/ch/njol/yggdrasil/SimpleClassResolver.java index 77eeff99653..ee0dceaa1b4 100644 --- a/src/main/java/ch/njol/yggdrasil/SimpleClassResolver.java +++ b/src/main/java/ch/njol/yggdrasil/SimpleClassResolver.java @@ -5,28 +5,38 @@ import org.jetbrains.annotations.Nullable; import javax.annotation.concurrent.NotThreadSafe; +import java.util.Map.Entry; @NotThreadSafe public class SimpleClassResolver implements ClassResolver { - + private final BiMap, String> classes = HashBiMap.create(); - + public void registerClass(Class type, String id) { String oldId = classes.put(type, id); if (oldId != null && !oldId.equals(id)) throw new YggdrasilException("Changed id of " + type + " from " + oldId + " to " + id); } - + @Override - @Nullable - public Class getClass(String id) { + public @Nullable Class getClass(String id) { return classes.inverse().get(id); } - + @Override - @Nullable - public String getID(Class type) { - return classes.get(type); + public @Nullable String getID(Class type) { + if (classes.containsKey(type)) + return classes.get(type); + Class closestClass = null; + String closestId = null; + for (Entry, String> entry : classes.entrySet()) { + Class current = entry.getClass(); + if (current.isAssignableFrom(type) && (closestClass == null || closestClass.isAssignableFrom(current))) { + closestClass = current; + closestId = entry.getValue(); + } + } + return closestId; } } diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang index bd2ef015411..532d875335e 100644 --- a/src/main/resources/lang/default.lang +++ b/src/main/resources/lang/default.lang @@ -2939,6 +2939,12 @@ cow variants: temperate: temperate warm: warm +# -- Frog Variants -- +frog variants: + cold: cold + temperate: temperate + warm: warm + # -- Villager Career Change Reasons villager career change reasons: employed: employment @@ -3113,6 +3119,7 @@ types: villagercareerchangereason: villager career change reason¦s @a damagesource: damage source¦s @a damagetype: damage type¦s @a + frogvariant: frog variant¦s @a # Skript weathertype: weather type¦s @a diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index 4d50d5dbb99..4390b63080c 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -1,8 +1,6 @@ local function compareData(data1: entity types, data2: entity types): loop {_data1::*}: - set {testDataSave} to loop-value - clear {testDataSave} if loop-value is spawnable: spawn (loop-value) at test-location: set {_entity} to event-entity @@ -15,215 +13,1146 @@ local function compareData(data1: entity types, data2: entity types): clear entity within {_entity} clear {_entity} +local function setSuperTypes(data: entity types): + set {-SuperTypes::*} to {_data::*} + +local function testData(data: entity type): + set {testDataSave} to {_data} # Ensure serialization does not error + clear {testDataSave} + if {_data} is spawnable: + spawn {_data} at test-location: + set {_entity} to entity + assert {_entity} is set with "Could not spawn '%{_data}%" + assert {_entity} is {_data} with "Spawned '%{_data}%' should match against its own EntityData" + loop {-SuperTypes::*}: + assert {_data} is loop-value with "EntityData '%{_data}%' should match against EntityData '%loop-value%'" + if {_entity} is set: + assert {_entity} is loop-value with "Spawned '%{_data}%' should match against EntityData '%loop-value%'" + clear entity within {_entity} + + test "axolotl data": - compareData((axolotl, lucy axolotl, wild axolotl, gold axolotl, cyan axolotl, blue axolotl) , (axolotl)) - compareData((baby axolotl, baby lucy axolotl, baby wild axolotl, baby gold axolotl, baby cyan axolotl, baby blue axolotl) , (axolotl, baby axolotl)) - compareData((adult axolotl, adult lucy axolotl, adult wild axolotl, adult gold axolotl, adult cyan axolotl, adult blue axolotl) , (axolotl, adult axolotl)) - compareData((axolotl kid, lucy axolotl kid, wild axolotl kid, gold axolotl kid, cyan axolotl kid, blue axolotl kid) , (axolotl, axolotl kid, baby axolotl)) + setSuperTypes(axolotl) + testData(axolotl) + testData(lucy axolotl) + testData(wild axolotl) + testData(gold axolotl) + testData(cyan axolotl) + testData(blue axolotl) + + setSuperTypes(axolotl, baby axolotl) + testData(baby axolotl) + testData(baby lucy axolotl) + testData(baby wild axolotl) + testData(baby gold axolotl) + testData(baby cyan axolotl) + testData(baby blue axolotl) + + setSuperTypes(axolotl, adult axolotl) + testData(adult axolotl) + testData(adult lucy axolotl) + testData(adult wild axolotl) + testData(adult gold axolotl) + testData(adult cyan axolotl) + testData(adult blue axolotl) + + setSuperTypes(axolotl, axolotl kid, baby axolotl) + testData(axolotl kid) + testData(lucy axolotl kid) + testData(wild axolotl kid) + testData(gold axolotl kid) + testData(cyan axolotl kid) + testData(blue axolotl kid) test "bee data": - compareData((bee, bee without nectar, bee with nectar, happy bee, happy bee with nectar, happy bee without nectar, angry bee, angry bee without nectar, angry bee with nectar) , (bee)) - compareData((baby bee, baby bee without nectar, baby bee with nectar, baby happy bee, baby happy bee with nectar, baby happy bee without nectar, baby angry bee, baby angry bee without nectar, baby angry bee with nectar) , (bee, baby bee)) - compareData((adult bee, adult bee without nectar, adult bee with nectar, adult happy bee, adult happy bee with nectar, adult happy bee without nectar, adult angry bee, adult angry bee without nectar, adult angry bee with nectar) , (bee, adult bee)) - compareData((bee with nectar, angry bee with nectar, happy bee with nectar), (bee with nectar)) - compareData((bee without nectar, angry bee without nectar, happy bee without nectar), (bee without nectar)) - compareData((happy bee, happy bee with nectar, happy bee without nectar), (happy bee)) - compareData((angry bee, angry bee with nectar, angry bee without nectar) , (angry bee)) + setSuperTypes(bee) + testData(bee) + testData(bee without nectar) + testData(bee with nectar) + testData(happy bee) + testData(happy bee without nectar) + testData(happy bee with nectar) + testData(angry bee) + testData(angry bee without nectar) + testData(angry bee with nectar) + + setSuperTypes(bee, baby bee) + testData(baby bee) + testData(baby bee without nectar) + testData(baby bee with nectar) + testData(baby happy bee) + testData(baby happy bee without nectar) + testData(baby happy bee with nectar) + testData(baby angry bee) + testData(baby angry bee without nectar) + testData(baby angry bee with nectar) + + setSuperTypes(bee, adult bee) + testData(adult bee) + testData(adult bee without nectar) + testData(adult bee with nectar) + testData(adult happy bee) + testData(adult happy bee without nectar) + testData(adult happy bee with nectar) + testData(adult angry bee) + testData(adult angry bee without nectar) + testData(adult angry bee with nectar) + + setSuperTypes(bee with nectar) + testData(bee with nectar) + testData(happy bee with nectar) + testData(angry bee with nectar) + + setSuperTypes(bee without nectar) + testData(bee without nectar) + testData(happy bee without nectar) + testData(angry bee without nectar) + + setSuperTypes(happy bee) + testData(happy bee) + testData(happy bee without nectar) + testData(happy bee with nectar) + + setSuperTypes(angry bee) + testData(angry bee) + testData(angry bee without nectar) + testData(angry bee with nectar) test "boat data": - compareData((chest boat, acacia chest boat, bamboo chest boat, birch chest boat, cherry chest boat, dark oak chest boat, jungle chest boat, mangrove chest boat, oak chest boat, spruce chest boat) , (any chest boat)) + setSuperTypes(any chest boat) + testData(chest boat) + testData(acacia chest boat) + testData(bamboo chest boat) + testData(birch chest boat) + testData(cherry chest boat) + testData(dark oak chest boat) + testData(jungle chest boat) + testData(mangrove chest boat) + testData(oak chest boat) + testData(spruce chest boat) parse if running minecraft "1.21.2": - compareData((pale oak chest boat), (any chest boat)) + testData(pale oak chest boat) test "boat data": - compareData((boat, acacia boat, bamboo boat, birch boat, cherry boat, dark oak boat, jungle boat, mangrove boat, oak boat, spruce boat) , (any boat)) + setSuperTypes(any boat) + testData(boat) + testData(acacia boat) + testData(bamboo boat) + testData(birch boat) + testData(cherry boat) + testData(dark oak boat) + testData(jungle boat) + testData(mangrove boat) + testData(oak boat) + testData(spruce boat) parse if running minecraft "1.21.2": - compareData((pale oak boat), (any boat)) + testData(pale oak boat) test "cat data": - compareData((cat, tabby cat, black cat, red cat, siamese cat, british shorthair cat, calico cat, persian cat, ragdoll cat, white cat, jellie cat, all black cat) , (cat)) - compareData((baby cat, baby tabby cat, baby black cat, baby red cat, baby siamese cat, baby british shorthair cat, baby calico cat, baby persian cat, baby ragdoll cat, baby white cat, baby jellie cat, baby all black cat) , (cat, baby cat)) - compareData((adult cat, adult tabby cat, adult black cat, adult red cat, adult siamese cat, adult british shorthair cat, adult calico cat, adult persian cat, adult ragdoll cat, adult white cat, adult jellie cat, adult all black cat) , (cat, adult cat)) - compareData((tamed ocelot, tamed baby ocelot, tamed adult ocelot) , (cat)) - compareData((tamed baby ocelot) , (cat, baby cat)) - compareData((tamed adult ocelot) , (cat, adult cat)) - compareData((kitten, tabby kitten, black kitten, red kitten, siamese kitten, british shorthair kitten, calico kitten, persian kitten, ragdoll kitten, white kitten, jellie kitten, all black kitten) , (cat, kitten, baby cat)) + setSuperTypes(cat) + testData(cat) + testData(tabby cat) + testData(black cat) + testData(red cat) + testData(siamese cat) + testData(british shorthair cat) + testData(calico cat) + testData(persian cat) + testData(ragdoll cat) + testData(white cat) + testData(jellie cat) + testData(all black cat) + + setSuperTypes(cat, baby cat) + testData(baby cat) + testData(baby tabby cat) + testData(baby black cat) + testData(baby red cat) + testData(baby siamese cat) + testData(baby british shorthair cat) + testData(baby calico cat) + testData(baby persian cat) + testData(baby ragdoll cat) + testData(baby white cat) + testData(baby jellie cat) + testData(baby all black cat) + + setSuperTypes(cat, adult cat) + testData(adult cat) + testData(adult tabby cat) + testData(adult black cat) + testData(adult red cat) + testData(adult siamese cat) + testData(adult british shorthair cat) + testData(adult calico cat) + testData(adult persian cat) + testData(adult ragdoll cat) + testData(adult white cat) + testData(adult jellie cat) + testData(adult all black cat) + + setSuperTypes(cat) + testData(tamed ocelot) + testData(tamed baby ocelot) + testData(tamed adult ocelot) + + setSuperTypes(cat, baby cat) + testData(tamed baby ocelot) + + setSuperTypes(cat, adult cat) + testData(tamed adult ocelot) + + setSuperTypes(cat, kitten, baby cat) + testData(kitten) + testData(tabby kitten) + testData(black kitten) + testData(red kitten) + testData(siamese kitten) + testData(british shorthair kitten) + testData(calico kitten) + testData(persian kitten) + testData(ragdoll kitten) + testData(white kitten) + testData(jellie kitten) + testData(all black kitten) test "chicken data": - compareData((chicken, baby chicken, adult chicken, chick) , (chicken)) + setSuperTypes(chicken) + testData(chicken) + testData(baby chicken) + testData(adult chicken) + testData(chick) parse if running minecraft "1.21.6": - compareData((chicken, warm chicken, temperate chicken, cold chicken) , (chicken)) - compareData((baby chicken, baby warm chicken, baby temperate chicken, baby cold chicken) , (chicken, baby chicken)) - compareData((adult chicken, adult warm chicken, adult temperate chicken, adult cold chicken) , (chicken, adult chicken)) - compareData((chick, warm chick, temperate chick, cold chick) , (chicken, chick, baby chicken)) + setSuperTypes(chicken) + testData(chicken) + testData(warm chicken) + testData(temperate chicken) + testData(cold chicken) + + setSuperTypes(chicken, baby chicken) + testData(baby chicken) + testData(baby warm chicken) + testData(baby temperate chicken) + testData(baby cold chicken) + + setSuperTypes(chicken, adult chicken) + testData(adult chicken) + testData(adult warm chicken) + testData(adult temperate chicken) + testData(adult cold chicken) + + setSuperTypes(chicken, chick, baby chicken) + testData(chick) + testData(warm chick) + testData(temperate chick) + testData(cold chick) test "cow data": - compareData((cow, baby cow, adult cow, calf) , (cow)) + setSuperTypes(cow) + testData(cow) + testData(baby cow) + testData(adult cow) + testData(calf) parse if running minecraft "1.21.6": - compareData((cow, warm cow, temperate cow, cold cow) , (cow)) - compareData((baby cow, baby warm cow, baby temperate cow, baby cold cow) , (cow, baby cow)) - compareData((adult cow, adult warm cow, adult temperate cow, adult cold cow) , (cow, adult cow)) - compareData((calf, warm calf, temperate calf, cold calf) , (cow, calf, baby cow)) + setSuperTypes(cow) + testData(cow) + testData(warm cow) + testData(temperate cow) + testData(cold cow) + + setSuperTypes(cow, baby cow) + testData(baby cow) + testData(baby warm cow) + testData(baby temperate cow) + testData(baby cold cow) + + setSuperTypes(cow, adult cow) + testData(adult cow) + testData(adult warm cow) + testData(adult temperate cow) + testData(adult cold cow) + + setSuperTypes(cow, calf, baby cow) + testData(calf) + testData(warm calf) + testData(temperate calf) + testData(cold calf) test "creeper data": - compareData((creeper, powered creeper, unpowered creeper) , (creeper)) + setSuperTypes(creeper) + testData(creeper) + testData(powered creeper) + testData(unpowered creeper) test "dropped item data": - compareData((dropped item, dropped item entity, dropped stone) , (dropped item, dropped item entity)) + setSuperTypes(dropped item, dropped item entity) + testData(dropped item entity) + testData(dropped stone) test "enderman data": - compareData((enderman, enderman holding stone) , (enderman)) + setSuperTypes(enderman) + testData(enderman) + testData(enderman holding stone) test "falling block data": - compareData((falling block, falling sand) , (falling block)) + setSuperTypes(falling block) + testData(falling block) + testData(falling sand) test "fox data": - compareData((fox, red fox, snow fox) , (fox)) - compareData((baby fox, baby red fox, baby snow fox) , (fox, baby fox)) - compareData((adult fox, adult red fox, adult snow fox) , (fox, adult fox)) - compareData((fox kid, red fox kid, snow fox kid) , (fox, fox kid, baby fox)) + setSuperTypes(fox) + testData(fox) + testData(red fox) + testData(snow fox) + + setSuperTypes(fox, baby fox) + testData(baby fox) + testData(baby red fox) + testData(baby snow fox) + + setSuperTypes(fox, adult fox) + testData(adult fox) + testData(adult red fox) + testData(adult snow fox) + + setSuperTypes(fox, fox kid, baby fox) + testData(fox kid) + testData(red fox kid) + testData(snow fox kid) test "frog data": - compareData((frog, warm frog, temperate frog, cold frog) , (frog)) - compareData((baby frog, baby warm frog, baby temperate frog, baby cold frog) , (frog, baby frog)) - compareData((adult frog, adult warm frog, adult temperate frog, adult cold frog) , (frog, adult frog)) - compareData((frog kid, warm frog kid, temperate frog kid, cold frog kid) , (frog, frog kid, baby frog)) + setSuperTypes(frog) + testData(frog) + testData(warm frog) + testData(temperate frog) + testData(cold frog) + + setSuperTypes(frog, baby frog) + testData(baby frog) + testData(baby warm frog) + testData(baby temperate frog) + testData(baby cold frog) + + setSuperTypes(frog, adult frog) + testData(adult frog) + testData(adult warm frog) + testData(adult temperate frog) + testData(adult cold frog) + + setSuperTypes(frog, frog kid, baby frog) + testData(frog kid) + testData(warm frog kid) + testData(temperate frog kid) + testData(cold frog kid) test "goat data": - compareData((goat, screaming goat, quiet goat) , (goat)) - compareData((baby goat, baby screaming goat, baby quiet goat) , (goat, baby goat)) - compareData((adult goat, adult screaming goat, adult quiet goat) , (goat, adult goat)) - compareData((goat kid, screaming goat kid, quiet goat kid) , (goat, goat kid, baby goat)) + setSuperTypes(goat) + testData(goat) + testData(screaming goat) + testData(quiet goat) + + setSuperTypes(goat, baby goat) + testData(baby goat) + testData(baby screaming goat) + testData(baby quiet goat) + + setSuperTypes(goat, adult goat) + testData(adult goat) + testData(adult screaming goat) + testData(adult quiet goat) + + setSuperTypes(goat, goat kid, baby goat) + testData(goat kid) + testData(screaming goat kid) + testData(quiet goat kid) test "llama data": - compareData((llama, creamy llama, white llama, brown llama, gray llama, trader llama, creamy trader llama, white trader llama, brown trader llama, gray trader llama) , (llama)) - compareData((baby llama, baby creamy llama, baby white llama, baby brown llama, baby gray llama, baby trader llama, baby creamy trader llama, baby white trader llama, baby brown trader llama, baby gray trader llama) , (llama, baby llama)) - compareData((adult llama, adult creamy llama, adult white llama, adult brown llama, adult gray llama, adult trader llama, adult creamy trader llama, adult white trader llama, adult brown trader llama, adult gray trader llama) , (llama, adult llama)) - compareData((llama cria, creamy llama cria, white llama cria, brown llama cria, gray llama cria, trader llama cria, creamy trader llama cria, white trader llama cria, brown trader llama cria, gray trader llama cria) , (llama, llama cria, baby llama)) + setSuperTypes(llama) + testData(llama) + testData(creamy llama) + testData(white llama) + testData(brown llama) + testData(gray llama) + testData(trader llama) + testData(creamy trader llama) + testData(white trader llama) + testData(brown trader llama) + testData(gray trader llama) + + setSuperTypes(llama, baby llama) + testData(baby llama) + testData(baby creamy llama) + testData(baby white llama) + testData(baby brown llama) + testData(baby gray llama) + testData(baby trader llama) + testData(baby creamy trader llama) + testData(baby white trader llama) + testData(baby brown trader llama) + testData(baby gray trader llama) + + setSuperTypes(llama, adult llama) + testData(adult llama) + testData(adult creamy llama) + testData(adult white llama) + testData(adult brown llama) + testData(adult gray llama) + testData(adult trader llama) + testData(adult creamy trader llama) + testData(adult white trader llama) + testData(adult brown trader llama) + testData(adult gray trader llama) + + setSuperTypes(llama, llama cria, baby llama) + testData(llama cria) + testData(creamy llama cria) + testData(white llama cria) + testData(brown llama cria) + testData(gray llama cria) + testData(trader llama cria) + testData(creamy trader llama cria) + testData(white trader llama cria) + testData(brown trader llama cria) + testData(gray trader llama cria) + + setSuperTypes(trader llama) + testData(trader llama) + testData(creamy trader llama) + testData(white trader llama) + testData(brown trader llama) + testData(gray trader llama) - compareData((trader llama, creamy trader llama, white trader llama, brown trader llama, gray trader llama) , (trader llama)) - compareData((baby trader llama, baby creamy trader llama, baby white trader llama, baby brown trader llama, baby gray trader llama) , (trader llama, baby trader llama)) - compareData((adult trader llama, adult creamy trader llama, adult white trader llama, adult brown trader llama, adult gray trader llama) , (trader llama, adult trader llama)) - compareData((trader llama cria, creamy trader llama cria, white trader llama cria, brown trader llama cria, gray trader llama cria) , (trader llama, trader llama cria, baby trader llama)) + setSuperTypes(trader llama, baby trader llama) + testData(baby trader llama) + testData(baby creamy trader llama) + testData(baby white trader llama) + testData(baby brown trader llama) + testData(baby gray trader llama) - compareData((creamy llama, baby creamy llama, creamy llama cria, creamy trader llama, baby creamy trader llama, creamy trader llama cria) , (creamy llama)) - compareData((white llama, baby white llama, white llama cria, white trader llama, baby white trader llama, white trader llama cria) , (white llama)) - compareData((brown llama, baby brown llama, brown llama cria, brown trader llama, baby brown trader llama, brown trader llama cria) , (brown llama)) - compareData((gray llama, baby gray llama, gray llama cria, gray trader llama, baby gray trader llama, gray trader llama cria) , (gray llama)) + setSuperTypes(trader llama, adult trader llama) + testData(adult trader llama) + testData(adult creamy trader llama) + testData(adult white trader llama) + testData(adult brown trader llama) + testData(adult gray trader llama) + + setSuperTypes(trader llama, trader llama cria, baby trader llama) + testData(trader llama cria) + testData(creamy trader llama cria) + testData(white trader llama cria) + testData(brown trader llama cria) + testData(gray trader llama cria) + + setSuperTypes(creamy llama) + testData(creamy llama) + testData(baby creamy llama) + testData(creamy llama cria) + testData(creamy trader llama) + testData(baby creamy trader llama) + testData(creamy trader llama cria) + + setSuperTypes(white llama) + testData(white llama) + testData(baby white llama) + testData(white llama cria) + testData(white trader llama) + testData(baby white trader llama) + testData(white trader llama cria) + + setSuperTypes(brown llama) + testData(brown llama) + testData(baby brown llama) + testData(brown llama cria) + testData(brown trader llama) + testData(baby brown trader llama) + testData(brown trader llama cria) + + setSuperTypes(gray llama) + testData(gray llama) + testData(baby gray llama) + testData(gray llama cria) + testData(gray trader llama) + testData(baby gray trader llama) + testData(gray trader llama cria) test "minecart data": - compareData((minecart, regular minecart, minecart with chest, minecart with furnace, minecart with hopper, minecart with tnt, minecart with spawner, minecart with command block) , (minecart)) + setSuperTypes(minecart) + testData(minecart) + testData(regular minecart) + testData(minecart with chest) + testData(minecart with furnace) + testData(minecart with hopper) + testData(minecart with tnt) + testData(minecart with spawner) + testData(minecart with command block) test "mooshroom data": - compareData((mooshroom, red mooshroom, brown mooshroom) , (mooshroom)) - compareData((baby mooshroom, baby red mooshroom, baby brown mooshroom) , (mooshroom, baby mooshroom)) - compareData((adult mooshroom, adult red mooshroom, adult brown mooshroom) , (mooshroom, adult mooshroom)) - compareData((mooshroom calf, red mooshroom calf, brown mooshroom calf) , (mooshroom, mooshroom calf, baby mooshroom)) - compareData((mooshroom kid, red mooshroom kid, brown mooshroom kid) , (mooshroom, mooshroom calf, baby mooshroom, mooshroom kid)) + setSuperTypes(mooshroom) + testData(mooshroom) + testData(red mooshroom) + testData(brown mooshroom) + + setSuperTypes(mooshroom, baby mooshroom) + testData(baby mooshroom) + testData(baby red mooshroom) + testData(baby brown mooshroom) + + setSuperTypes(mooshroom, adult mooshroom) + testData(adult mooshroom) + testData(adult red mooshroom) + testData(adult brown mooshroom) + + setSuperTypes(mooshroom, mooshroom calf, baby mooshroom) + testData(mooshroom calf) + testData(red mooshroom calf) + testData(brown mooshroom calf) + + setSuperTypes(mooshroom, mooshroom calf, baby mooshroom, mooshroom kid) + testData(mooshroom kid) + testData(red mooshroom kid) + testData(brown mooshroom kid) test "panda data": - compareData((panda, normal panda, lazy panda, worried panda, playful panda, brown panda, weak panda, aggressive panda) , (panda)) - compareData((normal-normal panda, normal-lazy panda, normal-worried panda, normal-playful panda, normal-brown panda, normal-weak panda, normal-aggressive panda) , (panda, normal panda)) - compareData((lazy-normal panda, lazy-lazy panda, lazy-worried panda, lazy-playful panda, lazy-brown panda, lazy-weak panda, lazy-aggressive panda) , (panda, lazy panda)) - compareData((worried-normal panda, worried-lazy panda, worried-worried panda, worried-playful panda, worried-brown panda, worried-weak panda, worried-aggressive panda) , (panda, worried panda)) - compareData((playful-normal panda, playful-lazy panda, playful-worried panda, playful-playful panda, playful-brown panda, playful-weak panda, playful-aggressive panda) , (panda, playful panda)) - compareData((brown-normal panda, brown-lazy panda, brown-worried panda, brown-playful panda, brown-brown panda, brown-weak panda, brown-aggressive panda) , (panda, brown panda)) - compareData((weak-normal panda, weak-lazy panda, weak-worried panda, weak-playful panda, weak-brown panda, weak-weak panda, weak-aggressive panda) , (panda, weak panda)) - compareData((aggressive-normal panda, aggressive-lazy panda, aggressive-worried panda, aggressive-playful panda, aggressive-brown panda, aggressive-weak panda, aggressive-aggressive panda) , (panda, aggressive panda)) - - compareData((baby panda, baby normal panda, baby lazy panda, baby worried panda, baby playful panda, baby brown panda, baby weak panda, baby aggressive panda) , (panda, baby panda)) - compareData((baby normal-normal panda, baby normal-lazy panda, baby normal-worried panda, baby normal-playful panda, baby normal-brown panda, baby normal-weak panda, baby normal-aggressive panda) , (panda, normal panda, baby panda, baby normal panda)) - compareData((baby lazy-normal panda, baby lazy-lazy panda, baby lazy-worried panda, baby lazy-playful panda, baby lazy-brown panda, baby lazy-weak panda, baby lazy-aggressive panda) , (panda, lazy panda, baby panda, baby lazy panda)) - compareData((baby worried-normal panda, baby worried-lazy panda, baby worried-worried panda, baby worried-playful panda, baby worried-brown panda, baby worried-weak panda, baby worried-aggressive panda) , (panda, worried panda, baby panda, baby worried panda)) - compareData((baby playful-normal panda, baby playful-lazy panda, baby playful-worried panda, baby playful-playful panda, baby playful-brown panda, baby playful-weak panda, baby playful-aggressive panda) , (panda, playful panda, baby panda, baby playful panda)) - compareData((baby brown-normal panda, baby brown-lazy panda, baby brown-worried panda, baby brown-playful panda, baby brown-brown panda, baby brown-weak panda, baby brown-aggressive panda) , (panda, brown panda, baby panda, baby brown panda)) - compareData((baby weak-normal panda, baby weak-lazy panda, baby weak-worried panda, baby weak-playful panda, baby weak-brown panda, baby weak-weak panda, baby weak-aggressive panda) , (panda, weak panda, baby panda, baby weak panda)) - compareData((baby aggressive-normal panda, baby aggressive-lazy panda, baby aggressive-worried panda, baby aggressive-playful panda, baby aggressive-brown panda, baby aggressive-weak panda, baby aggressive-aggressive panda) , (panda, aggressive panda, baby panda, baby aggressive panda)) - - compareData((adult panda, adult normal panda, adult lazy panda, adult worried panda, adult playful panda, adult brown panda, adult weak panda, adult aggressive panda) , (panda, adult panda)) - compareData((adult normal-normal panda, adult normal-lazy panda, adult normal-worried panda, adult normal-playful panda, adult normal-brown panda, adult normal-weak panda, adult normal-aggressive panda) , (panda, normal panda, adult panda, adult normal panda)) - compareData((adult lazy-normal panda, adult lazy-lazy panda, adult lazy-worried panda, adult lazy-playful panda, adult lazy-brown panda, adult lazy-weak panda, adult lazy-aggressive panda) , (panda, lazy panda, adult panda, adult lazy panda)) - compareData((adult worried-normal panda, adult worried-lazy panda, adult worried-worried panda, adult worried-playful panda, adult worried-brown panda, adult worried-weak panda, adult worried-aggressive panda) , (panda, worried panda, adult panda, adult worried panda)) - compareData((adult playful-normal panda, adult playful-lazy panda, adult playful-worried panda, adult playful-playful panda, adult playful-brown panda, adult playful-weak panda, adult playful-aggressive panda) , (panda, playful panda, adult panda, adult playful panda)) - compareData((adult brown-normal panda, adult brown-lazy panda, adult brown-worried panda, adult brown-playful panda, adult brown-brown panda, adult brown-weak panda, adult brown-aggressive panda) , (panda, brown panda, adult panda, adult brown panda)) - compareData((adult weak-normal panda, adult weak-lazy panda, adult weak-worried panda, adult weak-playful panda, adult weak-brown panda, adult weak-weak panda, adult weak-aggressive panda) , (panda, weak panda, adult panda, adult weak panda)) - compareData((adult aggressive-normal panda, adult aggressive-lazy panda, adult aggressive-worried panda, adult aggressive-playful panda, adult aggressive-brown panda, adult aggressive-weak panda, adult aggressive-aggressive panda) , (panda, aggressive panda, adult panda, adult aggressive panda)) + setSuperTypes(panda) + testData(panda) + testData(normal panda) + testData(lazy panda) + testData(worried panda) + testData(playful panda) + testData(brown panda) + testData(weak panda) + testData(aggressive panda) + + setSuperTypes(panda, normal panda) + testData(normal-normal panda) + testData(normal-lazy panda) + testData(normal-worried panda) + testData(normal-playful panda) + testData(normal-brown panda) + testData(normal-weak panda) + testData(normal-aggressive panda) + + setSuperTypes(panda, lazy panda) + testData(lazy-normal panda) + testData(lazy-lazy panda) + testData(lazy-worried panda) + testData(lazy-playful panda) + testData(lazy-brown panda) + testData(lazy-weak panda) + testData(lazy-aggressive panda) + + setSuperTypes(panda, worried panda) + testData(worried-normal panda) + testData(worried-lazy panda) + testData(worried-worried panda) + testData(worried-playful panda) + testData(worried-brown panda) + testData(worried-weak panda) + testData(worried-aggressive panda) + + setSuperTypes(panda, playful panda) + testData(playful-normal panda) + testData(playful-lazy panda) + testData(playful-worried panda) + testData(playful-playful panda) + testData(playful-brown panda) + testData(playful-weak panda) + testData(playful-aggressive panda) + + setSuperTypes(panda, brown panda) + testData(brown-normal panda) + testData(brown-lazy panda) + testData(brown-worried panda) + testData(brown-playful panda) + testData(brown-brown panda) + testData(brown-weak panda) + testData(brown-aggressive panda) + + setSuperTypes(panda, weak panda) + testData(weak-normal panda) + testData(weak-lazy panda) + testData(weak-worried panda) + testData(weak-playful panda) + testData(weak-brown panda) + testData(weak-weak panda) + testData(weak-aggressive panda) + + setSuperTypes(panda, aggressive panda) + testData(aggressive-normal panda) + testData(aggressive-lazy panda) + testData(aggressive-worried panda) + testData(aggressive-playful panda) + testData(aggressive-brown panda) + testData(aggressive-weak panda) + testData(aggressive-aggressive panda) + + setSuperTypes(panda, baby panda) + testData(baby panda) + testData(baby normal panda) + testData(baby lazy panda) + testData(baby worried panda) + testData(baby playful panda) + testData(baby brown panda) + testData(baby weak panda) + testData(baby aggressive panda) + + setSuperTypes(panda, normal panda, baby panda, baby normal panda) + testData(baby normal-normal panda) + testData(baby normal-lazy panda) + testData(baby normal-worried panda) + testData(baby normal-playful panda) + testData(baby normal-brown panda) + testData(baby normal-weak panda) + testData(baby normal-aggressive panda) + + setSuperTypes(panda, lazy panda, baby panda, baby lazy panda) + testData(baby lazy-normal panda) + testData(baby lazy-lazy panda) + testData(baby lazy-worried panda) + testData(baby lazy-playful panda) + testData(baby lazy-brown panda) + testData(baby lazy-weak panda) + testData(baby lazy-aggressive panda) + + setSuperTypes(panda, worried panda, baby panda, baby worried panda) + testData(baby worried-normal panda) + testData(baby worried-lazy panda) + testData(baby worried-worried panda) + testData(baby worried-playful panda) + testData(baby worried-brown panda) + testData(baby worried-weak panda) + testData(baby worried-aggressive panda) + + setSuperTypes(panda, playful panda, baby panda, baby playful panda) + testData(baby playful-normal panda) + testData(baby playful-lazy panda) + testData(baby playful-worried panda) + testData(baby playful-playful panda) + testData(baby playful-brown panda) + testData(baby playful-weak panda) + testData(baby playful-aggressive panda) + + setSuperTypes(panda, brown panda, baby panda, baby brown panda) + testData(baby brown-normal panda) + testData(baby brown-lazy panda) + testData(baby brown-worried panda) + testData(baby brown-playful panda) + testData(baby brown-brown panda) + testData(baby brown-weak panda) + testData(baby brown-aggressive panda) + + setSuperTypes(panda, weak panda, baby panda, baby weak panda) + testData(baby weak-normal panda) + testData(baby weak-lazy panda) + testData(baby weak-worried panda) + testData(baby weak-playful panda) + testData(baby weak-brown panda) + testData(baby weak-weak panda) + testData(baby weak-aggressive panda) + + setSuperTypes(panda, aggressive panda, baby panda, baby aggressive panda) + testData(baby aggressive-normal panda) + testData(baby aggressive-lazy panda) + testData(baby aggressive-worried panda) + testData(baby aggressive-playful panda) + testData(baby aggressive-brown panda) + testData(baby aggressive-weak panda) + testData(baby aggressive-aggressive panda) + + setSuperTypes(panda, adult panda) + testData(adult panda) + testData(adult normal panda) + testData(adult lazy panda) + testData(adult worried panda) + testData(adult playful panda) + testData(adult brown panda) + testData(adult weak panda) + testData(adult aggressive panda) + + setSuperTypes(panda, normal panda, adult panda, adult normal panda) + testData(adult normal-normal panda) + testData(adult normal-lazy panda) + testData(adult normal-worried panda) + testData(adult normal-playful panda) + testData(adult normal-brown panda) + testData(adult normal-weak panda) + testData(adult normal-aggressive panda) + + setSuperTypes(panda, lazy panda, adult panda, adult lazy panda) + testData(adult lazy-normal panda) + testData(adult lazy-lazy panda) + testData(adult lazy-worried panda) + testData(adult lazy-playful panda) + testData(adult lazy-brown panda) + testData(adult lazy-weak panda) + testData(adult lazy-aggressive panda) + + setSuperTypes(panda, worried panda, adult panda, adult worried panda) + testData(adult worried-normal panda) + testData(adult worried-lazy panda) + testData(adult worried-worried panda) + testData(adult worried-playful panda) + testData(adult worried-brown panda) + testData(adult worried-weak panda) + testData(adult worried-aggressive panda) + + setSuperTypes(panda, playful panda, adult panda, adult playful panda) + testData(adult playful-normal panda) + testData(adult playful-lazy panda) + testData(adult playful-worried panda) + testData(adult playful-playful panda) + testData(adult playful-brown panda) + testData(adult playful-weak panda) + testData(adult playful-aggressive panda) + + setSuperTypes(panda, brown panda, adult panda, adult brown panda) + testData(adult brown-normal panda) + testData(adult brown-lazy panda) + testData(adult brown-worried panda) + testData(adult brown-playful panda) + testData(adult brown-brown panda) + testData(adult brown-weak panda) + testData(adult brown-aggressive panda) + + setSuperTypes(panda, weak panda, adult panda, adult weak panda) + testData(adult weak-normal panda) + testData(adult weak-lazy panda) + testData(adult weak-worried panda) + testData(adult weak-playful panda) + testData(adult weak-brown panda) + testData(adult weak-weak panda) + testData(adult weak-aggressive panda) + + setSuperTypes(panda, aggressive panda, adult panda, adult aggressive panda) + testData(adult aggressive-normal panda) + testData(adult aggressive-lazy panda) + testData(adult aggressive-worried panda) + testData(adult aggressive-playful panda) + testData(adult aggressive-brown panda) + testData(adult aggressive-weak panda) + testData(adult aggressive-aggressive panda) test "parrot data": - compareData((parrot, red parrot, blue parrot, green parrot, cyan parrot, gray parrot) , (parrot)) + setSuperTypes(parrot) + testData(parrot) + testData(red parrot) + testData(blue parrot) + testData(green parrot) + testData(cyan parrot) + testData(gray parrot) test "pig data": - compareData((pig, saddled pig, unsaddled pig) , (pig)) - compareData((baby pig, adult pig), (pig)) - compareData((piglet), (pig, baby pig)) + setSuperTypes(pig) + testData(pig) + testData(saddled pig) + testData(unsaddled pig) + + setSuperTypes(pig) + testData(baby pig) + testData(adult pig) + + setSuperTypes(pig, baby pig) + testData(piglet) parse if running minecraft "1.21.5": - compareData((warm pig, warm saddled pig, warm unsaddled pig) , (pig, warm pig)) - compareData((temperate pig, temperate saddled pig, temperate unsaddled pig) , (pig, temperate pig)) - compareData((cold pig, cold saddled pig, cold unsaddled pig) , (pig, cold pig)) - compareData((warm baby pig, temperate baby pig, cold baby pig) , (pig, baby pig)) - compareData((warm adult pig, temperate adult pig, cold adult pig) , (pig, adult pig)) - compareData((warm piglet, temperate piglet, cold piglet) , (pig, piglet, baby pig)) + setSuperTypes(pig, warm pig) + testData(warm pig) + testData(warm saddled pig) + testData(warm unsaddled pig) + + setSuperTypes(pig, temperate pig) + testData(temperate pig) + testData(temperate saddled pig) + testData(temperate unsaddled pig) + + setSuperTypes(pig, cold pig) + testData(cold pig) + testData(cold saddled pig) + testData(cold unsaddled pig) - compareData((saddled warm pig, saddled temperate pig, saddled cold pig) , (pig, saddled pig)) - compareData((unsaddled warm pig, unsaddled temperate pig, unsaddled cold pig) , (pig, unsaddled pig)) + setSuperTypes(pig, baby pig) + testData(warm baby pig) + testData(temperate baby pig) + testData(cold baby pig) + + setSuperTypes(pig, adult pig) + testData(warm adult pig) + testData(temperate adult pig) + testData(cold adult pig) + + setSuperTypes(pig, piglet, baby pig) + testData(warm piglet) + testData(temperate piglet) + testData(cold piglet) + + setSuperTypes(pig, saddled pig) + testData(saddled warm pig) + testData(saddled temperate pig) + testData(saddled cold pig) + + setSuperTypes(pig, unsaddled pig) + testData(unsaddled warm pig) + testData(unsaddled temperate pig) + testData(unsaddled cold pig) test "rabbit data": - compareData((rabbit, white rabbit, black rabbit, black white rabbit, brown rabbit, gold rabbit, salt pepper rabbit, killer rabbit) , (rabbit)) - compareData((baby rabbit, baby white rabbit, baby black rabbit, baby black white rabbit, baby brown rabbit, baby gold rabbit, baby salt pepper rabbit, baby killer rabbit) , (rabbit, baby rabbit)) - compareData((adult rabbit, adult white rabbit, adult black rabbit, adult black white rabbit, adult brown rabbit, adult gold rabbit, adult salt pepper rabbit, adult killer rabbit) , (rabbit, adult rabbit)) + setSuperTypes(rabbit) + testData(rabbit) + testData(white rabbit) + testData(black rabbit) + testData(black white rabbit) + testData(brown rabbit) + testData(gold rabbit) + testData(salt pepper rabbit) + testData(killer rabbit) + + setSuperTypes(rabbit, baby rabbit) + testData(baby rabbit) + testData(baby white rabbit) + testData(baby black rabbit) + testData(baby black white rabbit) + testData(baby brown rabbit) + testData(baby gold rabbit) + testData(baby salt pepper rabbit) + testData(baby killer rabbit) + + setSuperTypes(rabbit, adult rabbit) + testData(adult rabbit) + testData(adult white rabbit) + testData(adult black rabbit) + testData(adult black white rabbit) + testData(adult brown rabbit) + testData(adult gold rabbit) + testData(adult salt pepper rabbit) + testData(adult killer rabbit) test "salmon data" when running minecraft "1.21.2": - compareData((salmon, small salmon, medium salmon, large salmon) , (any salmon)) + setSuperTypes(any salmon) + testData(salmon) + testData(small salmon) + testData(medium salmon) + testData(large salmon) test "sheep data": - compareData((sheep, unsheared sheep, sheared sheep) , (sheep)) - compareData((red sheep, red unsheared sheep, red sheared sheep) , (red sheep)) + setSuperTypes(sheep) + testData(sheep) + testData(unsheared sheep) + testData(sheared sheep) + + setSuperTypes(red sheep) + testData(red sheep) + testData(red unsheared sheep) + testData(red sheared sheep) test "strider data": - compareData((strider, warm strider, cold strider) , (strider)) - compareData((baby strider, baby warm strider, baby cold strider) , (strider, baby strider)) + setSuperTypes(strider) + testData(strider) + testData(warm strider) + testData(cold strider) + + setSuperTypes(strider, baby strider) + testData(baby strider) + testData(baby warm strider) + testData(baby cold strider) test "thrown potion data": - compareData((thrown potion, thrown speed potion) , (thrown potion)) + setSuperTypes(thrown potion) + testData(thrown potion) + testData(thrown speed potion) test "tropical fish data": - compareData((tropical fish, kob, sunstreak, snooper, dasher, brinely, spotty, flopper, stripey, glitter, blockfish, betty, clayfish) , (tropical fish)) - compareData((red tropical fish, red kob, red sunstreak, red snooper, red dasher, red brinely, red spotty, red flopper, red stripey, red glitter, red blockfish, red betty, red clayfish) , (tropical fish, red tropical fish)) - compareData((red-blue tropical fish, red-blue kob, red-blue sunstreak, red-blue snooper, red-blue dasher, red-blue brinely, red-blue spotty, red-blue flopper, red-blue stripey, red-blue glitter, red-blue blockfish, red-blue betty, red-blue clayfish) , (tropical fish, red tropical fish, red-blue tropical fish)) + setSuperTypes(tropical fish) + testData(tropical fish) + testData(kob) + testData(sunstreak) + testData(snooper) + testData(dasher) + testData(brinely) + testData(spotty) + testData(flopper) + testData(stripey) + testData(glitter) + testData(blockfish) + testData(betty) + testData(clayfish) + + setSuperTypes(tropical fish, red tropical fish) + testData(red tropical fish) + testData(red kob) + testData(red sunstreak) + testData(red snooper) + testData(red dasher) + testData(red brinely) + testData(red spotty) + testData(red flopper) + testData(red stripey) + testData(red glitter) + testData(red blockfish) + testData(red betty) + testData(red clayfish) + + setSuperTypes(tropical fish, red tropical fish, red-blue tropical fish) + testData(red-blue tropical fish) + testData(red-blue kob) + testData(red-blue sunstreak) + testData(red-blue snooper) + testData(red-blue dasher) + testData(red-blue brinely) + testData(red-blue spotty) + testData(red-blue flopper) + testData(red-blue stripey) + testData(red-blue glitter) + testData(red-blue blockfish) + testData(red-blue betty) + testData(red-blue clayfish) test "villager data": - compareData((villager, jobless villager, armorer, cartographer, cleric, fisherman, fletcher, mason, shepherd, toolsmith, weaponsmith, farmer, librarian, butcher, nitwit) , (villager)) - compareData((baby villager, baby jobless villager, baby armorer, baby cartographer, baby cleric, baby fisherman, baby fletcher, baby mason, baby shepherd, baby toolsmith, baby weaponsmith, baby farmer, baby librarian, baby butcher, baby nitwit) , (villager, baby villager)) - compareData((adult villager, adult jobless villager, adult armorer, adult cartographer, adult cleric, adult fisherman, adult fletcher, adult mason, adult shepherd, adult toolsmith, adult weaponsmith, adult farmer, adult librarian, adult butcher, adult nitwit) , (villager, adult villager)) + setSuperTypes(villager) + testData(villager) + testData(jobless villager) + testData(armorer) + testData(cartographer) + testData(cleric) + testData(fisherman) + testData(fletcher) + testData(mason) + testData(shepherd) + testData(toolsmith) + testData(weaponsmith) + testData(farmer) + testData(librarian) + testData(butcher) + testData(nitwit) + + setSuperTypes(villager, baby villager) + testData(baby villager) + testData(baby jobless villager) + testData(baby armorer) + testData(baby cartographer) + testData(baby cleric) + testData(baby fisherman) + testData(baby fletcher) + testData(baby mason) + testData(baby shepherd) + testData(baby toolsmith) + testData(baby weaponsmith) + testData(baby farmer) + testData(baby librarian) + testData(baby butcher) + testData(baby nitwit) + + setSuperTypes(villager, adult villager) + testData(adult villager) + testData(adult jobless villager) + testData(adult armorer) + testData(adult cartographer) + testData(adult cleric) + testData(adult fisherman) + testData(adult fletcher) + testData(adult mason) + testData(adult shepherd) + testData(adult toolsmith) + testData(adult weaponsmith) + testData(adult farmer) + testData(adult librarian) + testData(adult butcher) + testData(adult nitwit) test "wolf data": - compareData((wolf, dog, tamed wolf, wild wolf, angry wolf, peaceful wolf) , (wolf)) - compareData((baby wolf, baby dog, tamed baby wolf, pup, wild baby wolf, angry baby wolf, peaceful baby wolf) , (wolf, baby wolf)) - compareData((adult wolf, adult dog, tamed adult wolf, wild adult wolf, angry adult wolf, peaceful adult wolf) , (wolf, adult wolf)) + setSuperTypes(wolf) + testData(wolf) + testData(dog) + testData(tamed wolf) + testData(wild wolf) + testData(angry wolf) + testData(peaceful wolf) - compareData((wolf color red, dog color red, tamed wolf color red, wild wolf color red, angry wolf color red, peaceful wolf color red) , (wolf, wolf color red)) - compareData((baby wolf color red, baby dog color red, tamed baby wolf color red, pup color red, wild baby wolf color red, angry baby wolf color red, peaceful baby wolf color red) , (wolf color red, baby wolf color red)) - compareData((adult wolf color red, adult dog color red, tamed adult wolf color red, wild adult wolf color red, angry adult wolf color red, peaceful adult wolf color red) , (wolf color red, adult wolf color red)) + setSuperTypes(wolf, baby wolf) + testData(baby wolf) + testData(baby dog) + testData(tamed baby wolf) + testData(pup) + testData(wild baby wolf) + testData(angry baby wolf) + testData(peaceful baby wolf) + + setSuperTypes(wolf, adult wolf) + testData(adult wolf) + testData(adult dog) + testData(tamed adult wolf) + testData(wild adult wolf) + testData(angry adult wolf) + testData(peaceful adult wolf) + + setSuperTypes(wolf, wolf color red) + testData(wolf color red) + testData(dog color red) + testData(tamed wolf color red) + testData(wild wolf color red) + testData(angry wolf color red) + testData(peaceful wolf color red) + + setSuperTypes(wolf color red, baby wolf color red) + testData(baby wolf color red) + testData(baby dog color red) + testData(tamed baby wolf color red) + testData(pup color red) + testData(wild baby wolf color red) + testData(angry baby wolf color red) + testData(peaceful baby wolf color red) + + setSuperTypes(wolf color red, adult wolf color red) + testData(adult wolf color red) + testData(adult dog color red) + testData(tamed adult wolf color red) + testData(wild adult wolf color red) + testData(angry adult wolf color red) + testData(peaceful adult wolf color red) parse if running minecraft "1.20.6": - compareData((ashen wolf, black wolf, chestnut wolf, pale wolf, rusty wolf, snowy wolf, spotted wolf, striped wolf, woods wolf) , (wolf)) - compareData((baby ashen wolf, baby black wolf, baby chestnut wolf, baby pale wolf, baby rusty wolf, baby snowy wolf, baby spotted wolf, baby striped wolf, baby woods wolf) , (wolf, baby wolf)) - compareData((adult ashen wolf, adult black wolf, adult chestnut wolf, adult pale wolf, adult rusty wolf, adult snowy wolf, adult spotted wolf, adult striped wolf, adult woods wolf) , (wolf, adult wolf)) + setSuperTypes(wolf) + testData(ashen wolf) + testData(black wolf) + testData(chestnut wolf) + testData(pale wolf) + testData(rusty wolf) + testData(snowy wolf) + testData(spotted wolf) + testData(striped wolf) + testData(woods wolf) + + setSuperTypes(wolf, baby wolf) + testData(baby ashen wolf) + testData(baby black wolf) + testData(baby chestnut wolf) + testData(baby pale wolf) + testData(baby rusty wolf) + testData(baby snowy wolf) + testData(baby spotted wolf) + testData(baby striped wolf) + testData(baby woods wolf) + + setSuperTypes(wolf, adult wolf) + testData(adult ashen wolf) + testData(adult black wolf) + testData(adult chestnut wolf) + testData(adult pale wolf) + testData(adult rusty wolf) + testData(adult snowy wolf) + testData(adult spotted wolf) + testData(adult striped wolf) + testData(adult woods wolf) - compareData((ashen wolf, ashen dog, tamed ashen wolf, wild ashen wolf, angry ashen wolf, peaceful ashen wolf) , (wolf, ashen wolf)) - compareData((baby ashen wolf, baby ashen dog, tamed baby ashen wolf, ashen pup, wild baby ashen wolf, angry baby ashen wolf, peaceful baby ashen wolf) , (wolf, ashen wolf, baby wolf, baby ashen wolf)) + setSuperTypes(wolf, ashen wolf) + testData(ashen wolf) + testData(ashen dog) + testData(tamed ashen wolf) + testData(wild ashen wolf) + testData(angry ashen wolf) + testData(peaceful ashen wolf) - compareData((ashen wolf color red, ashen dog color red, tamed ashen wolf color red, wild ashen wolf color red, angry ashen wolf color red, peaceful ashen wolf color red) , (wolf, ashen wolf, wolf color red, ashen wolf color red)) - compareData((baby ashen wolf color red, baby ashen dog color red, tamed baby ashen wolf color red, ashen pup color red, wild baby ashen wolf color red, angry baby ashen wolf color red, peaceful baby ashen wolf color red) , (wolf, ashen wolf, baby wolf, baby ashen wolf, wolf color red, ashen wolf color red, baby wolf color red, baby ashen wolf color red)) + setSuperTypes(wolf, ashen wolf, baby wolf, baby ashen wolf) + testData(baby ashen wolf) + testData(baby ashen dog) + testData(tamed baby ashen wolf) + testData(ashen pup) + testData(wild baby ashen wolf) + testData(angry baby ashen wolf) + testData(peaceful baby ashen wolf) + + setSuperTypes(wolf, ashen wolf, wolf color red, ashen wolf color red) + testData(ashen wolf color red) + testData(ashen dog color red) + testData(tamed ashen wolf color red) + testData(wild ashen wolf color red) + testData(angry ashen wolf color red) + testData(peaceful ashen wolf color red) + + setSuperTypes(wolf, ashen wolf, baby wolf, baby ashen wolf, wolf color red, ashen wolf color red, baby wolf color red, baby ashen wolf color red) + testData(baby ashen wolf color red) + testData(baby ashen dog color red) + testData(tamed baby ashen wolf color red) + testData(ashen pup color red) + testData(wild baby ashen wolf color red) + testData(angry baby ashen wolf color red) + testData(peaceful baby ashen wolf color red) test "zombie villager data": - compareData((zombie villager, normal zombie villager, zombie farmer, zombie librarian, zombie butcher, zombie nitwit, zombie armorer, zombie cartographer, zombie cleric, zombie fisherman, zombie fletcher, zombie mason, zombie shepherd, zombie toolsmith, zombie weaponsmith) , (zombie villager)) - compareData((baby zombie villager, baby normal zombie villager, baby zombie farmer, baby zombie librarian, baby zombie butcher, baby zombie nitwit, baby zombie armorer, baby zombie cartographer, baby zombie cleric, baby zombie fisherman, baby zombie fletcher, baby zombie mason, baby zombie shepherd, baby zombie toolsmith, baby zombie weaponsmith) , (zombie villager, baby zombie villager)) - compareData((adult zombie villager, adult normal zombie villager, adult zombie farmer, adult zombie librarian, adult zombie butcher, adult zombie nitwit, adult zombie armorer, adult zombie cartographer, adult zombie cleric, adult zombie fisherman, adult zombie fletcher, adult zombie mason, adult zombie shepherd, adult zombie toolsmith, adult zombie weaponsmith) , (zombie villager, adult zombie villager)) + setSuperTypes(zombie villager) + testData(zombie villager) + testData(normal zombie villager) + testData(zombie farmer) + testData(zombie librarian) + testData(zombie butcher) + testData(zombie nitwit) + testData(zombie armorer) + testData(zombie cartographer) + testData(zombie cleric) + testData(zombie fisherman) + testData(zombie fletcher) + testData(zombie mason) + testData(zombie shepherd) + testData(zombie toolsmith) + testData(zombie weaponsmith) + + setSuperTypes(zombie villager, baby zombie villager) + testData(baby zombie villager) + testData(baby normal zombie villager) + testData(baby zombie farmer) + testData(baby zombie librarian) + testData(baby zombie butcher) + testData(baby zombie nitwit) + testData(baby zombie armorer) + testData(baby zombie cartographer) + testData(baby zombie cleric) + testData(baby zombie fisherman) + testData(baby zombie fletcher) + testData(baby zombie mason) + testData(baby zombie shepherd) + testData(baby zombie toolsmith) + testData(baby zombie weaponsmith) + + setSuperTypes(zombie villager, adult zombie villager) + testData(adult zombie villager) + testData(adult normal zombie villager) + testData(adult zombie farmer) + testData(adult zombie librarian) + testData(adult zombie butcher) + testData(adult zombie nitwit) + testData(adult zombie armorer) + testData(adult zombie cartographer) + testData(adult zombie cleric) + testData(adult zombie fisherman) + testData(adult zombie fletcher) + testData(adult zombie mason) + testData(adult zombie shepherd) + testData(adult zombie toolsmith) + testData(adult zombie weaponsmith) test "display data": - compareData((display, text display, block display, block display entity, block display of stone, stone block display, item display, item display entity, item display of stone, stone item display) , (display, display entity)) - compareData((block display, block display of sand, block display entity of sand, sand block display, sand block display entity) , (block display, block display entity)) - compareData((item display, item display of bedrock, item display entity of bedrock, bedrock item display, bedrock item display entity) , (item display, item display entity)) + setSuperTypes(display, display entity) + testData(display) + testData(text display) + testData(block display) + testData(block display entity) + testData(block display of stone) + testData(stone block display) + testData(item display) + testData(item display entity) + testData(item display of stone) + testData(stone item display) + + setSuperTypes(block display, block display entity) + testData(block display) + testData(block display of sand) + testData(block display entity of sand) + testData(sand block display) + testData(sand block display entity) + + setSuperTypes(item display, item display entity) + testData(item display) + testData(item display of bedrock) + testData(item display entity of bedrock) + testData(bedrock item display) + testData(bedrock item display entity) # TODO: simple entity data From 57e503da62a57f5dab776f853927a1cafc95a640 Mon Sep 17 00:00:00 2001 From: SirSmurfy2 Date: Tue, 8 Jul 2025 03:16:40 -0400 Subject: [PATCH 21/21] Update EntityData.sk --- src/test/skript/tests/misc/EntityData.sk | 20 +++----------------- 1 file changed, 3 insertions(+), 17 deletions(-) diff --git a/src/test/skript/tests/misc/EntityData.sk b/src/test/skript/tests/misc/EntityData.sk index 4390b63080c..d55527dc791 100644 --- a/src/test/skript/tests/misc/EntityData.sk +++ b/src/test/skript/tests/misc/EntityData.sk @@ -1,18 +1,4 @@ -local function compareData(data1: entity types, data2: entity types): - loop {_data1::*}: - if loop-value is spawnable: - spawn (loop-value) at test-location: - set {_entity} to event-entity - assert {_entity} is set with "Could not spawn '%loop-value%'" - assert {_entity} is loop-value with "Spawned '%loop-value%' should match against own EntityData '%loop-value%'" - loop {_data2::*}: - assert loop-value-1 is loop-value-2 with "EntityData '%loop-value-1%' should match against EntityData '%loop-value-2%'" - if {_entity} is set: - assert {_entity} is loop-value-2 with "Spawned '%{_entity}%' should match against EntityData '%loop-value-2%'" - clear entity within {_entity} - clear {_entity} - local function setSuperTypes(data: entity types): set {-SuperTypes::*} to {_data::*} @@ -22,14 +8,14 @@ local function testData(data: entity type): if {_data} is spawnable: spawn {_data} at test-location: set {_entity} to entity - assert {_entity} is set with "Could not spawn '%{_data}%" + assert {_entity} is set with "Could not spawn '%{_data}%'" assert {_entity} is {_data} with "Spawned '%{_data}%' should match against its own EntityData" loop {-SuperTypes::*}: assert {_data} is loop-value with "EntityData '%{_data}%' should match against EntityData '%loop-value%'" if {_entity} is set: assert {_entity} is loop-value with "Spawned '%{_data}%' should match against EntityData '%loop-value%'" clear entity within {_entity} - + clear {_entity} test "axolotl data": setSuperTypes(axolotl) @@ -854,7 +840,7 @@ test "strider data": testData(baby warm strider) testData(baby cold strider) -test "thrown potion data": +test "thrown potion data" when running minecraft "1.21.0": setSuperTypes(thrown potion) testData(thrown potion) testData(thrown speed potion)