logoChat01.ai

can i teach you minecraft skript with complex addo...

Created on: November 3, 2025

Answered using GPT-5 Thinking by Chat01

Question

can i teach you minecraft skript with complex addon ability by uploading skripts made by professionals?

Thought

Clarifying about teaching Skript

The user wants to know if they can teach me Minecraft Skript (like the plugin for Bukkit/Spigot) using professional scripts. Yes, they can upload files, and I can analyze them for patterns, but I can’t learn or store info beyond the session unless memory is enabled. We’ll also ensure there's no issue with sharing any copyrighted code.

Suggesting a workflow for learning Skript

I could suggest a workflow: 1) upload sample scripts, 2) annotate goals, 3) create a cheat sheet for syntax and APIs, and 4) build a knowledge pack for addon APIs. We’d need metadata for the scripts like server versions and installed addons. I can help generate “profiles” of these scripts, extract patterns, and suggest troubleshooting resources or snippet libraries. However, I can’t run the code but can reason through it statically if documentation’s available.

Safety suggestions and next steps

I’ll advise that while the code can’t be executed, we can still check for potential issues like loop-lag, event recursion, or unsafe NBT manipulations. I’ll suggest uploading a few sample scripts along with addon lists and priorities like performance or readability. Asking one optional follow-up question is okay, but no clarifying questions are needed.

Suggesting a plan for Skript scripts

I can suggest a clear plan for packaging scripts, including a directory structure like /skripts/core, /skripts/commands, and /skripts/utils. We should also include an addons.txt file with versions and server.md with Minecraft and platform info. I’ll mention adding a style guide, snippets, and linting checklist. Additionally, I’ll clarify that they should only upload professional scripts if they have permission and provide disclaimers about licensing. No need to suggest enabling memory unless asked.

Thought for 22s

Answer

Absolutely—yes! If you upload high-quality Skript (.sk) files (including ones that use complex addons), I can study them in this chat, extract patterns and conventions, and then help you write new Skripts that match that style and make smart use of those addons.

A few notes on how this works (and what I can/can’t do):

  • I can’t execute Skript or run a Minecraft server here, but I can read, analyze, refactor, and generate Skript based on the examples you provide.
  • I don’t keep a permanent memory outside this conversation, but we can build a “mini knowledge base” right here (style guide + snippet library + API notes) that I’ll use for all follow-ups.
  • If the scripts aren’t yours, make sure you have permission to share them.

Best way to upload/organize

Zip a small starter set (3–10 representative scripts) plus a short text file with environment info:

text
/skripts/
  core/
  commands/
  utils/
addons.txt            # e.g., Skript 2.8.x, SkBee 3.x, skript-reflect 2.x, skript-yaml, skript-gui, skript-db, etc.
server.md             # MC version (e.g., Paper 1.20.6), platform, any key plugins (WorldGuard, LuckPerms…)
README.md             # goals, coding style preferences (perf vs readability, naming, tabs/spaces), known pain points

What I’ll produce from your uploads (right away in this chat)

  • Addon cheat-sheet: effects/expressions/events actually used (e.g., SkBee NBT, YAML sections, skript-reflect calls), with example snippets.
  • Style guide: naming, variable scoping ({_locals} vs globals), options, command structure, event ordering, error handling.
  • Snippet library: ready-to-paste patterns (menus, scoreboards, cooldowns, async DB with skript-db, WG region checks, permission gates).
  • Anti-lag checklist: spot loops/every-tick tasks, heavy selectors, recursion, unsafe reflect calls, and suggest safer patterns.
  • Function index: a quick reference of custom functions with parameters and side-effects.

Tips that make the “teaching” extra effective

  • Include versions (Skript + each addon). Syntax and features vary a lot.
  • If you use advanced addons (SkBee NBT, skript-reflect, Vixio, skript-db, skript-yaml, skript-gui), examples that show the “tricky bits” help me generalize.
  • Point out any conventions you want enforced (e.g., always use local vars in events, never loop all entities, use namespaced keys, etc.).

When you’re ready, upload the zip (or just drop a few .sk files to start). I’ll read them and immediately give you a tailored guide and first batch of reusable snippets.

Question

-orbsSMP.sk

analyze this skript and tell me EXACTLY what you notice.

Python

python
# Let's read the uploaded Skript file
from pathlib import Path, PurePosixPath
p = Path('/mnt/data/-orbsSMP.sk')
print(p.exists(), p.stat())
content = p.read_text(encoding='utf-8', errors='replace')
print(content[:1000])
len(content.splitlines())

696

Python

python
import re, textwrap, json
lines = content.splitlines()
def find_indices(pattern):
    indices=[]
    for i,l in enumerate(lines, start=1):
        if re.search(pattern, l):
            indices.append((i,l))
    return indices

funcs=find_indices(r'^\s*function\s+([a-zA-Z0-9_]+)\(')
commands=find_indices(r'^\s*command\s+\/')
events=find_indices(r'^\s*on\s+')
options=find_indices(r'^\s*options:|^\s*option\s+')
variables=find_indices(r'%\{|^\s*set\s+\{|\{_') # rough

len(funcs), len(commands), len(events), len(options)

(20, 2, 8, 0)

Python

python
func_entries=[]
pattern=re.compile(r'^\s*function\s+([a-zA-Z0-9_]+)$(.*?)$:')
for i,l in enumerate(lines, start=1):
    m=pattern.match(l)
    if m:
        func_entries.append((i, m.group(1), m.group(2)))
func_entries[:10], len(func_entries)

([(2, 'clearOrbs', 'p: player'),
  (5,
   'coloredRing',
   'p: player, r: integer, r1: integer, r2: integer, s: integer'),
  (16,
   'coloredRing1',
   'p: location, r: integer, r1: integer, r2: integer, s: integer'),
  (28, 'particleRing1', 'p: location, s: integer'),
  (40, 'particleRing', 'p: player, r: text, s: integer'),
  (51, 'stun', 'p: player, t: integer'),
  (283, 'venom1', 'p: player, t: integer'),
  (338, 'venom2', 'p: player'),
  (365, 'venom3', 'p: player'),
  (382, 'volcano2', 'p: player')],
 20)

Python

python
func_entries

[(2, 'clearOrbs', 'p: player'),
 (5,
  'coloredRing',
  'p: player, r: integer, r1: integer, r2: integer, s: integer'),
 (16,
  'coloredRing1',
  'p: location, r: integer, r1: integer, r2: integer, s: integer'),
 (28, 'particleRing1', 'p: location, s: integer'),
 (40, 'particleRing', 'p: player, r: text, s: integer'),
 (51, 'stun', 'p: player, t: integer'),
 (283, 'venom1', 'p: player, t: integer'),
 (338, 'venom2', 'p: player'),
 (365, 'venom3', 'p: player'),
 (382, 'volcano2', 'p: player'),
 (416, 'wind2', 'p: player'),
 (435, 'wind3', 'p: player'),
 (457, 'electro2', 'p: player'),
 (477, 'electro3', 'p: player'),
 (487, 'catalyst2', 'p: player'),
 (507, 'catalyst3', 'p: player'),
 (526, 'cosmic2', 'p: player'),
 (565, 'cosmic3', 'p: player'),
 (582, 'dragon1', 'p: player'),
 (606, 'dragon2', 'p: player')]

Python

python
commands

[(70, 'command /orb <text> [<player>]:'), (123, 'command /lives:')]

Python

python
def snippet(start, end):
    return "\n".join(f"{i:04d}: {lines[i-1]}" for i in range(start, end+1))
print(snippet(60, 120))

Python

python
print(snippet(120, 170))

Python

python
print(snippet(170, 240))

Python

python
events

[(57, 'on first join:'),
 (60, 'on join:'),
 (120, 'on tab complete for "/orb":'),
 (130, 'on right click:'),
 (149, 'on swapping of item:'),
 (334, 'on projectile collide:'),
 (429, 'on damage:'),
 (602, 'on disconnect:')]

Python

python
print(snippet(1, 70))

Python

python
print(snippet(130, 220))

Python

python
print(snippet(145, 210))

Python

python
print(snippet(250, 420))

Python

python
print(snippet(280, 365))

Python

python
print(snippet(334, 480))

Python

python
print(snippet(480, 620))

Python

python
print(snippet(40, 120))

Python

python
print(snippet(420, 500))

Python

python
print(snippet(596, 696))

Python

python
print(snippet(70, 118))

Python

python
print(snippet(16, 39))

Python

python
find_indices(r'lives')

[(58, "\tset {lives.%player's uuid%} to 5"),
 (61, "\tif {lives.%player's uuid%} is not an integer:"),
 (62, "\t\tset {lives.%player's uuid%} to 5"),
 (123, 'command /lives:'),
 (124, '\taliases: /orbs:lives, /getlives'),
 (126, '\t\tsend "&aYour lives: &c%{lives.%player\'s uuid%}%&a!"')]

Python

python
find_indices(r'slash')

[(66, "\tset {slash.%player's uuid%} to false"),
 (419, "\tset {slash.%{_p}'s uuid%} to true"),
 (427, "\tset {slash.%{_p}'s uuid%} to false"),
 (430, "\t{slash.%attacker's uuid%} is true")]

Python

python
for start in range(282, 355, 10):
    print(snippet(start, min(start+9, 360)))

Python

python
print(snippet(296, 334))

Python

python
print(snippet(180, 200))

Python

python
print(snippet(365, 420))

Python

python
print(snippet(382, 418))

Python

python
print(snippet(416, 560))

Python

python
print(snippet(452, 510))

Python

python
print(snippet(506, 596))

Python

python
print(lines[585])

Python

python
print(snippet(526, 565))

Python

python
print(snippet(565, 596))

Python

python
import re
dust_colors=set()
for l in lines:
    for m in re.finditer(r'dustOption$(.*?)$', l):
        dust_colors.add(m.group(1))
dust_colors

{'black, 1',
 'brown, 3',
 'cyan, 3',
 'green, 1',
 'green, 3',
 'light blue, 2',
 'lime, 0.7',
 'lime, 1',
 'orange, 1',
 'purple, 1',
 'purple, 3',
 'red, 1',
 'rgb({_r}, {_r1}, {_r2}',
 'white, 1',
 'white, 3',
 'yellow, 2',
 'yellow, 3'}

Python

python
particles=set()
for l in lines:
    m=re.search(r'draw (?:\d+|an animation) of ([a-zA-Z_ ]+)', l)
    if m:
        particles.add(m.group(1).strip())
particles

{'dust using dustOption',
 'glow at',
 'lava at',
 'lava at location',
 'lava at loop',
 'poof at',
 'poof at loop',
 'sculk charge pop at',
 'sculk charge pop at location',
 'sonic boom at',
 'sweep attack at',
 'sweep attack at victim',
 'the shape of',
 'wax off at',
 'witch at'}

Python

python
keys=set()
for l in lines:
    for m in re.finditer(r'\{cooldown\.%.*?::(\d+)\}', l):
        keys.add(m.group(1))
sorted(keys)

['11',
 '12',
 '13',
 '21',
 '22',
 '31',
 '32',
 '33',
 '41',
 '42',
 '43',
 '51',
 '52',
 '61',
 '62',
 '63',
 '71',
 '72',
 '73']

Python

python
find_indices(r'coloredRing\(')

[(5,
  'function coloredRing(p: player, r: integer, r1: integer, r2: integer, s: integer):'),
 (480, '\tcoloredRing({_p}, 255, 255, 0, 10)')]

Python

python
find_indices(r'particleRing1\(')

[(28, 'function particleRing1(p: location, s: integer):'),
 (577, '\t\tparticleRing1({_loc}, 30)')]

Python

python
find_indices(r'coloredRing1\(')

[(16,
  'function coloredRing1(p: location, r: integer, r1: integer, r2: integer, s: integer):'),
 (563, '\t\t\tcoloredRing1({_loc1}, 200, 0, 250, 6)')]

Python

python
find_indices(r'particleRing\(')

[(40, 'function particleRing(p: player, r: text, s: integer):')]

Python

python
vars=set()
for l in lines:
    for m in re.finditer(r'\{([A-Za-z0-9_:.\'%\s\-_]+)\}', l):
        vars.add(m.group(1))
sorted(list(vars))[:50], len(vars)

(["Dragon1::Dragon::%player's uuid%",
  "Dragon1::Horse::%player's uuid%",
  '_a',
  '_c',
  '_c::%loop-value%',
  '_ee',
  '_ee1',
  '_l',
  '_l1',
  '_loc',
  '_loc1',
  '_p',
  '_r',
  '_r1',
  '_r2',
  '_rand',
  '_rand1',
  '_rand2',
  '_s',
  '_s::%loop-value%',
  '_s::%loop-value-2%',
  '_t',
  '_v',
  '_v::%loop-value%',
  '_v::1',
  '_v::2',
  '_v::3',
  '_v::4',
  '_v::5',
  "cooldown.%loop-player's uuid%::11",
  "cooldown.%loop-player's uuid%::12",
  "cooldown.%loop-player's uuid%::13",
  "cooldown.%loop-player's uuid%::21",
  "cooldown.%loop-player's uuid%::22",
  "cooldown.%loop-player's uuid%::31",
  "cooldown.%loop-player's uuid%::32",
  "cooldown.%loop-player's uuid%::33",
  "cooldown.%loop-player's uuid%::41",
  "cooldown.%loop-player's uuid%::42",
  "cooldown.%loop-player's uuid%::43",
  "cooldown.%loop-player's uuid%::51",
  "cooldown.%loop-player's uuid%::52",
  "cooldown.%loop-player's uuid%::61",
  "cooldown.%loop-player's uuid%::62",
  "cooldown.%loop-player's uuid%::63",
  "cooldown.%loop-player's uuid%::71",
  "cooldown.%loop-player's uuid%::72",
  "cooldown.%loop-player's uuid%::73",
  "lives.%player's uuid%",
  "o.%arg-2's uuid%"],
 63)

Python

python
print(lines[120])

Python

python
# Build function block ranges and analyze cooldown sets and effects (approx)
funcs=[]
pattern=re.compile(r'^\s*function\s+([a-zA-Z0-9_]+)$(.*?)$:')
func_positions=[]
for i,l in enumerate(lines, start=1):
    if pattern.match(l):
        func_positions.append(i)
# add end line as len+1 to slice last function
func_positions.append(len(lines)+1)
for idx in range(len(func_positions)-1):
    start=func_positions[idx]
    end=func_positions[idx+1]-1
    l=lines[start-1]
    m=pattern.match(l)
    name=m.group(1)
    params=m.group(2)
    block=lines[start-1:end]
    # find cooldown assignments
    sets=[]
    for j,line in enumerate(block, start=start):
        for m2 in re.finditer(r'set \{cooldown\.%.*?::(\d+)\} to (\d+)', line):
            sets.append((j, m2.group(1), int(m2.group(2))))
    funcs.append({"name":name,"start":start,"end":end,"params":params,"cooldowns":sets})
funcs

[{'name': 'clearOrbs',
  'start': 2,
  'end': 4,
  'params': 'p: player',
  'cooldowns': []},
 {'name': 'coloredRing',
  'start': 5,
  'end': 15,
  'params': 'p: player, r: integer, r1: integer, r2: integer, s: integer',
  'cooldowns': []},
 {'name': 'coloredRing1',
  'start': 16,
  'end': 27,
  'params': 'p: location, r: integer, r1: integer, r2: integer, s: integer',
  'cooldowns': []},
 {'name': 'particleRing1',
  'start': 28,
  'end': 39,
  'params': 'p: location, s: integer',
  'cooldowns': []},
 {'name': 'particleRing',
  'start': 40,
  'end': 50,
  'params': 'p: player, r: text, s: integer',
  'cooldowns': []},
 {'name': 'stun',
  'start': 51,
  'end': 282,
  'params': 'p: player, t: integer',
  'cooldowns': []},
 {'name': 'venom1',
  'start': 283,
  'end': 337,
  'params': 'p: player, t: integer',
  'cooldowns': [(290, '11', 15),
   (291, '21', 15),
   (292, '31', 15),
   (293, '41', 15),
   (294, '61', 15),
   (295, '71', 15)]},
 {'name': 'venom2',
  'start': 338,
  'end': 364,
  'params': 'p: player',
  'cooldowns': [(340, '12', 25)]},
 {'name': 'venom3',
  'start': 365,
  'end': 381,
  'params': 'p: player',
  'cooldowns': [(367, '13', 45)]},
 {'name': 'volcano2',
  'start': 382,
  'end': 415,
  'params': 'p: player',
  'cooldowns': [(384, '22', 35)]},
 {'name': 'wind2',
  'start': 416,
  'end': 434,
  'params': 'p: player',
  'cooldowns': [(418, '32', 40)]},
 {'name': 'wind3',
  'start': 435,
  'end': 456,
  'params': 'p: player',
  'cooldowns': [(437, '33', 30)]},
 {'name': 'electro2',
  'start': 457,
  'end': 476,
  'params': 'p: player',
  'cooldowns': [(459, '42', 30)]},
 {'name': 'electro3',
  'start': 477,
  'end': 486,
  'params': 'p: player',
  'cooldowns': [(479, '43', 40)]},
 {'name': 'catalyst2',
  'start': 487,
  'end': 506,
  'params': 'p: player',
  'cooldowns': [(489, '62', 30)]},
 {'name': 'catalyst3',
  'start': 507,
  'end': 525,
  'params': 'p: player',
  'cooldowns': [(509, '63', 30)]},
 {'name': 'cosmic2',
  'start': 526,
  'end': 564,
  'params': 'p: player',
  'cooldowns': [(528, '72', 40)]},
 {'name': 'cosmic3',
  'start': 565,
  'end': 581,
  'params': 'p: player',
  'cooldowns': [(567, '73', 40)]},
 {'name': 'dragon1',
  'start': 582,
  'end': 605,
  'params': 'p: player',
  'cooldowns': [(584, '51', 40)]},
 {'name': 'dragon2',
  'start': 606,
  'end': 696,
  'params': 'p: player',
  'cooldowns': [(608, '52', 60)]}]

Python

python
[(f["name"], f["start"], [ (c[1], c[2]) for c in f["cooldowns"] ]) for f in funcs]

[('clearOrbs', 2, []),
 ('coloredRing', 5, []),
 ('coloredRing1', 16, []),
 ('particleRing1', 28, []),
 ('particleRing', 40, []),
 ('stun', 51, []),
 ('venom1',
  283,
  [('11', 15), ('21', 15), ('31', 15), ('41', 15), ('61', 15), ('71', 15)]),
 ('venom2', 338, [('12', 25)]),
 ('venom3', 365, [('13', 45)]),
 ('volcano2', 382, [('22', 35)]),
 ('wind2', 416, [('32', 40)]),
 ('wind3', 435, [('33', 30)]),
 ('electro2', 457, [('42', 30)]),
 ('electro3', 477, [('43', 40)]),
 ('catalyst2', 487, [('62', 30)]),
 ('catalyst3', 507, [('63', 30)]),
 ('cosmic2', 526, [('72', 40)]),
 ('cosmic3', 565, [('73', 40)]),
 ('dragon1', 582, [('51', 40)]),
 ('dragon2', 606, [('52', 60)])]

Python

python
print(snippet(209, 264))

Python

python
print(snippet(224, 244))

Python

python
print(snippet(244, 266))

Thought

Exploring abilities and cooldowns

Wind3 has triple repeating, sweeping projectiles going up and down. Different abilities match the orbs:

  • Electro: Ability1=venom1(t=4), Electro 2 and 3.
  • Dragon: Only two abilities (dragon1 and dragon2).
  • Catalyst: Venom1(t=5), Catalyst2 and Catalyst3.
  • Cosmic: Venom1(t=6), Cosmic2 and Cosmic3.

Venom1's cooldown setup doesn’t impact 51 directly, as it's not tied to dragon abilities, but there's a question about whether venom1 should set 51.

Addressing cross-cooldown details

The goal is to manage cross-cooldown for ability #1 across orbs. Orbs 1, 2, 3, 4, 6, and 7 share venom1 as ability1. Dragon orb, however, uses dragon1 and sets cooldown ::51 as 40. If venom1 was used first, cooldowns 11, 21, 31, etc., are set to 15, but not for 51. This may require adjustments to unify cooldown rules for faster ability swapping between venom1 and dragon1. It appears the cooldown design intentionally differentiates between orbs.

Considering cross-cooldown consistency

It seems they might want the same cooldown for ability1 across all orbs, including 51 for fairness. However, venom1 sets cooldowns across other keys but not 51, which might be intentional or an oversight. The choice could influence gameplay balance. Also, right-click toggles ability number, but abilities trigger only on item swap—important to clarify.

Organizing final response

I’ll structure the final response into clear sections:

  • Snapshot: Brief file summary (lines, functions).
  • Commands & Tab Completion: Describe available commands and compatibility.
  • Data Model & Cooldown Scheme: Mapping and key structure.
  • Event Flow: Outline the sequence of events.
  • Abilities by Orb: Short tables

Thought for 5m 0s

Answer

Here’s a precise, “no-hand-waving” read of your file /mnt/data/-orbsSMP.sk (≈696 lines).

Snapshot

  • Abilities implemented as functions (20): venom1/2/3, volcano2, wind2/3, electro2/3, catalyst2/3, cosmic2/3, dragon1/2 + helpers stun, coloredRing/coloredRing1/particleRing/particleRing1.
  • Commands: /orb <text> [<player>] (op-only) and /lives.
  • Events: on first join, on join, on tab complete for "/orb", on right click, on swapping of item, every second, on projectile collide, on damage, on disconnect.

Data model & cooldown scheme

  • Per-player orb choice in {orb.%uuid%}:
    1=Venom, 2=Volcano, 3=Wind, 4=Electro, 5=Dragon, 6=Catalyst, 7=Cosmic. (Set via /orb.)
  • Selected ability slot in {o.%uuid%} where:
    • Orbs 2 (Volcano) and 5 (Dragon) have 2 abilities (slots 1–2).
    • All others have 3 abilities (slots 1–3).
    • Cycling happens on sneak + right-click; ability use on sneak + swap item.
  • Cooldown keys: {cooldown.%uuid%::XY} → X = orb id, Y = ability index.
    Ticks down every second, then when < 0 the key is set to the string "&aʀᴇᴀᴅʏ!".
    Keys used: 11,12,13,21,22,31,32,33,41,42,43,51,52,61,62,63,71,72,73.

Commands & tab completion

  • /orb <text> [player] (line ~70): sets {orb.%uuid%}. Supports venom, volcano, wind, electro, dragon, catalyst, cosmic, reset; with optional target player.
    • Aliases: declared as aliases: /orbs:orb (namespaced alias syntax).
    • Tab-complete (line ~120): provides first-argument suggestions (“Venom”, “Wind”, “Electro”, “Volcano”, “Dragon”, “Catalyst”, “Cosmic”, “RESET”).
  • /lives (line ~123): echos {lives.%uuid%} (defaults to 5 on first join).

Event flow (exact behavior)

  • on first join → set lives to 5.
  • on join → ensure {lives} exists; ensure {o} defaults to 1; reveal player to all players; set {slash.%uuid%} = false.
  • on right click (sneaking) → selection mode: cycles {o.%uuid%} depending on orb (2/5 → 1↔2, others → 1→2→3→1). Sends “You have swapped to ability X”.
  • on swapping of item (sneaking) → cast ability based on {orb} and {o} by calling the functions listed below.
  • every second → for each player, subtracts 1 from all cooldown keys listed above, then for each key < 0 sets it to the string "&aʀᴇᴀᴅʏ!".
  • on projectile collide → if the projectile equals one of {thorn::1..4} then damage event-entity by 3.
  • on damage → if {slash.%attacker's uuid%} is true, +2 damage, draw sweep attacks, play sound.
  • on disconnect → kill any spawned Dragon/Horse entities for that player.

Abilities by orb (what they do + exact cooldowns)

Note: “sec” below is wall time because timers decrement once per second.

Shared ability 1 (venom1(p, t) at line ~283)

  • CD set: 11,21,31,41,61,71 → 15 sec each. (Notably does not set 51.)
  • Effect: brief invisibility (21 ticks ≈ 1.05 s), hide from all players, forward dash (push ... with velocity 1), play orb-themed sound & particles (t=1..6 picks sounds/particles), then reveal.

Venom (orb=1)

  • A1: venom1(p,1) (15s).
  • A2: venom2 (line ~338) → 25s. Spawns 2–4 tridents {thorn::1..4} from head with random vectors; runs a 40-tick visual loop; on collision (global handler) deals 3; while looping, every tick damages all entities within 4 blocks by 0.5 and draws green beams from player to each entity.
  • A3: venom3 (line ~365) → 45s. A poison aura: over ~130 ticks (65× wait 2 ticks) draws a lime sphere at head; self gets short Strength 1 bursts; others in 2.1-block radius get Poison II and Weakness for 2s each tick cycle.

Volcano (orb=2)

  • A1: venom1(p,2) (15s).
  • A2: volcano2 (line ~382) → 35s. Rings of brown dust at multiple heights for ~9s (90× wait 2 ticks); for entities within 4 blocks: 40% chance to damage 1 each cycle, place fire on air/grass at their position and play fire sounds.

Wind (orb=3)

  • A1: venom1(p,3) (15s).
  • A2: wind2 (line ~416) → 40s. Sets {slash.%uuid%} = true for ~10.5s (210 ticks): plays shulker/elytra sounds, Haste V (10s), constant sweep visuals; in on damage adds +2 damage while active.
  • A3: wind3 (line ~435) → 30s. Shoots 3 short sweep/white-dust lines ~7.5 blocks forward; entities within 1.5 blocks of the path take 1 and are launched up then pushed down with particle “poofs”.

Electro (orb=4)

  • A1: venom1(p,4) (15s + fake lightning pop).
  • A2: electro2 (line ~457) → 30s. Creates 5 lightning tracks aimed ~12 blocks ahead; every ~10 ticks, fake lightning strikes near end point; entities within 2 blocks at the strike take 4.
  • A3: electro3 (line ~477) → 40s. Yellow ring (coloredRing) then fake lightning on all entities within 3 blocks, each taking 2 and a stun(10 ticks).

Dragon (orb=5)

  • A1: dragon1 (line ~582) → 40s. Spawns an invisible, resistant horse (ridden by player) and an Ender Dragon tethered 4 blocks above; draws extensive wing-like purple/black dust trails for ~6s, then kills both entities.
  • A2: dragon2 (line ~606) → 60s. For ~6s, every tick: players within 4 blocks (not self) gain Blindness (3s) and Wither III (3s); constant purple dust “trail” behind.

Catalyst (orb=6)

  • A1: venom1(p,5) (15s with Warden sounds).
  • A2: catalyst2 (line ~487) → 30s. Levitate self (1s), then fire a 20-step Warden sonic boom line that deals 4 to entities within 1 block of the beam.
  • A3: catalyst3 (line ~507) → 30s. Sculk-themed concentric rings; entities within 4.3 blocks are pulled slightly toward the center (vector push toward _loc).

Cosmic (orb=7)

  • A1: venom1(p,6) (15s with illusioner/witch theming).
  • A2: cosmic2 (line ~526) → 40s. A black sphere with wax-off rings and an outline circle around self for ~10s; gently pulls entities within 7 blocks toward center; occasionally spawns colored rings at random nearby points.
  • A3: cosmic3 (line ~565) → 40s. 10 pulses: draw a white sphere for ~10 ticks, then a large particle ring; entities within 6 blocks are stunned for 10 ticks each pulse.

Visuals, sounds & addons implied

  • Particles/shapes used: circles, spirals, spheres (solid & hollow), lines, sweep attack, wax off, sculk charge pop, glow, poof, witch, lava, sonic boom, dustOption(...) with many colors and rgb(...).
  • Likely addon requirement: SkBee (shapes/“draw shapes…”, particles with dustOption, “spawn entity … with NBT”, and fake lightning).
  • Skript version hints: uses modern effect syntax and tab-complete event; expect Skript 2.7+ / 2.8+ and Paper 1.19+ / 1.20+ (because of particle names like wax off, sculk, sonic boom).

Exact things that look risky / inconsistent (bugs & edge cases)

  1. Cooldown type mixing

    • You subtract 1 every second, but when a timer finishes you set it to the string "&aʀᴇᴀᴅʏ!". On the next ticks you still subtract 1 from that key → Skript will attempt numeric math on a string (console errors / undefined behavior).
    • Fix: keep cooldowns numeric only (e.g., clamp to 0) and treat 0 as “ready”, or store readiness in a separate boolean.

  2. Global projectile refs for Venom2

    • {thorn::1..4} are global, not per-player. Two players casting at once will overwrite each other, and the collide check will misattribute hits.
    • Fix: namespace by player: {thorn.%uuid%::1..4} and in the collide event, test against the attacker’s set.

  3. Ability-1 cross-cooldown missing Dragon

    • venom1 sets 11,21,31,41,61,71 to 15s but not 51. After dashing on another orb, you can swap to Dragon and still use dragon1 immediately (unless you intended Dragon to be exempt).

  4. Very high sustained damage on some abilities

    • venom2: the loop damages all entities within 4 blocks for 0.5 every tick for 40 ticks → up to 20 hearts if someone stays nearby (plus trident hits).
    • volcano2: 90 cycles × 40% chance of 1 damage ≈ 36 expected hits over ~9s, plus fire placement.
    • These numbers are likely overtuned unless you want very lethal kits.

  5. Right-click guard line style

    • You rely on bare condition lines (e.g., player is sneaking, loop-entity is not {_p}) as section guards without if:. Skript does allow this, but it’s easy to mis-indent; elsewhere you also use explicit if:—it’s inconsistent and can cause subtle logic errors if indentation shifts.

  6. Dragon safety & cleanup

    • You do clean up on disconnect and at the end of dragon1, good. Consider also cleanup on death, world change, or server stop to prevent orphaned entities if the section is interrupted.

  7. Tab completion vs comparisons (case)

    • You tab-suggest capitalized names but compare against lowercase strings. Skript comparisons are case-insensitive, so this is fine—just noting the mismatch is intentional.

  8. Unused function

    • particleRing(p: player, r: text, s: integer) is never called.

  9. Minor grammar portability

    • You use location N blocks **infront** of {player}. The canonical Skript grammar is usually "in front of" (with a space). Many servers addons alias both, but this can be a compatibility gotcha across versions/addons.

  10. Lives system is stubbed

    • {lives.%uuid%} is initialized/readable via /lives, but never decremented or used for any gating.

Quality touches I noticed (nice!)

  • Reveal on join so hidden players aren’t stuck invisible.
  • Per-player UUID scoping for almost all state (cooldowns, orb, selection).
  • Ability slot cycling separated from casting; clear player feedback messages.
  • Cosmetic helpers (coloredRing, etc.) reuse across abilities.
  • Thematic SFX/VFX per orb (warden/illusioner/dragon, etc.)—gives each kit a flavor.

If you want, I can refactor the cooldown engine to be numeric-only and per-orb/per-slot safe (and namespaced tridents) in one pass, or tune the damage windows to hit specific TTK targets.

Share this Q&A