Sequell User Definitions

.echo $(let (x (- (!lm ${1:-.} !ak $* banished fmt:"${n}") (!lg ${1:-.} !ak $* abyss fmt:"${n}")) y (!lm ${1:-.} !ak $* banished fmt:"${n}")) "$(name_fixup ${1:-.}) $(if $* "("$*") ")has survived banishment $x of $y times: $(int (* 100 (/ (float $x) $y)))%")

For each time you were banished checks whether you died in Abyss in that game or not. Shows ratio.

.echo If you have $1 base AC then you need $(/ (int (+ 0.5 (* 100 (/ 22.0 $1)))) 100.0) armour skill per AC and get $(/ (int (/ (* 100.0 $1) 22.0)) 100.0) AC per armour skill.

Usage: !ac <base AC>, tells you how much armour skill per AC

!lm * ktyp= type!=crash time>=$(- (utc (time)) (interval-minute 30)) s=name,src pfmt:"${.} (${child})" fmt:"${.}" title:"Active games, last half-hour ($*)" stub:"No milestones in the last half-hour ($*)" $*

Shows all games with a milestone in the last 30 minutes that haven't ended. Syntax: !activegames [!lm filters]

.echo ER=$1, str=$2, armour skill=$3 : -$(int (/ (* (/ (* (/ 2 5.0) (** $1 2)) (+ $2 3)) (- 45 $3)) 45.0)) EV

Usage: !aevp <ER> <str> <armour skill>. Returns the aevp (armour EV penalty)

!lm ${1:-.} verb=ancestor.class $* s=regexp_replace(noun, ".*\m(\w+)\.$", "\1")%

Counts how many times each ancestor class was picked. Syntax: !ancestorclasses [name] [lg filters]

.echo $(name_fixup ${1:-.}) antiprogress: $(car (split | (!lg ${1:-.} $* won s=char fmt:"${n_x}${.}" join:"|")))

Shows a players most won combo. Syntax: !antiprogress [playername] [lg filters]

.echo $(name_fixup ${1:-.}) antititleprogress: $(car (split | (!lg ${1:-.} $* won s=title fmt:"${n_x}${.}" join:"|")))

Shows a players most won title. Syntax: !antititleprogress [playername] [lg filters]

.echo $(sprintf "Aptitude $1 skills require %.0f%% as much experience as a skill with aptitude 0." (* (** 2 (* -1 (/ $1 4.0))) 100))

Give it an aptitude and it will tell you how much that skill costs to train relative to an apt0 skill. Try !aptstrength 3

!echo $(let (a (apthash $1)) (apply ${+} (map (fn (k) (elt $k $a)) (hash-keys $a))))

Sums the aptitudes for a given Species or Skill. Try: !aptsum Shape or !aptsum Dj

.echo "$*$(if (/= (last (split "" (concat $*))) ?) ?)" $(ask_response)!

Answers a yes/no question. Try: !ask Does Offline count?

.echo $nick casts a spell. ${1:-Everyone} is cast into ${*:-$(=badplace)}!

Banish someone to a bad place. Syntax: !banish [someone] [bad place]. The [someone] shouldn't contain spaces!

.echo The bees are $(let (time (secondssince (stamptime (!lg * cikiller=killer_bee|meliai|queen_bee x=end fmt:'${x[0]}')))) (if (< $time 300) "happy!" (if (< $time 3600) "content." (if (< $time 86400) "restless." "angry!"))))

As any amateur bee psychologist could tell you, a bee's emotions are determined by how long it's been since a bee has killed a player. This command tells you how they are feeling right now.

.echo /me slides a $(beervessel) of $(beertype) down the bar to ${*:-${nick}}$(if $* ", courtesy of $nick").

Ask the bot to give someone a random beer. Syntax: !beer [someone]

.echo I pronounce ${*:-${nick}}... Guilty!

Blame someone. Syntax: !blame [someone]

!echo $(!blame $(randelt (nick-aliases devteam)))

Blame someone at random from the devteam nick.

.echo $(name_fixup ${1:-.}): $(car (split | (!lm ${1:-.} $* uniq=boris s=gid fmt:"${n_x}" join:"|"))) Boris

What's the most you've killed boris in a single game? This command lists your top score. Syntax: !boris [playernick] [lg filters]

.echo $(if $1 (!lm ${2:-*} br.enter=$1 $* / lg:br=$1 title="$1 death rate for $(name_fixup ${1:-.})$(argst $*)" stub:"No games for $(name_fixup ${1:-.})$(argst $*)") (!help branchdeathrate))

Get the ratio of branch deaths to games that entered that branch. First argument must be the branch name! "D" for dungeon, or the first word of the branch for every other branch. (eg "Slime" for slime pits) Syntax: !branchdeathrate <branch> [playernick] [lm args]

.echo https://dev.dcss.io/learndb.html#$(ldb-canonical-term $*)

Link a learn database entry for easy reading in a web browser. Try !browse coffin

!lg xyz x=$$(replace ^ ** $*)$ fmt:"${x[0]}"

Leverages !lg math to calculate things for you. Remember to use ** for exponents, % for modulo operations, and add a .0 to integers if you want to do floating point math. [!calc 8**2] = 64, [!calc 5 / 10] = 0, [!calc 5 / 10.0] = 0.5, [!calc 10 % 3] = 1 (the remainder)

!lg * current char=$(join '|' (nem-remaining)) $* s=char o=-. fmt:"${.}" title:"Available combos for Nemelex Choice with $*" stub:"No available combos for Nemelex Choice with $*"

List remaining nemelex choice combos that match the filter (if you supply one). Syntax: !cannchoice [lg filters] Try: !cannchoice co or !cannchoice wn

!unplayed

see {!help:!unplayed}

!lg ${1:-.} won fe-- $* s=char join:"|" fmt:"${n_x}{=^;^=}" stub:"=u.u=" title:"Cats won for $(name_fixup $1)"

Displays how meowny cats you've won. Syntax: !cats [playernick]

.echo $(sprintf "$* degrees F is %1.1f degrees C" $(/ (- $1 32) 1.8))

Converts F to C. Syntax: !celcius <degrees F>. Try !celcius 212

!learn q cerebot

Type `!help` or `!cerebot` for help with Cerebot. For help with Sequell, type `!sequellhelp`.

!streak ${1:-.} $* won

Shows all won combos, as if you streaked them :) Takes lg filters just like !streak does.

.echo /me slides a $(cheerscontainer) of $(cheersdrink) across the bar to ${*:-${nick}}$(if $* ", courtesy of $nick").

Give someone a random drink. Defaults to yourself.

.echo $(let (c (fullclass $1)) (!lg * playable cls="$c" $(ignore $1)$(ignore $2)$* crace!=$(!lg ${2:-.} cls="$c" $* s=regexp_replace(char, "..$", "") fmt:"${.}" join:'|' title:'') s=char o=-. fmt:"${.}" title:"Available combos for $(name_fixup ${2:-.}) to oneandwon with $1$(argst $*)" stub:"No vailable combos for $(name_fixup ${2:-.}) to oneandwon with $1$(argst $*)"))

Prints combos that the user hasn't played yet for the supplied class. Syntax: !classcanwonandwon <class abbreviation>

.echo $(map (fn (p) (.echo $p${1})) (sort (split "|" (!lg * playable current alpha s=regexp_replace(char, "..$", "") join:"|" fmt:"${.}"))))

Makes 4-letter combo words with currently playable species and the supplied 2-letter class. Try !classwords ll

.echo $(!cmd $2 $(re-replace-n 1 '.*?=>' '' (!cmd $1)))

Command copy-paste. Copy the instructions of one command to a new command (or overwriting an existing one!), leaving the first command intact. Syntax: !cmdcp <old command name> <new command name>. Try !cmdcp !test !test2

!cmdsearch

see {!help:!cmdsearch}

!help $*

An alias to !help to work around Cerebot's overriding of !help. It gives you information about a command. Try: !cmdhelp !crystalball

!cmd -$(.echo ls)

Alias for !cmd -ls. Lists user-defined commands.

.echo $(do (!cmd $2 $(re-replace-n 1 '.*?=>' '' (!cmd $1))) (!cmd -rm $1))

Move a command to a new home, deleting the old name and possibly overwriting the new name. Syntax: !cmdmv <old name> <new name>

.echo $(filter (fn (keyword) (re-find "$*" $keyword)) (split ", " (replace "User Commands: " (!cmd -ls))))

Find command names that partially match a given regex pattern. Syntax: !cmdsearch <regex>. Try: !cmdsearch player

.echo /me hands ${1:-${user}} a $(randnth (list cup mug pot)) of $(coffee), brewed by $(rng-god-uniq).

Get coffee brewed by a random god or unique. Syntax: !coffee [drinker]

!rng heads tails

Flips a coin. Expect Heads or Tails.

.echo Combo fanatics$(argst $*): $(join ", " (map (fn (x) "$(elt 1 $x) $(first $x)x $(elt 2 $x)") (sortby (fn (x) (* -1 (int (first $x)))) (map split (split ", " (!lg * $* s=char,name won fmt:'$(groupcount $n_x) ${.}' pfmt:'$(first (split ", " $child)) ${.}'))))))

Lists the player with the most wins for each combo. Syntax: !combofanatics [lg args]. Try !combofanatics gn

!lg ${1:-.} $(replace " " | (ldbent-text (ldb words 1))) won console s=char fmt:"$name is a coolplayer!" stub:"$name is not a coolplayer!" title:"" join:" "

Reveals to all present if you're a cool player. Obviously, cool players have an online console win with a species/background combo whose abbreviation is a real word. e.g.: Barachi Necromancer = bane. Syntax: !coolplayer [playernick]

!crashlog

see {!help:!crashlog}

!lm ${*:-!ignoredcrashers} crash -log

Print the log for the most recent crash milestone. Syntax: !crashlog [playernick] [lm filters]

.echo $(name_fixup ${1:-.}) $(let* (lm (split | (=rip.lm $1 $*)) game (split | (!rg * $(=rip.opts) xl>=$lm[2] xl<=$(* 1.5 $lm[2]) absdepth>$lm[6] fmt:"$vmsg|$place|$sc|$turn|$dur|$xl"))) (ripformat $lm[0] $lm[1] $game[5] $lm[3] $game[0] $game[1] $game[2] $game[3] $game[4]))

A command that uses the cursed vision of Ashenzari to peer into the future and foretell your certain doom!

.echo $(let (l (length (re-replace '[^!]' '' $*))) (if (> $l 1) (+ 1 (=maxdam $(- $l 1)))" - "(=maxdam $l) (if (= $l 1) "7.0 - 17.0" "0.0 - 7.0")))

Calculates damage for a supplied hit message. Syntax: !dam Message_ending_in_exclamation_marks!!!

.echo $(name_fixup ${1:-.}) wins approximately once per $(let (age $(int $(let (first $(ptime $(!lg $(name_fixup ${1:-.}) x=min(end) fmt:"${x[0]}" stub:'$(ftime $(utc $(time)) "%Y-%m-%d %H:%M:%S")') "%Y-%m-%d %H:%M:%S") now $(utc $(time))) (- $now $first)))) (/ (float $age) $(!lg $(name_fixup ${1:-.}) won $* fmt:"${n}"))) days

The average number of real-life days between each win for a given player. Syntax: !daysperwin [playernick] [lg filters]

.echo https://dcss-stats.com/players/$(lower (nth 0 (split ' ' (nick-aliases (name_fixup ${1:-.})))))

Links to your https://dcss-stats.com/ stats page.

!lg ${*:-*} start>20101115 fe-- won gid!=$(!lm ${*:-*} death won s=gid join:"|") s=name,char -opt:(title:"Deathless wins for ${*:-*}")

Lists felid wins where the felid never died. Syntax: !deathless [playernick] [filters that work in both !lg and !lm]

!oneandwonchar

Randomly picks a char you have never played, weighted by recent wins

.echo $(let (l (length (split , (!lg $(name_fixup $*) rstart=$(!lg $(name_fixup $*) s=char x=min(rstart) fmt:"${x[0]}" join:"|") won s=char stub:"")))) (if (> $l 9) "$(name_fixup $*) is a decent player. $l oneandwon wins$(attack-strength-punctuation $l)" "$(name_fixup $*) is not a decent player. $l oneandwon wins ($(- 10 $l) to go)."))

Decent players are defined as having at least 10 "oneandwon" combos - species/background combos that were won on the first try. This command displays how many oneandwon combos a player has won. Syntax: !decentplayer [playernick]

.echo https://en.wiktionary.org/w/index.php?search=$(replace " " + $*)

Search the english language wikitionary. Syntax: !define <word or phrase>

!lm ${1:-.} cv>=0.31-a dreamshard !cat $* / ((won || ${lg:turns>=turns+100})) title:"Dreamshard savior% for $(name_fixup ${1:-.})$(argst $*)"

Percentage of times the dreamshard shattered but the player survived at least 100 more turns. Excludes felids for cheating. Try !dreamsaved * recent s=br

&dump

see {!help:&dump}

.echo $(let* (info (split (!lg ${1:-.} $* x=gid,char,ktype,dur notitle fmt:'${x[0]} ${x[1]} ${x[2]} ${x[3]}')) out (!lm * gid=$(nth 0 $info) !portal !arena !crucible br.enter|rune|orb|god.worship s=noun x=-min(dur) fmtsimple title:"Summary for $(nth 0 $info) $(nth 1 $info)" stub:"N/A")) $(if (= 'N/A' $out) "No games found for $(name_fixup ${1:-.})$(argst $*)" "$out, $(nth 2 $info) [$(nth 3 $info)]"))

Shows the order and duration of various important milestones for a single game. Usage: !dursummary <lg args for the game>. Try !dursummary !bot t won min(dur) or !dursummary !bot recent urune=15 min(dur) -2

.echo $(let* (sortbyfirst (fn (l r) (- (car $r) (car $l))) format (fn (x) "$(cdr $x) $(car $x)%") xs (split "|" (!lg * x=count(name) fmt:'$(re-replace ".*\((.*)%.*" $1 ${x[0]}) ${.}' notitle join:'|' / won $*))) "Ratio of players that won:tried$(argst $*): $(join ", " (map $format (sort $sortbyfirst $xs)))")

Ratio of players that eventually won a character. Takes !lg arguments and works best with "s=" Try [!eventuallywon gn s=char recent] or [!eventuallywon bygod recent] or [!eventuallywon bysp playable:sp recent]

.echo $(sprintf "$* degrees C is %1.1f degrees F" $(+ (* $1 1.8) 32))

Converts C to F. Syntax: !fahrenheit <degress C>. Try !fahrenheit 100

.echo Hours per win with at least ${1:-10} games and ${2:-1} wins$(argst $*): $(join ", " (map (fn (xs) (sprintf "%s: %.1f" (nth 0 $xs) (nth 1 $xs))) (sortby (fn (xs) (float (nth 1 $xs))) (split ", " (!lg * s=name x=sum(dur) $* / won notitle fmt:'${.} $(/ (/ (pduration (re-replace ".*/(.*) \(.*" "$1" ${x[0]})) $(float (re-replace "\/.*" ${n_x}))) 3600)' ?: den.N>=${1:-10} N>=${2:-1})))))

Lists total playtime divided by wins for each player in ascending order. Syntax: !fastestperwin <minimum games played> <minimum wins> <listgame arguments> Try: !fastestperwin 10 10 recent or !fastestperwin 10 1 t

.echo Latest versions seen in milestones this week$(argst $*): $(let* (sourceversions (reverse-hash (mergehash (mappedhash (fn (ignore) "None") (serverlist)) (apply hash (split ' ' (=fastversions.lm $*)))))) $(join (map (fn (k) "[$(elt $k $sourceversions)] => $k") (sort (hash-keys $sourceversions)))))

Like &versions but much faster and easier to read! Only one !lm query. Takes !lm filters if you want for some reason.

.echo $(let (gid $(!lm $* x=gid fmt:"${x[0]}")) $(!lm * gid=$gid fmt:"${name}, ${char}: ")" "$(nth -1 (split " " (!lm * gid=$gid s=turn x=max(AC),max(EV),max(SH),max(mhp/10),max(absdepth) -graph:area))))

Link to a graph that tracks your defense stats and depth over your last (or current) game. Syntax: !gamegraph [playernick] [lm filters]

!lm ${1:-.} $* x=str,int,dex,gid fmt:'${name} the L${xl} ${char}^$(=godshortname ${god}) in ${place} ($src $(if $tiles tiles console)), ${dur}, T:$turn$(if ${urune} ", runes: ${urune} ($(=lastrunes * gid=${x[3]})$(if (> ${urune} 3) ...))"), defenses: ${ac}/${ev}/${sh}, stats: ${x[0]}/${x[1]}/$x[2]$(if ${fifteenskills} ", >15 skills: ${fifteenskills}")$(if ${maxskills} ", Max skills: ${maxskills}")'

List a useful summary of your most recent milestone. Syntax: !gameinfo [playernick] [lm filters]

.echo $(let (path (gamepath_query $*)) (if (= (length $path) 0) "No milestones found." (format_autocompress $path (list gamepath_format_normal gamepath_format_compressed1 gamepath_format_compressed2 gamepath_format_compressed3 gamepath_format_compressed4))))

List how many turns it took each branch in the most recently finished game. Syntax: !gamepath [playernick] [lg filters]

.echo $(let* (interest (re-replace "^-" $1) ordering (if (= - (first $1)) "min($interest)" "max($interest)")) (if $1 (!lg * x=name,char,god,$interest $ordering fmt:'$x[3] $x[0] $x[1]^$(godletter $x[2])' title:"Games by $1 $(argst $*)" -count:50 $*) $(!help gamesbyx)))

Shows the first 50 games sorted by a provided logfile field. If sorts by biggest first unless you prepend "-". Syntax: !gamesbyx [logfile field] <lg args>. Try: [!gamesbyx -kills t won] or [!gamesbyx goldfound .] or [!gamesbyx -dur won !bot] For a list of logfile fields see ??lg

.echo $(let (player (name_fixup $*)) (try (!lg ${*:-$user} rstart>$(!lg ${*:-$user} won -1 fmt:"$end") s=char title:"$n games since last win for $player" fmt:"${n_x}${.}" stub:"No games played since last win for $player.") (!lg ${*:-$user} s=char title:"$n games since last win for $player" fmt:"${n_x}${.}" stub:"No games played since last win for $player.")))

Lists which combos you've lost after your most recent win. Syntax: !gamestriedsincelastwin [playernick] [lg args]

.echo $(if (> 8 (!lg ${1:-.} dr won race!=mottled_draconian|draconian x=count(race) fmt:'${x[0]}' stub:'0')) (!tiamat ${1:-.} $*) (!lg ${1:-.} dr $* x=sum(dur) title:"$n Draconian games before Tiamat for $(name_fixup ${1:-.})$(argst $*)" rend<=$(re-replace ",.*" "" $(!lg ${1:-.} dr won s=race x=+min(rend) fmt:'${x}' notitle))))

How many draconian games and how much draconian playtime it took before a player won with all draconian colours. Syntax: !gamesuntiltiamat [playernick] [lg args]

!lg ${1:-.} $* rstart<=$(!lg ${1:-.} $* won 1 fmt:"$start" stub:"0") fmt:"$(name_fixup $1) had \$(- \$n 1) games before their first win$(argst $*)." stub:"No wins for $(name_fixup $1)."

How many games the player played before winning. Syntax: !gamesuntilwin [playernick] [lg args]

.echo $(gamesuntilwonhelper ${1:-.} $* (=gamesuntilwonbg.lg ${1:-.} $*))

Show how many games it took to win for each background. Try [!gamesuntilwonbg] or [!gamesuntilwonbg . human]

.echo $(gamesuntilwonhelper ${1:-.} $* (=gamesuntilwonchar.lg ${1:-.} $*))

Show how many games it took to win for each combo. Try [!gamesuntilwonchar] or [!gamesuntilwonchar . gnoll]

.echo $(gamesuntilwonhelper-nchoice $* (=gamesuntilwonnchoice.lg ${1:-nchoice} ${2:-t} $*))

For each nemelex choice combo, how many games did it take until the first win? Syntax: !gamesuntilwonnchoice [nchoice keyword eg "nchoice-0.33"] [tournament keyword eg "t0.33-games"] [lg filters]

.echo $(gamesuntilwonhelper ${1:-.} $* (=gamesuntilwonsp.lg ${1:-.} $*))

Show how many games it took to win for each species. Try [!gamesuntilwonsp] or [!gamesuntilwonsp . monk]

!lg ${1:-.} won rend>$(!lg ${1:-.} $* fmt:"$end" stub:"error") fmt:"$n" stub:"0"

How many games you won since the last game that matches given parameters. Syntax: !gameswonsince <playernick> <lg args>

!lg ${1:-.} $* killer~~'s_ghost s=killer title:"$n deaths to player ghosts for $(name_fixup ${1:-.})" stub:"No deaths to player ghosts for $(name_fixup ${1:-.})"

Lists ghost deaths for a given player. Syntax !gdeaths [playername] [lg filters]

!lg * vmsg=~"11 gems (all intact)" s=name title:"Players who really gemmed it$(argst $*)" stub:"No all-gem winners$(argst $*)" $*

Lists players that obtained all gems without shattering any.

.echo $(let* (ends (=gemratio.ends $1 $2 $*) gems $(=gemratio.gems $1 $2 $*) intact (nth 0 $gems) found (nth 1 $gems) lost (nth 2 $gems)) (if $1 (sprintf "$intact intact gems ($found found, $lost lost) out of $ends $1 branch endings ($(if $(= $(int $ends) 0) 🤷 %0.2f)%%) $(name_fixup [${2:-.})$(argst $*)]" (/ (* $intact 100) (float $ends))) $(!help gemratio)))

Ratio of unshattered gems to br.end milestones for the given branch. Syntax: !gemratio <branch name> [player selector] [lm filters]. Try: !gemratio vaults or !gemratio snake * t

.echo $(let* (all (map split (split '|' (!lg * $* !nchoice playable s=-char notitle stub:"N/A" fmt:'$(re-replace "^(\d+).*" "$1" ${n_x}) ${.}' join:'|' / won))) min (int (car (nth 149 $all))) elig (map (fn (x) (nth 1 $x)) (filter (fn (x) (<= (int (nth 0 $x)) $min)) $all))) "$(length $elig) combos with <=$min wins$(argst $*): $(join '|' (sort $elig))")

Approximated, more automated way of choosing initial nchoice combos. It picks at least 140 combos with the fewest wins + all combos with the same number of wins as the 140th.

!lg * ikiller~~^($(join '|' (nick-aliases (name_fixup ${1:-.}))))$(=apostrophe)s?_ghost $* s=ikiller,name title:"${n} kills by $(name_fixup ${1:-.})'s ghost$(if "${*}" " (${*})" "")"

Lists players that died to a given player's ghost. Syntax: !ghostkills [playernick] [lg filters]

.echo %git $*

Sequell will attempt to pass a %git command to NotCheibriados. You can get a github link for a commit hash, branch name or tag. See https://github.com/crawl/crawl/wiki/Guide-to-the-DCSS-knowledge-Bots for more info.

.echo $(ignore $1)$(let (n $1 s $*) (concat "%git HEAD^{/" $s "}" (repeat (concat "^^{/" $s "}") (- (int $n) 1))))

Search git commits with limited case sensitive regex. The first argument is the match number (e.g. "2" means the second most recent match). Try !gitgrep 1 [oO]rb

!lg * ikiller~~^($(join '|' (nick-aliases (name_fixup_long ${1:-.}))))$(=apostrophe)s?_ghost $* s=name title:"${n} kills by $(name_fixup ${1:-.})'s ghost$(argst $*)"

Find kills by your ghost! Syntax: !gkills [player] [lg filters]

!rg * recent playable won $* fmt:"The RNG chooses: $char"

Will randomly pick a char weighted by number of recent wins

.echo $(let (wins $(nwins ${1:-.}) player $(name_fixup $1)) $(if (>= $wins 10) "$player is a goodplayer: $wins wins$(attack-strength-punctuation $wins)" "$player is not a goodplayer yet: $wins $(plural win $wins) ($(- 10 $wins) to go)."))

Tells you if you're a "goodplayer". A "goodplayer" has at least 10 wins. Syntax: !goodplayer [playernick]

.echo $(let* (sps (unwonsp ${1:-.}) bgs (unwonbg ${1:-.}) name (name_fixup ${1:-.}) args $(argst $*) stub "$name has won all species and backgrounds${args}!") (if (= 0 (length (concat $sps $bgs))) $stub (greatcharrandom $name $args $sps $bgs $stub)))

"Great" as in "great[er]player". Will pick a combo with a species and background you have not won yet. If you've won all species already, it will pick a combo with a background you haven't won (and vice versa). The combo it picks is random but weighted by how often it's played so it tends to pick good ones! Syntax: !greatchar [playername] [combo filters].

!greatchar

see {!help:!greatchar}

!lg * playable:job role!=$(!lg * won s=char / gid=$(=oneandwongids $*) fmt:'$(combo_to_class ${.})' join:"|" stub:"" ?: %!=0) title:"non-oneandwon roles for $(name_fixup $*)" stub:"$(name_fixup $*) is a greateroneandwoner" s=role fmt:"${.}"

Show remaining classes to win through a oneandwon containing that class.

.echo $(do ${1:-.} "")$(greathelper2 cls ${1:-.} backgrounds "greaterplayer (or at least has won every background)" playable:job $*)

Shows you backgrounds you haven't won yet. Syntax: !greaterplayer [playernick] [lg args]

!lg * playable:sp crace!=Barachian crace!=$(!lg * won playable:sp s=char / gid=$(=oneandwongids $*) fmt:'$(combo_to_race ${.})' join:"|" stub:"" ?: %!=0) title:"non-oneandwon races for $(name_fixup $*)" stub:"$(name_fixup $*) is a greatoneandwoner" s=crace fmt:"${.}"

Show remaining species to win through a oneandwon containing that species.

.echo $(do ${1:-.} "")$(greathelper2 crace ${1:-.} species greatplayer playable:sp $*)

Shows you species you haven't won yet. Syntax: !greatplayer [playernick] [lg args]

.echo $(=greatprogress.species $*) | $(=greatprogress.role $*)

Shows how many combos you have to win to get !greatrace/!greatrole for each species/background respectively.

.echo $(let* (charwon (wonchars ${1:-.} *) spunwon (setdiff (playablespls) (map (fn (char) (take 2 $char)) $charwon)) bgunwon (setdiff (playablebgls) (map (fn (char) (drop 2 $char)) $charwon))) "Unwon for $(name_fixup ${1:-.}) | $(if $spunwon "Species: $(sort $spunwon)" "All species won!") | $(if $bgunwon "Backgrounds: $(sort $bgunwon)" "All backgrounds won!")")

Shows you abbreviated species and backgrounds you haven't won yet. Syntax: !greatremaining [playernick]

!rng $(re-replace ',' '' $(re-replace '\b ' '_' $(re-replace '.*: ' ' ' $(!greatplayer ${*:-.}))))

Chooses at random one of unwon species for a specified nickname.

!lm ${1:-.} $* br.enter=tar|geh|coc|dis s=br o=% title:"Death rates in hell branches for $(name_fixup ${1:-.})$(argst $*)" stub:"Death rates in hell branches for $(name_fixup ${1:-.})$(argst $*)" / lg:br=$noun

Shows death rates for the 4 hell branches. The ratios are [players that died in the branch] divided by [players that entered the branch]. Syntax: !helldeathrate [playernick] [lm args]

.echo $(let (skillsleft (sort (setdiff (split ", " (!lg * current s=sk fmt:'${.}')) (split ", " (!lg ${1:-.} won s=sk fmt:'${.}' stub:"" $*))))) (if (= 0 (length $skillsleft)) "$(name_fixup ${1:-.})$(argst $*) has won with each skill as their highest skill!" "Highest skill wins remaining for $(name_fixup ${1:-.})$(argst $*): $(join ", " $skillsleft)"))

Shows you which skills that haven't been your highest skill in a winning game. Syntax: !highestskills [playernick] [lg args]

!lg * ${2:-*} s=char o=-char x=max(sc) / @${1:-.} fmt:"${.}" join:" " title:"${name}'s high scores" stub:"$name has no high scores." ?:%.max(sc)=1

Shows combos for which you have the highest score! Syntax: !highscores [playernick] [lg args].

.echo $(let* (name (name_fixup ${1:-.}) duration (!lg ${1:-.} $* x=sum(dur) notitle fmt:'$x') wins (!lg ${1:-.} $* won notitle fmt:'${n}') avg (/ (/ (float (pduration $duration)) $wins) 3600)) (if (> $wins 0) (sprintf "Total playtime divided by wins for $name$(argst $*): %1.2f hours/win" $avg) "No wins for $name$(argst $*)... yet!"))

Hours played divided by number of wins. How long it takes you to get a win on average. Try !hoursperwin . recent

.echo $(let (version-starts (split ", " (!lg * s=cv cv!= cv>=0.13 !0.29timetraveler !alpha x=-min(start) fmt:'${.} $x'))) "Months spent in development: $(join ' ' (map (fn (i) $(sprintf "[%s %.1f]" (nth 0 (elt $i $version-starts)) (/ (deltaseconds (join ' ' (sub 1 (split ' ' (elt (- $i 1) $version-starts)))) (join ' ' (sub 1 (split ' ' (elt $i $version-starts))))) 2628000.0))) (range (- (length $version-starts) 1) 1 -1)))")

Shows about how many months each version spent in development. It is a slow command so be patient. A "month" is 365/12=30.4 days in this context.

.echo $(if $* (let* (t (split " " $*) apt (nth 1 (split "=" (!apt $t[0] HP))) xl $t[1] f $t[2]) "HP apt: "$apt", XL: "$xl", Fighting: "$f" => MHP = "$(int (* (+ (int (* 5.5 $xl)) 8 (int (* $xl (/ $f 14.0))) (int (/ (+ 1 (* 3 $f)) 2.0))) (+ 1 (/ $apt 10.0))))) "Usage: !hp [species] [XL] [Fighting]")

Usage: !hp [species] [XL] [Fighting]. Calculate the maximum HP for a character with a given species, experience level, and Fighting skill.

!lg $* max=sc

Shows the single highest scoring game. Syntax: !hs [playernick] [lg args]

.echo Players with the most combo highscores$(argst $*): $(join ", " (map (fn (kv) "$kv[0]: $kv[1]") (sortby (fn (kv) (* -1 (int $kv[1]))) (freqhash (split ", " (!lg * won s=char,gid x=+min(sc),min(name) fmt:'$x[1]' pfmt:'$(nth 0 (split ", " $child))' $*))))))

List players by the number of combo highscore win records they have. Note that sequell and the CAO scorepage consider some combos in different ways: this command will consider Gnoll Hexslinger and Gnoll Arcane Marksman to be the same combo but CAO won't. Try: !hscounts t or !hscounts playable

!lg ${1:-.} won vmsg~~'\d+ gems? \((?:\w+ )?intact!?\)' s=int(regexp_replace(regexp_replace(regexp_replace(regexp_replace(vmsg, '.*and (\d+) gems? \(intact!?\).*', '1'), '.*and (\d+) gems? \(both intact!?\).*', '2'), '.*and (\d+) gems? \(all intact!?\).*', "\1"), '.*and \d+ gems? \((\w+) intact!?\).*', "\1")) o=-. title:"Intact gem wins for $(name_fixup ${1:-.})$(argst $*)" stub:"No gem wins for $(name_fixup ${1:-.})$(argst $*)" $*

Lists intact gems obtained during winning games for the selected player(s). Only includes games that have some gems ("0" means all their gems shattered).

.echo $(=time_since_milestone weekmilestone $*) since last activity ($(replace . $nick $*))

Shows time since the last milestone satisfying a supplied condition. Syntax: !isonline <!lm_condition> | Examples: !isonline <servername> | !isonline @nickname

!killratioall $1 ${2:-*} ${3:-recent} $*

Displays the number of player deaths/number of unique deaths. Only works for uniques!

.echo $(!kw $1 $(=kw $1)$*)

Add something to the end of a sequell keyword. Syntax: !kw-append <keyword> <string to append>

.echo $(filter (fn (keyword) (re-find "$*" $keyword)) (split ", " (replace "User keywords: " (!kw -ls))))

Search for sequell keywords using regex. Syntax: !kwsearch <regex>

.echo $(let (x (!lm ${1:-.} $* br.enter=lair ktyp!= x=cdist(gid) fmt:"${x}" stub:"0") y (!lg ${1:-.} $* fmt:"${n}" stub:"0") player (name_fixup $1)) "${player}$(if "${*}" " (${*})" "") has reached Lair in $x of $y attempts: $(int (+ 0.5 (/ (* 100.0 $x) $y)))%")

Shows how often your games entered lair. Syntax: !lairratio [playernick] [lg and lm args]

!won ${2:-.} $* rend>=$(!lg ${2:-.} $* fmt:"${rend}" -${1:-100})

Usage: !last <number> <player> <other args>, shows wins in the last x games played. e.g. !last 50 . Be

!lg * $* won s=-end x=max(end),max(name),max(char) fmt:'${x[1]} (${x[2]})' rend>=$(!lg * $* won -10 fmt:"$end") title:"last 10 wins $(if $* "for $* " " ")are"

This command shows the last 10 games won on any public server(s)

!lg ${1:-.} $(split " " $*) x=xl,char,god,ckiller -count:10 fmt:'L${x[0]} ${x[1]}^$(=godshortname ${x[2]}) (${x[3]})' title:"Last 10 games for $(name_fixup $1)" stub:"No games for $(name_fixup $1)"

Shows information about the last 10 games you played (or played by the person in the command argument)

!lm ${*:-.} alive fmt:"${*:-${user}} was last seen on \$(upper $src) ($name, L$xl $char of ${god:-No God})." stub:"Failed to locate ${*:-${user}}."

Find most recent "recent" game that hasn't ended yet. Syntax: !locate [playernick] [lm args]

.echo $(or $(join " || " $(split " | ^" $(sub 1 $(=locateall.raw $*)))) "Failed to locate $(name_fixup "$*").")

Locates ongoing games in recent versions. Syntax: !locateall [playernick] [lm args]

.echo $(or $(join " || " $(split " | ^" $(sub 1 $(=locateall.rawall $*)))) "Failed to locate $(name_fixup "$*").")

Locates ongoing games in all versions. Syntax: !locateallall [playernick] [lm args]

!lg ${*:-.} -log

Shows a game morgue. Equivalent to "!lg [whatever] -log"

!lg xyz x=log($*) fmt:"${x[0]}"

Find the base 10 log of a given number. Try: !log10 100 or !log10 15.5

!lm ${1:-.} mark newmakhleb $* s=regexp_replace(noun, "accepted the Mark of( the)?", "") title:"Makhleb marks taken by $(name_fixup ${1:-.})$(argst $*)" stub:"No Makhleb marks taken by $(name_fixup ${1:-.})$(argst $*)"

Shows you which marks you've taken. Syntax: !makhlebmarks [playernick] [lm args]. Try: [!makhlebmarks . won] or [!makhlebmarks * recent / won o=%]

.echo $(let* (times (split '|' $(!lg * $* s=name x=median(dur) o=median(dur) fmt:'$x' notitle join:'|' stub:'N/A')) median (if (= $times 'N/A') "N/A" (elt (/ (length $times) 2) $times))) "Median game duration of the median player$(argst $*): $median")

The median game duration of the median player. A reasonable indicator of how long a game typically lasts. Try !mediandur * recent won urune=3

.echo $(name_fixup ${1:-.})$(argst $*) megaprogress: $(let (num (!lg ${1:-.} $* won !trunkonly x=cdist(char) fmt:"${x[0]}") den (!lg * cao !alpha cv>=0.10 crace!=LO|Yak x=cdist(char) fmt:"${x[0]}")) $num"/"$den" ("$(/ (* 100 $num) $den)"%)")

It includes all combos from stable that are playable online now, starting from 0.10 and excluding trunk-only combos

.echo $(let* (re (comboregex ${2:-----}) filt (fn (ls) (filter (fn (char) (re-find $re (lower $char))) $ls)) denom (length (filt (playableallls))) numer (- $denom (length (filt (unwon_raw (playableallls) ${1:-.} *))))) "Megaprogress for $(name_fixup ${1:-.})$(argst ${2:-}): $(percent-print $numer $denom).")

Like !megaprogress but much faster, at the expense of less flexible filters. Shows your progress with all sp/bg combos that are playable in stable versions online. Optionally takes filters in the form of sp-- or --bg. Try: !megaprogress2 . --fe

!lg * $(ignore $1)$* s=char o=-char char=$(!lg * cao !alpha cv>=0.10 crace!=LO|Yak s=char fmt:'${.}' join:'|' notitle) title:"Unwon megaprogress chars$(argst $*)" stub:"All megaprogress chars have been won$(argst $*)" join:' ' fmt:"${.}" / won $(if $1 @$1) ?: N=0

Shows unwon combos that are playable in stable online versions. Try: !megaunwon . gn

.echo $(let* (re (comboregex ${2:-----}) combos (filter (fn (char) (re-find $re (lower $char))) (unwon_raw (playableallls) ${1:-.} *)) name $(name_fixup ${1:-.}) args $(argst ${2:-})) (if $combos "Unwon playable$args combos for $name: $combos" "$name has won all playable$args combos!"))

Like !megaunwon but much faster at the expense of less flexible filters. Shows unwon combos that are playable in stable online versions. Filters are in the form of sp-- or --bg. Try: !megaunwon2 . gn--

.echo $(let* (monster (findmonster ${*:-hydra}) time (secondssince (stamptime (!lg * cikiller="$monster" x=end fmt:'${x[0]}')))) (if $monster "The ${monster}s are $(if (< $time 300) "happy!" (if (< $time 3600) "content." (if (< $time 86400) "restless." "angry!")))" "No recent games with cikiller $*"))

A silly command that tells you how a monster type is feeling, under the assumption that monsters are happier when they've killed a player recently. Spaces are ignored and you can use ^ to match the start or $ to match the end of the monster name. Try [!monsterfeelings orboffire] or [!monsterfeelings elf pyro] or [!monsterfeelings ^orc$].

.echo $(let* (n (int ${1:-1}) combos (sort (map (fn (kv) (elt 0 $kv)) (filter (fn (kv) (= (- $n 1) (indexof w (split "" (sub 0 $n (elt 1 $kv)))))) (apply hash (split > (=nandwonlg ${2:-.} $*)))))) len (length $combos) name "$(name_fixup ${2:-.})$(argst $*)") (if (= 0 $len) "No ${n}-and-won combos for $name." "$len ${n}-and-won combos for $name: $(join " " $combos)"))

See which characters you won on exactly the Nth try! Syntax: !nandwon [N] [playernick] [lg filters]

.echo $(let (combo (if (is_int ${1:--1}) (nth (int ${1:--1}) $(split | (replace " => " | (!kw nchoice)))) $1)) (let (wins (!lg * t won char=$combo fmt:"$n" stub:"0")) (if (and (> (int $wins) 0) (= ${1:-x} x)) (=nchoice.new) (concat (canonicalise char $combo) ": $wins $(plural win (int $wins)) || " (or (=lastnchoice.combostatus $combo) "No $combo games in progress.")))))

Shows information about nchoice games during the tournament. Syntax: !nchoice [combo]

.echo $(map (fn (x) (concat (nth 1 $x) "(" (nth 0 $x) "),")) (transpose (list (sub 0 -1 (split | (=kw nchoice))) (split " " (!nchoice-credit.helper)))))

Shows the first player to win each nchoice combo during the tournament.

!lg * t nchoice $* s=regexp_replace(char, "^..", "") x=+cdist(char) fmt:"${.}: $x[0]" title:"Nemelex Choice class combo counts$(argst $*)"

How many of each class was in the most recent set of nchoice combos?

.echo Most nchoices won: $(join ", " (sortby (fn (kv) (* -1 (int (nth 1 $kv)))) (map (fn (kv) "$kv[0] $kv[1]") (freqhash (split (!lg * won t nchoice s=char,gid x=-min(rend),min(name) fmt:'$x[1]' pfmt:'$(sub 0 9 (split $child))' join:' '))))))

Shows how many nchoices each player "got" (by being one of the first 9 to win). Might be slightly more up to date than the website.

!lg * nem-eligible !nchoice t won $* s=char fmt:'${.}' title:"Ruined (formerly) eligible nemelex choice combos$(argst $*)" stub:"No eligible nemelex choice combos$(argst $*) have been ruined!"

Which elibigle nchoice combos were disqualified by being won before being chosen.

!lg * t nchoice $* s=regexp_replace(char, "..$", "") x=+cdist(char) fmt:"${.}: $x[0]" title:"Nemelex Choice species combo counts$(argst $*)"

How many of each species was in the most recent set of nchoice combos?

.echo $(let* (combotimes (nchoicetimes-ct ${1:-t} ${2:-nchoice}) times (cons (rtime-to-time (!lg * ${1:-t} min(start) x=start fmt:'$x[0]')) (map (fn (ct) $ct[1]) $combotimes))) (join ", " (map (fn (i) "$(nth 0 (nth (- (int $i) 1) $combotimes)) $(deltatime (elt (- $i 1) $times) (elt $i $times))") (range 1 (- (length $times) 1)))))

Shows the time taken to win each nchoice combo; measuring the difference between the time the nchoice combo became availible to when it was first won. Syntax: !nchoicetimes [tournament keyword] [nchoice keyword]

!lg * title:"Neglected combos$(argst $*)" playable s=char won x=+min(now() - end) fmtxyears $*

Shows the most "neglected" playable combos - combos that haven't been won in the longest time. Combos that have never been won won't show up (for those, see !neverwon). Try [!neglected] or [!neglected sp].

!echo $(let* (nc (nem-chosen) nr (nem-remaining) nw (nem-weights $nc $nr) tw (apply ${+} $nw) num (length $nr)) (.echo Remaining eligible Nemelex Choices (chance): $(map (fn (i) (sprintf "$(elt $i $nr)(%2.2f%%)" (* 100 (/ (float (elt $i $nw)) $tw)))) (reverse (sort (fn (x y) (<=> (elt $x $nw) (elt $y $nw))) (range 0 (- $num 1)))))))

What are the odds that an eligible nchoice combo will be picked next?

.echo $(let* (nc (nem-chosen) nr (nem-remaining) nw (nem-weights $nc $nr) tw (apply ${+} $nw) fnr (apply nem-remaining-filtered || (split " " $*)) ids (subset-ids $nr $fnr)) (.echo possible nchoices$(argst $*): $(map (fn (i) (sprintf "$(elt $i $nr)(%2.2f%%)" (* 100 (/ (float (elt $i $nw)) $tw)))) (reverse (sort (fn (x y) (<=> (elt $x $nw) (elt $y $nw))) $ids)))))

What are the odds that an eligible nchoice combo will be picked next? Takes lg filters, but negated. Try: [!nem-chances-filtered !op] to see octopode combo chances.

!echo $(nem-remaining)

Which combos are eligible nchoices that haven't been disqualified (by being won or picked already).

!lg * recent ${1:-nem-eligible} $* s=regexp_replace(char, "^..", "") x=+cdist(char) fmt:"${.}: $x[0]" title:"Eligible Nemelex Choice class combo counts (${1:-nem-eligible})$(argst $*)"

Find out how many of each background are in the nem-eligible keyword (ignoring if they've been picked or disqualified). Syntax: !nemeligibleclasscounts [nem-eligible keyword]

!lg * recent ${1:-nem-eligible} $* s=regexp_replace(char, "..$", "") x=+cdist(char) fmt:"${.}: $x[0]" title:"Eligible Nemelex Choice species combo counts (${1:-nem-eligible})$(argst $*)"

Find out how many of each species are in the nem-eligible keyword (ignoring if they've been picked or disqualified). Syntax: !nemeligiblespeciescounts [nem-eligible keyword]

.echo $(let* (p ${1:-${user}} c (last_win $p) e (exact-entry ~${p}_next 1) needcombo (or (= '' $e) (has_won $p $e)) char (if $needcombo (=newnext $p) $e)) (next_output $p $c $e $needcombo $char))

Gives you a combo that you haven't won yet. Will remember your current combo and only change when you win it; only available for players who have already won. See !help !next-pref and !help !next-cheat for other options.

.echo $(no_pm (do (if (= 0 (length (exact-entry ~${user}_next 1))) "" (ldb-rm! ~${user}_next 1)) (!next)))

Rerolls your current !next combo. Cheating!

.echo $(no_pm (do (if (= 0 (entrylength ~${user}_pref)) (ldb-add ~${user}_pref 1 "$*") (ldb-set! ~${user}_pref 1 "$*")) "New !next preferences for ${user}: ${*}."))$(ignore (concat $*))

Sets restrictions on what combos !next will give you, e.g. "!next-pref --en !mu--" to receive a random non-mummy enchanter you haven't won yet. Use !next-pref-append to add new restrictions on at the end of your current prefs.

.echo $(no_pm (do (if (= 0 (entrylength ~${user}_pref)) (ldb-add ~${user}_pref 1 "$*") (ldb-set! ~${user}_pref 1 "$(entry ~${user}_pref 1) $*")) "New !next preferences for ${user}: $(entry ~${user}_pref 1)."))$(ignore (concat $*))

see {!help:!next-pref}

.echo $(let (results (!nick $1)) (if (str-find? "No nick mapping for" $results) 0 (- (length (split " " $results)) 3)))

Count how many words (usually player names) are in a nick. Try !nicklength greatplayers

.echo $(let* (name (name_fixup ${1:-.}) autsec (split (!lg ${1:-.} x=sum(aut),sum(dur) notitle fmt:"${x[0]} ${x[1]}" $*)) aut (float (elt 0 $autsec)) secs (pduration (elt 1 $autsec))) (sprintf "There are %1.2f non-arbitrary units of time per second for $name$(argst $*)." (/ $aut $secs)))

Find out how much real-life time the average aut is for the selected games. Try !nonaut . recent

.echo $(let (combo (if (is_int ${1:--1}) (nth (int ${1:--1}) $(split | (replace " => " | (!kw nchoice)))) $1)) (let (wins (!lg * t won char=$combo fmt:"$n" stub:"0")) (if (and (> (int $wins) 0) (= ${1:-x} x)) (=nchoice.new) (concat (canonicalise char $combo) ": $wins $(plural win (int $wins)) || " (or (=lastnchoice.combostatus2 $combo) "No $combo games in progress.")))))

Shows where the current nchoice characters are. Optionally you can supply it with a number or combo code to check that combo. Syntax: !nchoice [nth or combo]

.echo $(let (l (length (split , (!lg ${1:-.} $* rstart=$(!lg ${1:-.} $* s=char x=min(rstart) fmt:"${x[0]}" join:"|") won s=char stub:"")))) (!lg ${1:-.} $* rstart=$(!lg ${1:-.} $* s=char x=min(rstart) fmt:"${x[0]}" join:"|") won s=char title:"$l chars won first try for $name" stub:"No chars won on first try for $name"))

Show combos won on the first attempt of that combo.

!rg * playable won char!=$(!lg ${1:-.} s=char join:"|" fmt:"${.}" stub:"") $* fmt:"The RNG chooses: $char" stub:"${1:-.} has played every char."

Pick a random character that you haven't played yet, weighted by how often it has been won.

!lg ${1:-.} $* rstart=$(!lg ${1:-.} $* s=class x=min(rstart) fmt:"${x[0]}" join:"|") won s=class title:"classes won first try for $name" stub:"No classes won on first try for $name"

Shows which classes you won on the first try! Syntax: !oneandwonclass [player nick] [lg args]

!lg ${1:-.} $* rstart=$(!lg ${1:-.} $* s=god x=min(rstart) fmt:"${x[0]}" join:"|") won s=god title:"Gods won first try for $name" stub:"No gods won on first try for $name"

Which gods did you win with first try? Type !oneandwongods and see!

!lg ${1:-.} $* rstart=$(!lg ${1:-.} $* s=crace x=min(rstart) fmt:"${x[0]}" join:"|") won s=crace title:"Races won first try for $name" stub:"No species won on first try for $name"

Shows which species you won on the first try! Syntax: !oneandwonspecies [player nick] [lg args]

!lg * gid=$(!lm * orb killer=Boris s=gid fmt:"${.}" stub:"0" join:"|") stub:"No orb run kills for Boris yet." $*

Shows the last time Boris killed a player during the orb run (no felid mini-deaths don't count!).

!lg ${1:-.} $* x=tdam,mhp tdam>=${mhp} tdam>70 !((ak place=abyss xl<5)) stub:"$name hasn't been owned by Crawl yet. $name should play some more ;)"

Games in which the player lost all of their hp in a single turn. The damage must be greater than 70 and low level AKs in abyss don't count. Try: !owned or !owned * recent

.echo $(if (and (= 2 (length (split $*))) (re-find "^\d+\.?\d*$" $1) (re-find "^\d+\.?\d*$" $2)) (percent $1 $2) (!help !percent))

You must give it 2 numbers. It takes the first number and divides it by the second number. Try: !percent 1 3

.echo $(let* (name $(name_fixup ${1:-$user}) won (=personality.won ${1:-.} $*) sp (=personality.sp $won $1 $*) bg (=personality.bg $won $1 $*) god (=personality.god $won $1 $*) enemies (=personality.enemies $1 $*) skills (=personality.skills $1 $*) places (=personality.places $1 $*)) "$name loves $sp, $bg, and $god but hates $enemies. $name is good at $skills but bad at $places.")

A cute lil blurb about your crawl games. Uses +sum(dur) to rank everything so lategame statistics are weighted more than early game statistics (though there are typically more games that end early and those add up!). Try [!personality] or [!personality * t] or [!personality . recentishish] or [!personality @greatplayers chei recent]

.echo $(greathelper god ${1:-.} gods polytheist "won playable:god")

Show which gods you have not won while worshiping.

!lm ${1:-.} portal br.enter $* s=br o=% title:"Portal death rates for $(name_fixup ${1:-.})$(argst $*)" stub:"No portal entries for $(name_fixup ${1:-.})$(argst $*)"/ lg:br=$noun

Shows the ratio of players that died in a portal branch to players that entered that branch. Syntax: !portaldeathrates [playernick] [lm args]

.echo https://github.com/crawl/crawl/pull/$1

Print a link to a github pull request by number. For example: !pr 3722

.echo $(name_fixup ${1:-.}) progress: $(let (num (!lg ${1:-.} $* playable won x=count(char) fmt:"${x[0]}") den (!lg * playable recent x=count(char) fmt:"${x[0]}")) $num"/"$den" ("$(/ (* 100 $num) $den)"%)")

Shows your progress in winning all currently playable (in trunk) combos. Syntax: !progress [player nick] [lg args]

.echo $(let* (re (comboregex ${2:-----}) filt (fn (ls) (filter (fn (char) (re-find $re (lower $char))) $ls)) denom (length (filt (playablels))) numer (- $denom (length (filt (unwon_raw (playablels) ${1:-.} *))))) "Progress for $(name_fixup ${1:-.})$(argst ${2:-}): $(percent-print $numer $denom).")

Like !progress but much faster in exchange for a less flexible filter. Filter in the form of sp-- or --bg. Shows your progress in winning all currently playable (in trunk) combos. Syntax: !progress2 [player nick] [filter]

!lg ${1:-.} $* char=$(join '|' (split ', ' (re-replace '^[^:]+: ' '' (!oneandwon ${1:-.} $*)))) s=crace won title:"Race oneandwon counts for $(name_fixup $1)$(argst $*)" stub:"No oneandwons for $(name_fixup $1)$(argst $*)"

Counts how many combos you've one-and-won for each species. Syntax: !raceoneandwoncounts [playernick] [lg args]

=racialwill

Show how much will each species gets per level.

!rng $(join ' ' (split '|' $(=kw playable)))

A completely random playable character combo. Some species or backgrounds are *slightly* more or less likely due to some combinations being impossible. Felids are less likely than other species, for example.

.echo $(let* (helpcmds (map (fn (entry) (replace "!help:" $entry)) (ldb-search-terms "!help:")) listcmds (split ", " (replace "User Commands: " (!cmd -ls))) result (randnth (setintersection $helpcmds $listcmds))) (!help $result))

Picks a random command with a description and displays that description.

.echo $(let (eligible (greatvaliddoubles ${1:-.}) name (name_fixup ${1:-.})) (if (> (length $eligible) 0) "Random combo with species or background that $name hasn't won: $(!wtf $(randnth $eligible))" "$name has won all species and backgrounds!"))

Picks a random character combo with a species OR a background you haven't won yet. Doesn't take lg filters. Syntax: !randgreat [playername]

!lm * alive !cdo -random $* time>${now()-interval('10minute')} x=src fmt:'$(lookup ${x[0]} (watchhash))${name}'

Spectate a randomgame that's been active in the last 10 minutes. Syntax: !randomgame [lm args]

!echo $(let* (pl (apply hash (split | (!lm * alive !cdo $* time>${now()-interval('10minute')} x=max(src) s=name join:'|' fmt:'$(lower ${.}|$x[0])' notitle stub:""))) npl (split | (!lg $(join | (hash-keys $pl)) fmt:'$(lower ${.})' join:'|' s=name won notitle stub:"" ?: N<4)) sel (elt (rand (length $npl)) $npl)) (lookup (elt $sel $pl) (watchhash))$sel)

Prints a watch link for a random new player with 1, 2 or 3 wins.

.echo Rare titles for $(name_fixup ${1:-.}): $(join ", " (map (fn (xs) $(replace-n 1 " " / $xs)) (sortby (fn (xs) (- (int (nth 1 $xs)) (int (nth 2 $xs)))) (split ", " (!lg * s=title won notitle fmt:'$(re-replace "(\d+)\/(\d+)x" "$1 $2" ${n_x}) ${.}' / name=${1:-.} ?: N>0)))))

Titles you've won, sorted by the percentage your wins are of all wins (for instance, if you have 2 of the 3 wins for a title, it's 66%). Sorry, if you have 1/4 wins (25%) it'll be treated as less rare than having 2/5 (40%).

=eval $(=rc.helper $*)

Print a player's online rc (settings) file link. Syntax: !rc [playernick] [canonical version] [server acronym]. Try [!rc] or [!rc rypofalem 0.34 cdi]

.echo $(let (x (ldb-canonical-term $*)) (join " / " $(map (fn (n) $(entry $x $n)) $(range 1 $(entrylength $x)))))

Read an entire ldb entry at once. See also !browse.

!lg * recentishish year title:"High winrate players this year$(argst $*) (winrate wins name)" fmt:'${n_ratio} $(re-replace "^(\d+).*" $1 ${n_x}) ${.}' $* s=name o=% / won ?: N>=20

Top winrates in the last year on modern versions (up to 3 versions behind stable). Listed players need 20+ wins under those conditions to be eligible!

!lg ${*:-.} -random

Like !lg, but picks a random game fuifilling the given criteria.

!githubsearch

Like !lm, but picks a random milestone fuifilling the given criteria.

.echo Players with the most combo low realtime records$(argst $*): $(join ", " (map (fn (kv) "$kv[0]: $kv[1]") (sortby (fn (kv) (* -1 (int $kv[1]))) (freqhash (split ", " (!lg * won s=char,gid x=-min(dur),min(name) fmt:'$x[1]' pfmt:'$(nth 0 (split ", " $child))' $*))))))

List players by the number of combo realtime win records they have. Try: !rtcounts t or !rtcounts playable or !rtcounts urune=15

.echo $(let* (all (map split (split '|' (!lg * !nchoice playable s=-char notitle stub:"N/A" fmt:'$(re-replace "^(\d+).*" "$1" ${n_x}) ${.}' join:'|' / $* recentishish won))) min (int (nth 0 (nth 139 $all))) elig (map (fn (x) (nth 1 $x)) (filter (fn (x) (<= (int (nth 0 $x)) $min)) $all))) "$(length $elig) combos with <=$min recentishish wins: $(sort $elig)")

A suggested nchoice combo generation method that measures only recentishish wins and picks at least 140 combos + all combos with the same number of recentishish wins. Hopefully it biases recently added species/backgrounds less.

!lm ${1:-*} $* br.enter=shoals|snake|spider|swamp s=br o=% title:"Death rates in 1st rune S branches for $(name_fixup ${1:-*})$(argst $*)" stub:"Current death rates in S branches for $(name_fixup ${1:-*})$(argst $*)" / lg:br=$noun lg:urune<=1

Branch entry to branch death (with 1 or fewer runes) ratio. Syntax: !sbranchratio [player nick] [lm args]

.echo Approx score for $1 runes in $2 turns: $(* 100000 (int (/ (+ 254000 (* $1 (+ $1 12) 1000) (* 2000 $1) (/ (* 6250000000 $1 $1) $2) 800000) 100000)))

Usage: !score <runes> <turns>

!scoringlink

see {!help:!scoringlink}

.echo https://crawl.akrasiac.org/scoring/players/$(lower (nth 0 (split ' ' (nick-aliases (name_fixup ${1:-.})))))

A link to a player's or nick's scorepage. In the nick case, the first word in the nick is used.

.echo Sending $(ignore $1)$* to ${1}.

Usage: !send <person> <thing>. Sends <thing> to <person> (this is a campaign promise).

!echo $(let* (c (apply (fn (. args) (!ftw $args)) (split ' ' (!wtf $1))) nc (=kw nchoice) pc (nth -1 (split | $nc))) (if (> (str-find ? $c) -1) "Unknown char: $1" (if (> (str-find "No key" $nc) -1) (!kw nchoice $c) (if (= "0" (!lg * t won char=$pc fmt:"$n" stub:"0")) "Current Nemelex Choice $pc isn't won" (!kw nchoice $nc|$c)))))

When !nchoice tells you to use this command, check the tournament website for the next nemelex choice combos and use this command to add them. If there are multiple new combos do add them in order! Syntax: !set-nchoice <4 letter combo>

!lg * playable $* s=char x=-max(sc) title:"The lowest high scores are" fmt:"${.} [${x}]"

Shows you the lowest high score for each combo. Useful if you wish to steal a high score! Try: [!snipe gnoll t]

.echo $(let (r (fullrace $1)) (!lg * playable crace="$r" $(ignore $1)$(ignore $2)$* cls!=$(!lg ${2:-.} crace="$r" $* s=regexp_replace(char, "^..", "") fmt:"${.}" join:'|' title:'') s=char o=-. fmt:"${.}" title:"Available combos for $(name_fixup ${2:-.}) to oneandwon with $1$(argst $*)" stub:"No vailable combos for $(name_fixup ${2:-.}) to oneandwon with $1$(argst $*)"))

Prints combos that the user hasn't played yet for the supplied species. Syntax: !speciescanwonandwon <species abbreviation>

.echo $(map (fn (p) (.echo $1${p})) (sort (split "|" (!lg * playable current alpha s=regexp_replace(char, "^..", "") join:"|" fmt:"${.}"))))

Prints potential 4-letter combos for a supplied 2-letter species. Try: !specieswords Li

.echo $(let* (runes (speedabyss3runes ${1:-.} $*) enters (speedabyss3enters ${1:-.} $*) times (sort (speedabyss3helper $runes $enters)) min (car $times) max (last $times) med (listmid $times) avg (listavg $times)) (sprintf "Abyss rune retrievals for $(name_fixup ${1:-.})$(argst $*): Min: $min, Max: $max, Median: $med, Average: %.2f" $avg))

Gives min, max, median, and average turns it takes from the time a player last entered the abyss to when they picked up the rune. Try: !speedabyss * current

!speedrune Coc ${1:-.} $*

Returns shortest number of turns from entering Coc to picking up the Icy rune. Usage: !speedcoc <name> <other options>

!speedrune Dis ${1:-.} $*

Returns shortest number of turns from entering Dis to picking up the Iron rune. Usage: !speeddis <name> <other options>

!speedrune Geh ${1:-.} $*

Returns shortest number of turns from entering Geh to picking up the Obsidian rune. Usage: !speedgeh <name> <other options>

!lm $(name_fixup ${1:-.}) br.enter=Lair min=turns x=turns fmt:"$(name_fixup ${1:-.})'s fastest Lair enter: ${x[0]}" stub:"$(name_fixup ${1:-.}) has never reached Lair."

A player's quickest time to enter lair. Syntax: !speedlairenter [player nick]

.echo $(let* (turns (map int (split (!lm ${1:-.} ((br.enter || rune)) br=pan $* s=gid x=-${max(turns)-min(turns)} fmt:'${x[0]}' notitle join:' ' stub:'-1' gid=$(=speedpan.eligible ${1:-.} $*))))) (sprintf "First Pan entry to last Rune turns for $(name_fixup ${1:-.})$(argst $*): Min: $(car $turns), Max: $(last $turns), Median: %.2f, Average: %.2f" $(listmedian $turns) $(listavg $turns)))

Stats of how quickly a playernick gets all Pan runes. Try: !speedpan * t

.echo $(if (= "" $1) (!help !speedrune) (=speed.generic ${2:-.} br.enter rune $(replace " " _ "Branch entry to Rune pickup turns for") br=$1 $*))

Returns min, max, median, and average turns from entering a branch to finding it's rune. Usage: !speedrune <branch> [name] [lg args]. Try !speedrune tomb or !speedrune vaults * recent

!speedrune Tar ${1:-.} $*

Returns shortest number of turns from entering Tar to picking up the Bone rune. Usage: !speedtar <name> <other options>

=speed.generic ${1:-.} tesseract.activate tesseract.kill $(replace " " _ "Tesseract activation to kill turns for") $*

Stats for how quickly a playernick kills tesseracts. It measures turns between tesseract.activate and tesseract.kill milestones so games with no activate milestone aren't counted sadly. Try: !speedtesseract * t

!speedrune Tomb ${1:-.} $*

Stats of how quickly a playernick gets the tomb rune. Try: !speedtomb * t

=speed.generic ${1:-.} br.end=vaults rune=silver $(replace " " _ "Vaults:5 to Silver rune pickup turns for") $*

Stats of how quickly a playernick does gets the vaults rune, starting at when they entered V:5. Try: !speedvaults5 * t

=speed.generic ${1:-.} br.enter=zot orb $(replace " " _ "Zot entry to Orb pickup turns for") $*

Gives min, max, median and average turns from entering Z:1 to picking up the Orb. Try !speedzot * recent

=speed.generic ${1:-.} br.end=zot orb $(replace " " _ "Zot:5 to Orb pickup turns for") $*

Gives min, max, median and average turns from entering Z:5 to picking up the Orb. Try !speedzot5 * recent

.echo $(if (re-find "^\d+" $*) (ldb-find "list_of_spells_by_level[Level $*") (ldb-find "list_of_spells_by_school[$*.*:"))

Provide either the spell school or level and it will bring up the appropriate list_of_spells learn database entry. Try: !spells 7 or !spells conj

.echo Spell skills at >=15 skill won for $(name_fixup ${1:-.})$(argst $*): $(join ", " (reverse (sortby (fn (s) (int (re-replace '.*: (\d+)\/.*' '$1' $s))) (map (fn (x) (re-replace "(.*): N=(\d+)\/(\d+) \((\d+\.\d+)\%\)" '$1: ${2}/$3 ($(sprintf "%.1f%%" $4))' (!lg ${1:-.} won !dj !gn $* / fifsk=~$x title:"$x"))) (list air alch conj earth fire forge hexes ice necro summon transloc)))))

What percentage of winning non-dj non-gn games finished with at least 15 for each spell skill. Try: !spellskills * t

.echo $(let* (xs (split "|" (!lg * fmt:'$(re-replace "\/.*" (groupcount ${n_x}))' join:'|' notitle o=-n $*)) ps (join " " (map (fn (n) "$n%[$(percentile $xs $n)]") (list 1 5 10 20 30 40 50 60 70 80 90 95 99)))) "S percentiles for $(argst $*): $ps")

Give it !lg query arguments for ***sorted** s= and it will spit out percentiles. Try: [!spercentiles * s=-name won t] to see the percentiles for how often players won during the tournament.

!lg ${1:-.} recentish xl>=17 $* s=name o=-% title:"Percent of recentish chars with XL>=17 killed for $(name_fixup $1)$(argst $*)" stub:"No recentish chars with XL>=17 for $(name_fixup $1)$(argst $*)" / !won

Ratio of games in recent versions that made it to XL17 but died (compared to all games that made it to XL17). Syntax: !splatratio [playernick] [lg args]

!gameinfo

see {!help:!gameinfo}

.echo $(if (= (lower (sub 2 $1)) wn) "Wanderer starting stats are random. Stat gain: $(getldbsid (combo_to_race $1))" $(!lm * begin char=$1 ${2:-recent alpha} $* x=str,int,dex fmt:"Starting stats for ${char}: Str $x[0] Int $x[1] Dex $x[2]. Stat gain: $(getldbsid (combo_to_race $1))" stub:"Go start a ${1:-?} if you want me to know its starting stats."))

Provides starting stats for the given starting character, such as !stats GhBe.

.echo $(let* (sid (!lg ${1:-.} $* x=avg(str),avg(int),avg(dex) notitle fmt:'${x[0]} ${x[1]} ${x[2]}') str (nth 0 $sid) int (nth 1 $sid) dex (nth 2 $sid) sum (+ $str $int $dex)) "Average stats for $(name_fixup ${1:-.})$(argst $*): STR: $(nth 0 $sid) ($(percent $str $sum)) INT: $(nth 1 $sid) ($(percent $int $sum)) DEX: $(nth 2 $sid) ($(percent $dex $sum))")

Displays the str/dex/int in all games as a percentage of the total of all stats. Takes !lg arguments. Try !statspread or !statspread * recent won urune=3

.echo $(if (< (int $1) (int ${3:-${2}})) $1 (+ (- ${3:-${2}} $2) (stepdown (- $1 (- ${3:-${2}} $2)) $2)))

Calculates stepdown_value(int base_value, int stepping, int first_step). Here first_step = stepping by default. Example: "!stepdown n 50" for the spellpower stepdown. Doesn't apply a ceiling_value.

.echo $(let* (streaks (apply hash (flatten (map (fn (kv) (list (nth 0 $kv) (length (split "," (longest (split | (nth 1 $kv))))))) (apply hash (split ">" (=streakall-lg $1 $*))))))) "Longest streaks in players with at least $1$(argst $*) wins: $(join ", " (map (fn (player) "$player: $(elt $player $streaks)") (reverse (sorthashcounts $streaks))))")

Finds the largest streaks with the specified lg filters. First argument is the minimum number of wins to consider a player (so it doesn't timeout). [!streakall 24 wn] Finds the longest Wanderer streak among players with at least 24 Wanderer wins. Try [!streakall 30 fe--] or [!streakall 5 month]

.echo $(let* (streaks (apply hash (flatten (map (fn (kv) (list (nth 0 $kv) (length (split "," (longest (split | (nth 1 $kv))))))) (apply hash (split ">" (=streakall2-lg $*))))))) "Longest streaks for $(argst $*): $(join ", " (map (fn (player) "$player: $(elt $player $streaks)") (reverse (sorthashcounts $streaks))))")

Like !streakall but with no subcommand to filter by wins. Advanced users can make their own filter instead! Try: [!streakall2 @greaterplayers op]

=streakby class role_abbrev

Lists a player's best streaks with each background.

=streakby god god_abbrev

Lists a player's best streaks with each god. (This is a silly command because it counts games where you died before getting your god as Atheist games and also you could cheese this by using a strong god and switching to a target god only on the orbrun. Still, satisfy your curiosity.)

=streakby crace species_abbrev

Lists a player's best streaks with each species.

.echo Players with the most combo low turncount records$(argst $*): $(join ", " (map (fn (kv) "$kv[0]: $kv[1]") (sortby (fn (kv) (* -1 (int $kv[1]))) (freqhash (split ", " (!lg * won s=char,gid x=-min(turns),min(name) fmt:'$x[1]' pfmt:'$(nth 0 (split ", " $child))' $*))))))

List players by the number of combo turncount win records they have. Try: !tccounts t or !tccounts playable

.echo $(let (player (name_fixup $1) won (hashlist (split ", " (!lg ${1:-.} won dr race!=mottled_draconian s=race fmt:'$(replace " Draconian" ${.})' stub:'' notitle)))) (if (>= (length $won) 8) "$player is a Tiamat player" "$player is not a Tiamat player. Unwon Draconians: $(join ", " (filter (fn (colour) (not (elt $colour $won))) (tiamatcolours)))"))

A Tiamat Player is one who has won with every colour of draconian. Use the command to see if a player is a Tiamat Player or if not, which colour draconians they need to win with. Syntax: !tiamat [playernick]

.echo $(replace github.com raw.githubusercontent.com (replace blob/ (!source $(replace ' ' _ "$*").png)))

Get a github link to a tile by filename (without the .png extension). Try [!tile hydra3]

.echo $(let (times (apply hash (split "|" (!lg ${1:-.} won $* s=crace x=min(rend) o=-. notitle fmt:'${.}|$x' join:'|')))) (concat "Time until won for $(name_fixup ${1:-.})$(argst $*): " (join ", " (sort (map (fn (sp) (!lg ${1:-.} $* crace=$(replace " " _ $sp) rend<=$(elt $sp $times) x=sum(dur),min(regexp_replace(char, '^(..).*', '\1')) notitle fmt:'${x[1]}: ${x[0]}')) (hash-keys $times))))))

The sum duration of all games before (and including) your first win for each species. In other words: how long it took you to win each species. Try !timeuntilspecieswon or !timeuntilspecieswon * t

.echo $(!lg ${1:-.} $* rend<=$(!lg ${1:-.} $* x=rend fmt:'${x[0]}' stub:'-1' notitle won 1) x=sum(dur) title:"Playtime until first win for $(name_fixup ${1:-.})$(argst $*) ($n games)" fmt:" ${x[0]}" stub:"No games won for $(name_fixup ${1:-.})$(argst $*)")

The total playtime and games it took to win, including the winning game. Syntax: !timeuntilwon [playernick] [lg args]

!lg ${1:-.} s=ckiller x=+sum(dur) title:"Time wasters" $*

Lists what killed players by how much total time they wasted. 6 10-minute gnoll deaths might equal 1 1-hour hydra death! Syntax: !timewasters [playernick] [lg args]. Try: [!timewasters * current]

.echo $(let (silly (< (rand 10) 1) size (tip-adj) material (tip-material) catch (if (>= (rand 5) 1) "" "It rolls into the gutter...")) (if $silly "/me $user tips ${*:-$bot}. ${*:-$bot} falls over!" "/me $user flips a $size $material coin towards ${*:-$bot}. $catch"))

Show your appreciation by throwing coins at people! By default, it will tip the sequell IRC bot Mnoleg. Syntax: !tip [some entity]

.echo ${*}: $(or $(=title.title recent $*) $(=title.skill.noinv recent $*) $(=title.skill.inv recent $*) $(=title.title !recent $*) $(=title.skill.noinv !recent $*) $(.echo cannot understand ${*}.))

Give it a title name and it will try to find the skill requirements. It's slow so be patient. It won't work with conduct titles.

.echo $(let (known (!lg * x=cdist(title) notitle fmt:"${x}" stub:"0") won (!lg ${1:-.} won x=cdist(title) notitle fmt:"${x}" stub:"0") name (name_fixup ${1:-.})) (sprintf "$name has won %d out of %d known titles (%.2f%%). %s" $won $known (/ (* 100.0 $won) $known) (if (> $won 99) "$name is an entitled player!" "")))

Lets you know how many titles a player has won with, compared to all titles seen so far. Try !titleprogress . or !titleprogress Ge0ff

!lg ${1:-*} won s=gid x=-min(dur),min(name),min(char),min(god) fmt:'$x[0] $x[1] $x[2]^$(godletter $x[3])' title:"Top Real-time wins for $(name_fixup ${1:-*})$(argst $*)" stub:"No wins for $(name_fixup ${1:-*})$(argst $*)" $*

Lists the top real-time (well, game duration) wins. Syntax: !toprt [playernick] [lg filters]. Try: [!toprt * !bot playable:sp dur<0:30:00] [!toprt * !bot playable:sp dur<1:00:00 urune=15] (capping the duration should speed it up)

!lg ${1:-*} won s=gid x=+min(sc),min(name),min(char),min(god) fmt:'$(sprintf "%.3g" $x[0]) $x[1] $x[2]^$(godletter $x[3])' title:"High score wins for $(name_fixup ${1:-*})$(argst $*)" stub:"No wins for $(name_fixup ${1:-*})$(argst $*)" $*

Lists the top highscore wins. Syntax: !topsc [playernick] [lg filters]. Try: [!topsc * playable:sp sc>50000000 urune=15] (limiting the score and runecount should speed it up)

!lg ${1:-*} won s=gid x=-min(turns),min(name),min(char),min(god) fmt:'$x[0] $x[1] $x[2]^$(godletter $x[3])' title:"Top Turncount wins for $(name_fixup ${1:-*})$(argst $*)" stub:"No wins for $(name_fixup ${1:-*})$(argst $*)" $*

Lists the top turncount wins. Syntax: !toptc [playernick] [lg filters]. Try: [!toptc * playable:sp turns<20000] or [!toptc * playable:sp turns<20000 urune=15] (capping the turncount should speed it up)

.echo $(let (time (!time)) (if (str-find? tournament $time) ($time) (ldb tournament)))

Shows tournament info. Equivalent to !time during the tournament or ??tournament otherwise.

.echo $(let (arg1 ${1:-16} arg2 ${*:-t}) (let (t (concat $arg2 " !@bot " end<$(+ (stamptime (!lg * $arg2 1 fmt:"$end")) $arg1))) "Stats after $arg1 days $(concat '(' $arg2 ')'): $(=tstats.players $t), $(=tstats.runers $t), $(=tstats.winners $t), $(=tstats.wins $t), $(=tstats.games $t), $(=tstats.winrate $t), $(=tstats.playertime $t)."))

!tstats <days> <tournament selector> for information on games/runes/wins. Example: !tstats 15 t0.14

!lm * t uniq s=regexp_replace(noun, ".*Lernaean.*", "the Lernaean hydra") / @${1:-.} title:"Uniques remaining for $(name_fixup $1)" fmt:"${.}" ?:N=0 den.N>=$(car (split x $(!lm * t uniq=murray|ignacio s=-uniq fmt:"${n_x}")))

Shows you uniques that you haven't yet killed in the tournament. It may not be accurate early in the tournament. Syntax: !tuniques [playername]

.echo $(let* (info (split (!lg ${1:-.} $* x=gid,char,ktype,turns notitle fmt:'${x[0]} ${x[1]} ${x[2]} ${x[3]}')) out (!lm * gid=$(nth 0 $info) !portal !arena !crucible br.enter|rune|orb|god.worship s=noun x=-min(turns) fmtsimple title:"Summary for $(nth 0 $info) $(nth 1 $info)" stub:"N/A")) $(if (= 'N/A' $out) "No games found for $(name_fixup ${1:-.})$(argst $*)" "$out, $(nth 2 $info) [$(nth 3 $info)]"))

Shows the order and turns of various important milestones for a single game. Usage: !turnsummary <lg args for the game>. Try !turnsummary * won min(turns) or !turnsummary . recent max(sc) -2

!lg ${1:-.} $* rstart=$(!lg ${1:-.} $* rstart!=$(!lg ${1:-.} $* s=char x=min(rstart) fmt:"${x[0]}" join:"|") s=char x=min(rstart) fmt:"${x[0]}" join:"|") won s=char title:"Chars won on second try for $name" stub:"No games won on second try for $name"

See which characters you won on exactly the 2nd try! Syntax: !twoandwon [playernick] [lg filters]

.echo $(!lg * playable $(ignore $1)$* s=char o=-. / @${1:-.} title:"Unplayed combos for $(name_fixup ${1:-.})$(argst $*)" fmt:'${.}' stub:"$(name_fixup ${1:-.}) has played all$(argst $*) combos" ?: N=0)

Lists your unplayed combos that are currently playable. Syntax: !unplayed [playernick] [lg filters]. Try !unplayed or !unplayed . gn

!lg * playable $(ignore $1)$* s=char o=-char title:"Unwon playable chars$(argst $*)" stub:"All playable chars have been won$(argst $*)" join:' ' fmt:"${.}" / won $(if $1 @$1) ?: N=0

Show playable characters that have been played by someone but have never been won by anyone. Syntax: !unwon [lg filters]

.echo $(let* (re (comboregex ${2:-----}) combos (filter (fn (char) (re-find $re (lower $char))) (unwon_raw (playablels) ${1:-.} *)) name $(name_fixup ${1:-.}) args $(argst ${2:-})) (if $combos "Unwon playable$args combos for $name: $combos" "$name has won all playable$args combos!"))

Finds all unwon playable combos for the given player. Syntax: !unwon2 [playername] [filter]. Filter is a 4-letter word that matches character combos. Use a non-letter like - to fill in blanks. Try [!unwon2] or [!unwon2 . gn--] or [!unwon2 qw --fe].

.echo $(let (eligible (unwonbg ${1:-.}) name (name_fixup ${1:-.})) (if (> (length $eligible) 0) "Random background that $name hasn't won: $(replace "Human " (!wtf hu$(randnth $eligible)))" "$name has won all backgrounds!"))

Picks a completely random playable background you haven't won yet. Syntax: !unwonbg [playernick]

.echo $(let (eligible (unwonsp ${1:-.}) name (name_fixup ${1:-.})) (if (> (length $eligible) 0) "Random species that $name hasn't won: $(replace " Fighter" (!wtf $(randnth $eligible)fi))" "$name has won all species!"))

Picks a completely random playable species you haven't won yet. Syntax: !unwonsp [playernick]

.echo $(let* (argtemp (split // "$*") args (list (lookupelse 0 $argtemp "") (lookupelse 1 $argtemp "")) playersrc (watchrandom-ongoing $args[0]) player (watchrandom-history $playersrc $args[1]) link (elt (elt $player $playersrc) (watchhash))) (if (bound? link) "$link$player" "No players with milestones in the last 10 minutes. (!lm filters: $args[0] // !lg filters: $args[1])"))

Gives a link to spectate a random game that was active in the last 10 minutes. You can give it lm and lg filters seperated by //. Try: [!watchrandom] or [!watchrandom mi xl>10] or [!watchrandom * // won ?: N>9] (a random game from a player with more than 9 wins).

!lg * won $1 recent $* s=god title:"${n} recent wins for $1$(argst $*)" stub:"No recent wins for $1$(argst $*)."

Usage: !whichgod [race and/or role]

!lg * won recent $(if (or (re-find ru|Ru $*) (> $(length $*) 2)) $* class=$*) s=crace title:"${n} recent wins" stub:"No recent wins for $*."

Usage: !whichrace [role or god]

!lg * won recent $(if (or (re-find ru|Ru $*) (> $(length $*) 2)) $* race=$*) s=role title:"${n} recent wins" stub:"No recent wins for $*."

Usage: !whichrole [race or god]

.echo $(let* (wins (split '|' (!lg * $* s=-name fmt:'$(re-replace "(\d+)/\d+" $1 $(groupcount ${n_x}))' join:'|' notitle stub:'N/A' / won ?: den.N>=${1:-100} N>=${2:-0})) percentiles (join ", " (map (fn (x) "$x: $(percentile $wins $x)") (range 4 99 5)))) "Win percentiles for players with at least ${1:-100} games and ${2:-0} wins$(argst $(ignore $1)$(ignore $2)$*): $percentiles")

Lists the wins of players at 4th-99th percentiles. Syntax: !winpercentiles [minimum games] [minimum wins] [lg args].

.echo $(let* (wins (split '|' (!lg * $* s=name fmt:'${n_ratio}' join:'|' notitle stub:'N/A' o=-% / won ?: den.N>=${1:-100} N>=${2:-0})) percentiles (join ", " (map (fn (x) "$x: $(percentile $wins $x)") (range 4 99 5)))) "Winrate percentiles for players with at least ${1:-100} games and ${2:-0} wins$(argst $(ignore $1)$(ignore $2)$*): $percentiles")

Lists the winrate of players at 4th-99th percentiles. Syntax: !winratepercentiles [minimum games] [minimum wins] [lg args].

.echo $(let* (n ${1:-1} combos (sort (map (fn (kv) $(elt 0 $kv)) (filter (fn (kv) (contains w (split "" (sub 0 $n (elt 1 $kv))))) (apply hash (split > (=nandwonlg ${2:-.} $*)))))) len (length $combos) name (concat (name_fixup ${2:-.}) (argst $*))) (if (= 0 $len) "No $n and won combos for $name." "$len ${n}-and-won $(if (> $n 1) "(or less!) ")combos for $name: $(join $combos)"))

Shows combos you won in N tries or less. Syntax: !woninn [n] [playernick] [lg filters].

.echo $(let* (toHash (fn (lg) (foldr xldeath-helper4 (hash) (split ", " $lg))) xlL (toHash (!lg ${1:-.} !won s=xl notitle fmt:"${.} ${n_x}" $*)) xlW (toHash (!lg ${1:-.} won s=xl notitle fmt:"${.} ${n_x}" $*)) total (xldeath-helper3 28 $xlW $xlL) result (fn (xl) (sprintf "%s: %2.2f%%" $xl (* 100 (/ (float (xldeath-helper $xl $xlL)) (- $total (xldeath-helper3 $xl $xlW $xlL))))))) (map result (range 1 27)))

Shows the rate of deaths (quits/deaths/etc) at each XL, for characters that made it to that XL. Basically, it shows something approximating the game's difficulty curve. Graphs: https://docs.google.com/spreadsheets/d/1m_aGyxgq97BKp2rZi2pksZyFaYeE58YAHAedZo2vlXo/edit Breakdown: https://gist.github.com/RypoFalem/10845d564efbf4d55f108278aa01d201

.echo $(let* (xs (split "|" (!lg * fmt:'${x[0]}' join:'|' notitle $*)) ps (join " " (map (fn (n) "$n%[$(percentile $xs $n)]") (list 1 5 10 20 30 40 50 60 70 80 90 95 99)))) "X percentiles for $(argst $*): $ps")

Give it !lg query arguments with s= and ***sorted*** x= and it will spit out percentiles for x=. Try: [!xpercentiles * s=gid x=-min(dur) won urune=3 t] or [!xpercentiles * s=name x=+median(turns) won current]

.echo $(let (num $(rand 5 15)) "$nick $(=rndspellgesture). $num tentacled monstrosities appear! The tentacled monstrosity tentacle-slaps ${*:-Mnoleg's tentacle}! x$num")

Cast Summon Horrible Things on some puny mortal.

!lm ${1:-.} fmt:"\$(=morgue_link ${2:-${src}} \$(if \$(match -a ${3:-${cv}}) trunk ${3:-${cv}}))/${name}/${name}.txt" stub:"No milestones for $(name_fixup ${1:-${user}})."

Find a player's in-progress game dump based on their last milestone (by default) or by server (argument two) and game version (argument three). For example, to find your last 0.20 game on cbro use: &dump . cbro 0.20

!rc

Gets the rc file of the specified player, version, and server. Syntax: &rc [player selector] [canonical version] [source]. Try "&rc" for your own rc, or "&rc qw 0.20 cao" for a specific rc.

!lm * ktyp= type!=crash time>=$(- (utc (time)) (interval-minute 30)) s=src x=+count(gid) fmt:'$x[0]x $(upper ${.})' title:"Living games, last half-hour$(argst $*)" stub:"No milestones in the last half-hour$(argst $*)" $*

!motto $(cons always ${*:-be closing})

!lm ${1:-.} $* ancestor s=regexp_replace(milestone, '.*remembered their ancestor (.+)as a (battlemage|hexer|knight).*$', '\1') title:"Ancestor names for $(name_fixup ${1:-$nick})$(argst $*)"

!apt

.echo https://crawl.akrasiac.org/rcfiles/crawl-$(replace trunk git ${2:-git})/$(!lm ${1:-.} cao x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

.echo https://crawl.dcss.io/crawl/rcfiles/crawl-$(replace trunk git ${2:-git})/$(!lm ${1:-.} cdi x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

!echo $(map (fn (w) (apply concat (map (fn (c) (if (rand 2) (upper $c) (lower $c))) (split '' $w)))) (split ' ' ${*:-$(!banish)}))

.echo $(replace "https://crawl.kelbi.org/crawl/" "https://cko-archive.nyc3.cdn.digitaloceanspaces.com/crawl-kelbi-org/" (!log $* cko)).gz

!emote 👏 $*

!emoteall 👏 $*

.echo https://archive.nemelex.cards/rcfiles/crawl-$(replace trunk git ${2:-git})/$(!lm ${1:-.} cnc x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

!lg ${1:-.} cv>=0.34-a won title~~pinnacle|flawless|true_ascetic|incurious|ruthless|miser|chaos_fanatic|keeper_of_the_flame title!=merchant_of_misery s=title title:"Conduct titles for $(name_fixup ${1:-.})$(argst $*)" stub:"No conduct titles for $(name_fixup ${1:-.})$(argst $*)" $*

.echo $(let (recipient ${1:-$user} cookie (cookie_type)) "$(if (= $recipient $user) "$bot offers $user a" "$user offers $recipient a") ${cookie}. $(if (= "fortune cookie" $cookie) (!crystalball $recipient) (if (= "browser cookie" $cookie) "Will $recipient accept?" "Baked by $(rng-god-uniq) with love!"))")

!lm ${1:-.} cpo fmt:"https://crawl.project357.org/morgue/${name}/${name}.txt"

!dumpstash $*

!learn q dump

.echo $(replace .txt .lst $(&dump $*))

.echo $*

!echo ${1:-🐢} $(join " ${1:-🐢} " (split " " "$(ignore $1)${*:-REMOVE FELIDS}")) ${1:-🐢}

!echo ${1:-🐢} $(join " ${1:-🐢} " (split "" "$(ignore $1)${*:-REMOVEFELIDS}")) ${1:-🐢}

!lg ${*:-.} won dur<$(!lg * urune=15 won min=dur x=dur fmt:"${x[0]}") fmt:"$(name_fixup $*) is a fast player." stub:"$(name_fixup $*) is not a fast player."

.echo $(!lg * !@bot !@hybridbot won s=name x=min(dur) o=-min(dur) dur<$(!lg * urune=15 won min=dur fmt:"$dur") join:" " fmt:"${.}")

.echo First wins by version for $(name_fixup ${1:-*})$(argst $*): $(join ", " (map (fn (kv) "$kv[0]: $kv[1]") (sortby (fn (kv) (int (sub 2 "$kv[0]"))) (freqhash (split ", " (!lg ${1:-*} $* won s=name,gid x=-min(rend),min(regexp_replace(cv, "-a", "")) pfmt:'$(first (split ", " $child))' fmt:'$x[1]' cv!=))))))

.echo First wins by year for $(name_fixup ${1:-*})$(argst $*): $(join ", " (map (fn (kv) "$kv[0]: $kv[1]") (sortby (fn (kv) (int $kv[0])) (freqhash (split ", " (!lg ${1:-*} $* won s=name,gid x=-min(regexp_replace(rend, "^(\d\d\d\d).*", "\1")) pfmt:'$(first (split ", " $child))' fmt:'$x[0]'))))))

!fnsearch

.echo $(filter (fn (func) (re-find "$*" $func)) (split ", " (replace "User functions: " (!fn -ls))))

.echo $(let (gid (!lg $* fmt:'$game_key')) (!lm * gid=$gid type=br.enter|rune|orb !portal s=id,turn,type,noun pfmt:'${.}:${child}' join:'/' stub:''))

!gamesuntilwin $*

!echo $(join | (sort (hash-keys (apply hash (flatten (map (fn (combo) (list $combo 1)) (concat (gen_nem_eligible_race ${1:-4}) (gen_nem_eligible_class ${1:-4}))))))))

!echo $(let (g $(!lm ${1:-.} $* ghost necropolis fmt:'$n') p $(!lm ${1:-.} $* br.enter=necropolis fmt:'$n') d $(!lg ${1:-.} $* necropolis fmt:'$n')) (sprintf "Necropolis stats for $(name_fixup ${1:-.})$(argst $*): Ghost kills per entry: %1.2f (${g}/$p); Death ratio: %1.2f%% ($d death(s))" (/ (float $g) $p) (* 100 (/ (float $d) $p))))

!echo Ghost vault kills$(argst $*): $(vaultallkills ghostkmap ghostmap "$*")

!echo https://github.com/search?q=repo%3Acrawl%2Fcrawl+$(re-replace "\s" + $1)&type=commits&s=committer-date&o=desc

.echo $nick $(=rndspelltarget $*). Insubstantial figures form in the air. The $(=randwraith) hits ${*:-something}! x$(rand 2 4) The $(=randwraith) hits ${*:-something}! x$(rand 3 6)

.echo $(let (hours (durbyver "${1:-.}" "$*") wins (winsbyver "${1:-.}" "$*") name "$(name_fixup ${1:-.})$(argst $*)") (if (= $wins "N/A") "No wins for $name... yet!" "Hours per win for $name: $(join ", " (map (fn (ver) (sprintf "$ver %1.2f" (/ (/ (float (pduration (elt $ver $hours))) (elt $ver $wins)) 3600))) (hash-keys $wins)))"))

.echo $(let (hours (durbyyear "${1:-.}" "$*") wins (winsbyyear "${1:-.}" "$*") name "$(name_fixup ${1:-.})$(argst $*)") (if (= $wins "N/A") "No wins for $name... yet!" "Hours per win for $name: $(join ", " (map (fn (year) (sprintf "$year %1.2f" (/ (/ (float (pduration (elt $year $hours))) (elt $year $wins)) 3600))) (hash-keys $wins)))"))

!timeuntilwon

!lm ${1:-*} tesseract.activate|tesseract.kill $* / tesseract.kill s=name,gid pfmt:'$(first (split / ${n_x}))x ${.}' title:"Sleeping Tesseract kills for $(name_fixup ${1:-*})$(argst $*)" stub:"No sleeping Tesseract kills for $(name_fixup ${1:-*})$(argst $*)" ?: %=1

!echo https://github.com/crawl/crawl/issues/$*

.echo $(let (target $(=target ${2:-*})$(replace " ()" '' " ($*)") ratio $(=killratio.calc $(!lg ${2:-*} $* ikiller=$1 fmt:"${n}" stub:"0") $(!lm ${2:-*} $* uniq=$1 fmt:"${n}" stub:"0"))) $(if $(= $ratio NaN) "No battles for $1"$(if $(/= $target *) " and $target"). "$1 wins $ratio% of battles"$(if $(/= $target *) " against $target").))

!killratio

.echo Unique's Kill/Death ratios for $(name_fixup ${1:-.})$(argst $*): $(let (deaths (killratiosdeaths ${1:-.} $*) kills (killratioskills ${1:-.} $*)) (killratiosfmt $kills $deaths))

!kwsearch

!lg ${1:-*} lairend $* s=kmap% title:"Lair End kills for $(name_fixup ${1:-*})$(argst $*)" stub:"No Lair End kills for $(name_fixup ${1:-*})$(argst $*)"

.echo $nick $(=rndspelltarget ${*:-something}). The crystal spear hits ${*:-something}$(nth $(rand 3) $(split '|' '!|!!|!!!'))!!

.echo http://lazy-life.ddo.jp:8080/rcfiles/$(replace git trunk ${2:-trunk})/$(!lm ${1:-.} lld x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

.echo $(replace .txt .lst $(!log $*))

!makhlebmarks

!lg ${1:-.} won fe-- $* s=char join:"|" fmt:"${n_x}😼" stub:"😿" title:"Cats won for $(name_fixup $1)"

.echo $(apply concat (map (fn (w) (upper (sub 0 1 $w))) $*))! $(map (fn (w) (concat (capitalise (sub 0 1 $w)) - (capitalise $w) !)) $*) $(map capitalise $*)! $(map upper $*)!

.echo $(map (fn (c) (!lg * t won $c 1 fmt:"$name" stub:"")) (split | (=kw nchoice)))

!nchoicetimes

.echo $(map (fn (x) (concat (nth 0 $x) " " (nth 1 $x) ",")) (transpose (list (sub 0 -1 (split | (=kw ${2:-nchoice}))) (split " " (!nchoice-times.helper $1 $2))))) $(nth -1 (split | (=kw ${2:-nchoice}))) $(fduration (* 86400 (- (time) (stamptime (!lg * ${1:-t} won $(nth -2 (split | (=kw ${2:-nchoice}))) 1 fmt:"$rend")))))(+)

.echo $(map (fn (d) (fduration (* 86400 (- (stamptime (nth 1 $d)) (stamptime (nth 0 $d)))))) (pairs (cons (!lg * ${1:-t} 1 fmt:"$rend") (map (fn (c) (!lg * ${1:-t} won $c 1 fmt:"$rend" stub:"")) (sub 0 -1 (split | (=kw ${2:-nchoice})))))))

!lg * nchoice t s=char o=-N fmt:'${.} ($(- 9 (if (= "" $n_x) 0 (replace x $n_x))) left)' title:"Available Nemelex Choice combos$(argst $*)" stub:"No available Nemelex Choice combos$(argst $*)" / won ?: N<9

!nchoice

!nchoiceleft

.echo $(let* (nc (nem-chosen) nr (nem-remaining) nw (nem-weights $nc $nr) tw (apply ${+} $nw) fnr (apply nem-remaining-filtered || (split " " $*)) ids (subset-ids $nr $fnr)) (.echo Chance that next nchoice is not$(argst $*) is $(percent (apply + (map (fn (j) (elt $j $nw)) $ids)) $tw): $(map (fn (i) (sprintf "$(elt $i $nr)(%s)" (percent (elt $i $nw) $tw))) (reverse (sort (fn (x y) (<=> (elt $x $nw) (elt $y $nw))) $ids)))))

!oneandwonclass $*

.echo pong

.echo /me cooks up a $(pizzaquantity) of $(pizzatype) pizza for ${*:-${nick}}$(if $* ", courtesy of $nick").

.echo Playtime relative to their average(mean) by version for $(name_fixup ${1:-.})$(argst $*): $(let* (times (apply hash (split " " (!lg ${1:-.} x=sum(dur) byversion fmt:'${.} $(pduration $x[0])' o=-. stub:"" join:" " $*))) avg (/ (float (apply + (hash-values $times))) $(length $times))) (join ", " (map (fn (kv) (sprintf "$kv[0]: %0.2fx" (/ $kv[1] $avg))) $times)))

.echo $(let* (days (!lm ${1:-.} x=count(day(time)) fmt:'$x[0]' $*) playtime (!lg ${1:-.} x=sum(dur) fmt:'$x[0]' $*) hrsperday (sprintf "%.2f" (/ (/ (float (pduration $playtime)) 3600) $days))) "$(name_fixup ${1:-.})$(argst $*) has played for $playtime and has milestones during $days days (UTC). That's $hrsperday hours/day!")

.echo $nick zaps a wand. $1 evaporates and reforms $(re-replace '^as a ([AEIOUaeiou])' 'as an $1' "as a ${*:-$(nth (rand 34) (split '|' (if (rand 2) (=poly1) (=poly2))))}!")

!polytheist $*

!speciescanoneandwon

.echo $(replace _ ' ' (ldb (randnth (split & (=randhat.list)))))

.echo Ru <:plogchamp:823530252075794433>

.echo $(replace "Time:" (concat (randnth (rhymes)) ":") (!time))

.echo Reeces <:plogchamp:823530252075794433>

.echo $(do (try (!nick -rm ryponick) "Nick already empty") (!nick ryponick $(join " " (split | $*))))

.echo $(if (str-find? mopl $*) "$nick raises a huge knife to sacrifice mopl... $nick slips on a banana peel and bleed himself white" "/me sacrifices ${*:-$nick}!")

!help $*

!help $*

.echo $nick $(=rndspellgesture). $channel rumbles around ${nick}! ${*:-Everyone} shudders from the earth-shattering force.

.echo The shrikes are $(let (time (secondssince (stamptime (!lg * cikiller=caustic_shrike|shard_shrike x=end fmt:'${x[0]}')))) (if (< $time 300) "happy!" (if (< $time 3600) "content." (if (< $time 86400) "restless." "angry!"))))

.echo $nick $(=rndspellgesture). A profound silence engulfs ${*:-$nick}.

.echo $nick $(=rndspellgesture). Space collapses on itself with a satisfying crunch. The singularity violently warps ${*:-something}!

.echo ${*}: $(sort (split ' ' $*))

!speedzot

!lg ${1:-*} spiderendkmap $* s=kmap% title:"Spider End kills for $(name_fixup ${1:-*})$(argst $*)" stub:"No Spider End kills for $(name_fixup ${1:-*})$(argst $*)"

!versions !alpha

!lst $*

!cheatstreak

.echo $(let (owed $(/ (!lg ${1:-.} !zin x=sum(goldfound) fmt:'$x[0]' stub:'0' $*) 10) name (name_fixup ${1:-.}) args (argst $*)) (if (= $owed 0) "$name$args is already square with Zin!" "$name$args owes $owed in taxes to Zin$(attack-strength-punctuation (/ $owed 1000))"))

.echo /me hands ${1:-${user}} a cup of $(tea-rng), brewed by $(rng-god-uniq).

.echo $(!fahrenheit $*), and $(!celcius $*)

.echo test

.echo test

!tournamentpage

.echo https://crawl.develz.org/tournament/0.34/players/$(lower (nth 0 (split ' ' (nick-aliases (name_fixup ${1:-.}))))).html

!lg ${*:-.} -ttyrec

!tuniques

!lg ${*:-.} -tv

!lg * t nem-eligible s=crace,char o=-. crace=$(!lg * nem-eligible current bysp notitle join:'|' fmt:'${.}' / t (( nchoice || won )) ?: N=0) title:"Unpicked species for Nemelex's Choice" stub:"No unpicked species for Nemelex's Choice"fmt:'${.}' pfmt:'${.}($child)'

!gamestriedsincelastwin

.echo $(let* (streaks (unstreaks ${1:-.} $*) name (name_fixup ${1:-.}) args (argst $*) worst (longest $streaks)) "Largest losing streak for $name$args: (length $(length $worst)) $worst")

!nick centuryplayers $(!lg * won s=name o=-name title:"" join:" " format:"${.}" ?:N>=100)

!nick goodplayers $(!lg * won s=name fmt:"${.}" join:" " ?:N>9)

!nick greaterorbrunners $(!lm * cv>0.10 orb urune=3 lg:urune=15 s=name title:"" join:" " fmt:"${.}")

!nick greaterplayers $(!lg greatplayers playable:job won s=name x=count(cls) title:"" fmt:"${.}" join:" " ?: count(cls)=$(!lg * playable:job won x=count(cls) fmt:"${x}"))

!nick greatorbrunners $(!lm * cv>=0.10 orb ${lg:urune>urune} s=name title:"" join:" " fmt:"${.}")

!nick greatplayers $(!lg * playable:sp won s=name x=count(crace) title:"" fmt:"${.}" join:" " ?: count(crace)=$(!lg * playable:sp won x=count(crace) fmt:"${x}"))

.echo $(let* (old (split | (replace char= '' (=kw playable:all))) new (split | (replace char= '' (=kw $1))) all (join | (sort (hash-keys (hashlist (concat $new $old))))) out "char=$all") (if (str-find? "char=" (!kw $1)) (!kw playable:all $out) "You must supply a keyword for combos of a playable *stable* version eg: $(quote "!update-playable-all playable:0.34")"))

!learn set starting_stats[3] $(!lm * begin recent playable hu-- s=char x=avg(str),avg(int),avg(dex) fmt:'$(sub 2 4 ${.}) $(fmt_mostly_int (- $x[0] 8)),$(fmt_mostly_int (- $x[1] 8)),$(fmt_mostly_int (- $x[2] 8))' join:' | ' notitle o=-.)

!learn set starting_stats[2] $(!lm * begin recent playable --fi s=char x=avg(str),avg(int),avg(dex) fmt:'$(sub 0 2 ${.}) $(- $x[0] 8),$x[1],$(- $x[2] 4)' join:' | ' notitle o=-.)

.echo $(do (try (!nick -rm thousandhourplayers) "Nick already empty") (!nick thousandhourplayers $(!lg !bot x=+sum(dur) s=name notitle join:" " format:"${.}" ?: sum(dur)>=3600000)))

!nick winners $(!lg * won s=name fmt:"${.}" join:" ")

.echo $(do (try (!nick -rm winrateplayers)) (!nick winrateplayers $(!lg * recent fmt:'${.}' join:' ' stub:'' s=name o=% / won ?: N>=10 %>0.33)))

!lg ${1:-*} $* status=no_stairs place!=crucible|arena|zig

!dcss-stats

!fastversions

&watch $*

.echo Weapon skills at >15 skill won for $(name_fixup $1). $(join ", " (map (fn (x) (!lg ${1:-.} won $* / fifsk=$x title:"$x")) (list long_blades short_blades axes maces polearms staves unarmed ranged_weapons throwing)))

!lm * recent won god.abandon~~^${1:-.} s=xl o=-. fmt:'$n_x [${.}]' title:"XL of god abandonment in recent winning games$(argst $*)" stub:"No god abandonments in recent winning games$(argst $*)" $*

!whichrole

!whichrole

!lg * won $1 recent $* s=god x=cdist(name) o=cdist(name) fmt:"${x}x ${.}" title:"Recent unique winning players for $1$(argst $*)" stub:"No recent wins for $1$(argst $*)."

!lg * won recent $(if (or (re-find ru|Ru $*) (> $(length $*) 2)) $* class=$*) s=crace x=cdist(name) o=cdist(name) fmt:"${x}x ${.}" title:"Recent wins" stub:"No recent wins for $*."

!lg * won recent $(if (or (re-find ru|Ru $*) (> $(length $*) 2)) $* race=$*) s=role x=cdist(name) o=cdist(name) fmt:"${x}x ${.}" title:"Recent wins" stub:"No recent wins for $*."

.echo $(let* (args (concat "won !dj !gn recent " (ignore $1)$*) results (fifskhash ${1:-.} $args) games $results[0] skills $results[1]) (if (= 0 $games) "No games for $(name_fixup ${1:-.})$(argst $args)" ">=15 skills for $(name_fixup ${1:-.})$(argst $args): $(join ", " (map (fn (kv) (sprintf "%.0f%% %s" (* 100 (/ $kv[1] (float $games))) (skill_abbrev $kv[0]))) (reverse (sortby (fn (kv) $kv[1]) $skills))))"))

!whichrace

!lg ${1:-*} won recent $* fifsk~~long_blades|ranged|unarmed|axe|mace|pole|stave s=regexp_replace(fifsk, ".*((long|ranged|unarmed|axes|maces|pole|stave)[^,]*).*", "\1")% title:"Recent win weapons skills for $(name_fixup ${1:-*})$(argst $*)" stub:"No recent wins for $(name_fixup ${1:-*})$(argst $*)."

!echo http://crawl.chaosforge.org/$(replace " " _ $*)

!echo https://dcss.roguelikes.gg/wiki/index.php?title=Special:Search&search=$(replace " " %20 $*)

.echo $(let* (a (hash sp 7 fe 6 dd 6 na 5 mu 5 vs 5 vp 4 de 4 fo 4 og 4 dg 4 dj 4) b $(elt $1 $a)) $(if $2 "$(* $(with-nvl 3 $b) $2) Will at level $2" "$(with-nvl 3 $b) Will per level"))

!won

.echo $(gamessincethingwon ${1:-.} $* background "min(regexp_replace(char, '..(..)', '\1'))" (playablebgls))

.echo $(gamessincethingwon ${1:-.} $* god "min(god)" (playablegodls))

.echo $(gamessincethingwon ${1:-.} $* species "min(regexp_replace(char, '(..)..', '\1'))" (playablespls))

!winssinceracewon

.echo $(name_fixup ${1:-.}) has won 0 games since their last win.

!lm ${1:-*} $* br.enter=wizlab s=regexp_replace(milestone, "entered ((the_hall_of_|the_chambers_of_)([_a-z]+(?=the_)))?(.*)\.", "\2\4") milestone!~~ering?ya|cekugob|mortuary|a_wizard|upun's_lair|cloud_mage's_chambers title:"WizLab deaths ($*)" / lg:br=wizlab o=%

.echo in $1 encumbrance with $2 str and $3 armour, next str is worth $(* (/ (* 3.8 (* $1 $1)) (* (+ 3 $2) (+ 4 $2))) (/ (- 45.0 $3) 45.0)) int for spell success

.echo $(!classwords $1) / $(!specieswords $1)

.echo $(let (xlg $(!lg $* fmt:'[$x]' stub:"nope")) (if (= $xlg nope) (!log $*) (concat $xlg " " (!log $*))))

.echo $(let* (xs (split "|" (!lm * fmt:'${x[0]}' join:'|' notitle $*)) ps (join " " (map (fn (n) "$n%[$(percentile $xs $n)]") (list 1 5 10 20 30 40 50 60 70 80 90 95 99)))) "X percentiles for $(argst $*): $ps")

!echo ╰( ͡ ° ͜ʖ ͡° )つ──☆*:・ﾟ$*

!lm * newzotorbs urune<=3 (( won || lg:place=zot:5 )) zotorb s=regexp_replace(noun, ".*?(\w+)$", "\1") title:"Zot:5 death rates by orb flavour$(argst $*)" $* / !won

!lg ${1:-*} newzotorbs $* cikiller~~orb_of_(fire|winter|entropy) title:"Zot ORB kills$(argst $*) for $(name_fixup ${1:-*})" stub:"No Zot ORB kills$(argst $*) for $(name_fixup ${1:-*})"

.echo https://CRAWL.XTAHUA.COM/crawl/rcfiles/crawl-$(replace trunk git ${2:-git})/$(!lm ${1:-.} cxc x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

.echo https://crawl.project357.org/rc-files/$(replace git trunk ${2:-trunk})/$(!lm ${1:-.} cpo x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

.echo https://underhound.eu/crawl/rcfiles/crawl-$(replace trunk git ${2:-git})/$(!lm ${1:-.} cue x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

.echo https://cbro.berotato.org/rcfiles/crawl-$(replace trunk git ${2:-git})/$(!lm ${1:-.} cbr2 x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc

!versions

!lm ${1:-.} fmt:"\$(lookup ${2:-${src}} (watchhash))${name}" stub:"No milestones for $(name_fixup ${1:-${user}})."

!lg ${1:-.} gf-good-mons|gf-good-branch|gf-good-dungeon|gf-good-abyss|moonbase|gf-wizard-prison|gf-cloud-mage-hellbinder|gf-elemental-lab $* title:"gammafunk good kills for $(name_fixup ${1:-.})$(argst $*)" stub:"No gammafunk good kills for $(name_fixup ${1:-.})$(argst $*)"

.echo '

.echo $(replace "_" " " $(weighted-rand 100:the_Abyss Hell beam.cc 1:ray.cc 1:stuff.cc 5:#crawl 5:4chan 5:4.1 1:the_Tower_of_Lemuel))

.echo $(if (= $1 cbr2) % (if (= $1 cao) !cao (if (= $1 cdo) @ (if (= $1 cdi) !cdi (if (= $1 cue) \$ (if (= $1 cxc) !| (if (= $1 cpo) # (if (= $1 lld) !lld (if (= $1 cnc) !cnc ?)))))))))

.echo $(let (name (elt $* (branchletterhash))) (if (bound? name) $name $*))

.echo $(join ' => ' $(sub 1 $(split ' => ' $(!cmd $1))))

.echo $(try (exec $*) $*)

!lm * weekmilestone s=src,vlong o=. pfmt:'$(upper ${.}) $(re-replace "([^\s]*).*" "$1" $child)' fmt:'$(re-replace "(.*-g[a-f0-9]{7}).*" "$1" ${.})' join:' ' $*

!lg ${1:-.} $* s=class,gid x=-min(rstart),min(ktype) fmt:'$(if (= ${x[1]} "winning") w l)' pfmt:'$(role_abbrev ${.}):,$(+ 1 (indexof w (split "" $child))),' join:'' stub:'N/A' notitle

!lg ${1:-.} $* s=char,gid x=-min(rstart),min(ktype) fmt:'$(if (= ${x[1]} "winning") w l)' pfmt:'${.}:,$(+ 1 (indexof w (split "" $child))),' join:'' stub:'N/A' notitle

!lg * $* s=char,gid x=-min(rend),min(ktype) fmt:'$(if (= ${x[1]} "winning") w l)' pfmt:'${.}:,$(+ 1 (indexof w (split "" $child))),' join:'' stub:'N/A' notitle

!lg ${1:-.} $* s=crace,gid x=-min(rstart),min(ktype) fmt:'$(if (= ${x[1]} "winning") w l)' pfmt:'$(species_abbrev ${.}):,$(+ 1 (indexof w (split "" $child))),' join:'' stub:'N/A' notitle

!lm ${2:-.} $* vlong>=0.31-a0-1242 br=$1 br.end fmt:"${n}" notitle stub:'0'

.echo $(intactgems ${2:-.} "br=$1 vlong>0.31-a0-1242 $*")

.echo $(let (name (elt $* (godshortnamehash))) (if (bound? name) $name $*))

.echo $(sort $(fn (a b) $(<=> $(list $(int $(sub 3 $a)) $(sub 0 2 $a)) $(list $(int $(sub 3 $b)) $(sub 0 2 $b)))) $(map $(fn (x) $(let (y $(split / $(car $(split " (" $x)))) $(role_abbrev (nth 0 $y)):$(- $(nth 2 $y) $(nth 1 $y)))) $(split ", " $(!lg * playable playable:sp won s=cls x=cdist(crace) / @${*:-.} fmt:"${.}/${x}" o=-cls))))

.echo $(sort $(fn (a b) $(<=> $(list $(int $(sub 3 $a)) $(sub 0 2 $a)) $(list $(int $(sub 3 $b)) $(sub 0 2 $b)))) $(map $(fn (x) $(let (y $(split / $(car $(split " (" $x)))) $(species_abbrev (nth 0 $y)):$(- $(nth 2 $y) $(nth 1 $y)))) $(split ", " $(!lg * playable playable:sp won s=crace x=cdist(char) / @${*:-.} fmt:"${.}/${x}" o=-crace))))

.echo $(sub 0 5 $(* 100.0 $1 $(/ 1.0 $(+ $1 $2))))

.echo $(join ' => ' $(sub 1 $(split ' => ' $(!kw $1))))

!lm * alive t $* s=gid x=max(xl) o=max(xl) join:" || " fmt:"\$(!lm * gid=${.} fmt:'$name: $(upper $src), L$xl $title of ${god:-No God}')" title:"" stub:""

!lm * alive t $* s=gid x=max(nrune),max(xl),max(time) o=max(nrune),max(xl),max(time) join:" || " fmt:"\$(!lm * gid=${.} fmt:'$name: $(upper $src), L$xl $title of ${god:-No God} ($place$(runeformat $nrune))')" title:"" stub:""

.echo $(join ', ' (sub 0 3 (split | (!lm ${1:-.} $* rune s=noun x=+max(time) join:"|" fmt:"${.}"))))

!lm ${*:-.} alive s=name,gid o=-name join:" | " pfmt:"^${.}: ${child}" fmt:"\$(!lm ${*:-.} gid=${.} fmt:'$(upper $src) $explbr $cv, L$xl $char of ${god:-No God}')" stub:"^"

!lm ${*:-.} alive_all s=name,gid o=-name join:" | " pfmt:"^${.}: ${child}" fmt:"\$(!lm ${*:-.} gid=${.} fmt:'$(upper $src) $explbr $cv, L$xl $char of ${god:-No God}')" stub:"^"

.echo $(- (* 18 (** 2 (- $* 1))) 1)

.echo $(let (base (car (split | (nth 1 (split ${1}> (=morgue_link.list ${2:-trunk})))))) (if (bound? base) $base unknown))

.echo >unknown|cao>https://crawl.akrasiac.org/rawdata|cdo>http://crawl.develz.org/morgues/${1:-trunk}|clan>https://www.underhound.eu/crawl/morgue|cpo>https://crawl.project357.org/morgue|cdi>https://crawl.dcss.io/crawl/morgue|cue>https://www.underhound.eu/crawl/morgue|cnc>https://archive.nemelex.cards/morgue|cxc>https://crawl.xtahua.com/crawl/morgue|cbr2>https://cbro.berotato.org/morgue|crg>https://crawl.roguelikes.gg/morgue|cbrg>https://crawl-br.roguelikes.gg/morgue|lld>http://lazy-life.ddo.jp:8000/morgue

!lg ${1:-.} $* s=char,gid x=-min(rstart),min(ktype) fmt:'$(if (= ${x[1]} "winning") w l)' pfmt:'${.}>$child>' join:'' notitle stub:''

.echo Time for a new nchoice! It will appear shortly on the tournament website (if it hasn't yet). Type "!set-nchoice XXXX" to update !nchoice with the new combo, where XXXX should be replaced by the new combo.

.echo $(let* (p ${1:-${user}} c (rand_unwon $p (exact-entry ~${p}_pref 1))) (if (bound? c) (do (ldb-set ~${p}_next 1 $c) $c) (do (ldb-rm! ~${p}_next *) "NONE")))

!lg ${*:-.} rstart=$(!lg ${*:-.} s=char x=min(rstart) fmt:"${x[0]}" join:"|" stub:"") won s=gid fmt:"${.}" join:"|" stub:""

.echo $(nth 0 (map (fn (x) (pluralize $x 2)) (split ', ' "$(!lg ${2:-.} s=class $(if (= "1" $1) won) x=+sum(dur) fmt:'${.}' stub:'?' $*)")))

.echo $(let (es (map (fn (e) (re-replace "^(a|an) " "" $e)) (split ', ' (!lg ${1:-.} $* !won !boring s=ckiller x=+sum(turn) fmt:'${.}' stub:'' notitle)))) $(if (< (length $es) 3) "?" "$(nth 0 $es), $(nth 1 $es), and $(nth 2 $es)"))

.echo $(let (gods (split ', ' "$(!lg ${2:-.} s=god $(if (= "1" $1) won) x=+sum(dur) fmt:'${.}' stub:'?' $*)")) (if (or (= 0 (length $gods)) (not (nth 0 $gods))) Theirself (nth 0 $gods)))

.echo $(let (ps (split ', ' (!lg ${1:-.} $* !won !boring s=place x=+sum(dur) fmt:'${.}' stub:'' notitle))) $(if (< (length $ps) 3) "?" "$(nth 0 $ps), $(nth 1 $ps), and $(nth 2 $ps)"))

.echo $(let (sks (split ', ' (!lg ${1:-.} $* s=sk x=+sum(dur) fmt:'${.}' stub:'' notitle))) $(if (< (length $sks) 3) "?" "$(nth 0 $sks), $(nth 1 $sks), and $(nth 2 $sks)"))

.echo $(nth 0 (map (fn (x) (pluralize $x 2)) (split ', ' "$(!lg ${2:-.} s=crace $(if (= "1" $1) won) x=+sum(dur) fmt:'${.}' stub:'?' $*)")))

!lg ${1:-.} won fmt:'1' stub:'0' $*

.echo adder|alligator|basilisk|bat|big kobold|blink frog|black mamba|boggart|boring beetle|boulder beetle|catoblepas|centaur|centaur warrior|death drake|death yak|deep elf annihilator|deep troll|dire elephant|draconian|emperor scorpion|ettin|faun|fire crab|fire dragon|fire giant|frost giant|giant eyeball|ghost moth|gnoll|golden dragon|goliath beetle|harpy|hobgoblin|ice dragon

.echo jackal|killer bee|kraken|lindwurm|manticore|minotaur|naga|naga sharpshooter|ogre|orb spider|orc priest|quokka|rat|red wasp|salamander|sea snake|sheep|siren|snapping turtle|spiny frog|sphinx|spriggan air mage|stone giant|tarantella|tengu reaver|titan|torpor snail|troll|vault sentinel|warg|wind drake|wolf spider|yak|yaktaur

=racialwill

.echo Will (Base = Apt * XL + Bonus): Sp:7!, Fe:6, Co:5, Mu:5, Na:5, VS:5, DE:4, Dg:4, Dj:4, Fo:4, MD:4, On:4, Po:4, At:3*, Ba:3*, Ds:3*, Dr[purple]:3* (40 Bonus), Dr:3*, Ga:3*, Gn:3*, Hu:3*, Ko:3*, Mf:3*, Mi:3*, Op:3*, Re:3*, Te:3*, Tr:3*

.echo hat of the alchemist&hat of the bear spirit&hat of the high council&hat of pondering&crown of dyrovepreva&mask of the dragon&maxwell's etheric cage

.echo $(sub 0 1 $(sub $(rand $(length $(split & $(=wraith)))) $(split & $(=wraith))))

!lm ${1:-.} fmt:"\$(concat (ignore ${2}) (=bot_prefix ${*:-${src}}))rc ${name} \$(version_fixup ${2:-${v}})" stub:"No milestones for $(name_fixup ${1:-${user}})."

!cmd $1 $(replace $2 $3 $(=cmd $1))

!kw $1 $(replace $2 $3 $(=kw $1))

.echo $(!lm ${1:-.} alive $* fmt:"$char|$title|$xl|$god|$br|$lvl|$absdepth")

.echo recent !won !boring

.echo $(sub 0 1 $(sub $(rand $(length $(split & $(=spellgesture)))) $(split & $(=spellgesture))))

.echo $(sub 0 1 $(sub $(rand $(length $(split & $(=spelltarget $*)))) $(split & $(=spelltarget $*))))

.echo $(let (turns (map int (split (!lm $1 $(concat "(( " $2 " || " $3 " ))") $(ignore $4)$* s=gid x=-${max(turns)-min(turns)} fmt:'${x[0]}' notitle join:' ' stub:'-1' ?: N=2)))) "$(replace _ " " $4) $(name_fixup $1)$(argst $*): Min: $(car $turns), Max: $(last $turns), Median: $(fmtn (listmedian $turns)), Average: $(fmtn (listavg $turns))")

!lm ${1:-.} $* br=pan rune s=gid fmt:'${.}' notitle join:'|' stub:'' ?: N=5

.echo gestures wildly while chanting&mumbles some strange words&casts a spell

.echo gestures at ${*:-something} while chanting&points at ${*:-something} and mumbles some strange words&casts a spell at ${*:-something}

.echo $(ignore 1 $*)$(!lg $(!lg * won $* listnames ?: N>=${1:-500}) $* s=name,gid x=-min(end),min(ktype),min(char) notitle stub:'' fmt:'$(if (= ${x[1]} winning) "${x[2]}," |)' pfmt:'${.}>${child}>' join:'')

.echo $(!lg * $* s=name,gid x=-min(end),min(ktype),min(char) notitle stub:'' fmt:'$(if (= ${x[1]} winning) "${x[2]}," |)' pfmt:'${.}>${child}>' join:'')

.echo Streaks for $(name_fixup ${3:-.})$(argst $*): $(join (reverse (sortby (fn (str) $(int (nth 1 $str))) (map (fn (sp) "$(call $2 $sp): $(replace "one" 1 (re-replace '.*has (\w+) .*win.*' '$1' (re-replace '.*none consecutive.*' 1 (!streak ${3:-.} ${1}=$(replace " " _ $sp) $*))))") (split ", " (!lg ${3:-.} won s=${1} fmt:'${.}' stub:'' $*))))))

!lg $* fmt:"\${target}"

.echo $(let (lmstring (!lm * x=time $* fmt:"$x[0]" stub:"")) (if (= $lmstring "") "literally forever" (let* (t (stamptime $lmstring) d (dayssince $t) H (mod (hourssince $t) 24) M (mod (minutessince $t) 60) S (mod (secondssince $t) 60)) (if (> $d 0) $d" days, ")(if (> $H 0) $H" hours, ")(if (> $M 0) $M" minutes, ")$S" seconds")))

.echo $(!lg * $* !boring fmt:"$n" stub: "0") games

.echo $(!lg * $* !boring x=cdist(name) fmt:"$x" stub: "0") players

.echo total player time $(!lg * $* !boring x=sum(dur) fmt:"$x" stub: "0")

.echo $(!lg * $* urune>0 x=cdist(name) fmt:"$x" stub: "0") runers

.echo $(!lg * $* won x=cdist(name) fmt:"$x" stub: "0") winners

.echo winrate $(!lg * $* !boring s=year(end) / won fmt:"$n_ratio" stub: "NaN")

.echo $(!lg * $* won fmt:"$n" stub:"0") wins

.echo phantom&hungry ghost&shadow wraith&wraith&wraith&wraith&wraith&wraith&freezing wraith&freezing wraith&phantasmal warrior&phantasmal warrior

.echo http://crawl.develz.org/configs/$(replace git trunk ${2:-trunk})/$(!lm ${1:-.} cdo x=name fmt:"${x[0]}" stub:"$(name_fixup $1)").rc