an array for a bunch of “eye” emotes we use, noting that Nightbot may not currently have subscriptions to all of these creators anymore. Array’s name is “eyes”
variables: eyes
const eyes = ['pcrowEyes',
'bryce4Eyes',
'cjyaEyes',
'lycelEyes',
'maizEyes',
'archit3Eyes',
'smolEyes',
'abbybaTea',
'lycelW',
'paintbNoScuff',
'pcrowO',
'maizFlushed',
'pcrowW',
'kaestr1Eyes'];[REMOVED] Previously contained data based on @radravioli_’s insult generator, removed due to disuse and rude out of context. Arrays now inform users this has been removed.
variables: gr1, gr2, gr3
/* original insult generator by @radravioli_ */
const gr1 = ['command'];
const gr2 = ['no longer used'];
const gr3 = ['should find a new one'];An array with the transcript of the popular “lemme smash” meme with expletives and suggestive content removed. Array’s name is “LMS”
variables: LMS
/* eslint-disable no-trailing-spaces */
const LMS = ['This is a nice stick',
'I like sticks (peck peck)',
'No Ron, go find Becky',
'I got you blue.',
'Ugh...',
'Ron, your tail is small.',
'Wot? Swiggity Swooty?',
'You want yellow?',
"She doesn't want yellow.",
'Blue and yellow? No...',
"Ron I'm leaving.",
'What has my life come to?',
'I need you Becky',
'wrong stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'stick',
'Need stick got stick',
'Becky I got stick!'];A list of primes up to 10,000 in an array called “primes.”
variables: primes
const primes = [
'2',
'3',
'5',
'7',
'11',
'13',
'17',
'19',
'23',
'29',
'31',
'37',
'41',
'43',
'47',
'53',
'59',
'61',
'67',
'71',
'73',
'79',
'83',
'89',
'97',
'101',
'103',
'107',
'109',
'113',
'127',
'131',
'137',
'139',
'149',
'151',
'157',
'163',
'167',
'173',
'179',
'181',
'191',
'193',
'197',
'199',
'211',
'223',
'227',
'229',
'233',
'239',
'241',
'251',
'257',
'263',
'269',
'271',
'277',
'281',
'283',
'293',
'307',
'311',
'313',
'317',
'331',
'337',
'347',
'349',
'353',
'359',
'367',
'373',
'379',
'383',
'389',
'397',
'401',
'409',
'419',
'421',
'431',
'433',
'439',
'443',
'449',
'457',
'461',
'463',
'467',
'479',
'487',
'491',
'499',
'503',
'509',
'521',
'523',
'541',
'547',
'557',
'563',
'569',
'571',
'577',
'587',
'593',
'599',
'601',
'607',
'613',
'617',
'619',
'631',
'641',
'643',
'647',
'653',
'659',
'661',
'673',
'677',
'683',
'691',
'701',
'709',
'719',
'727',
'733',
'739',
'743',
'751',
'757',
'761',
'769',
'773',
'787',
'797',
'809',
'811',
'821',
'823',
'827',
'829',
'839',
'853',
'857',
'859',
'863',
'877',
'881',
'883',
'887',
'907',
'911',
'919',
'929',
'937',
'941',
'947',
'953',
'967',
'971',
'977',
'983',
'991',
'997',
'1009',
'1013',
'1019',
'1021',
'1031',
'1033',
'1039',
'1049',
'1051',
'1061',
'1063',
'1069',
'1087',
'1091',
'1093',
'1097',
'1103',
'1109',
'1117',
'1123',
'1129',
'1151',
'1153',
'1163',
'1171',
'1181',
'1187',
'1193',
'1201',
'1213',
'1217',
'1223',
'1229',
'1231',
'1237',
'1249',
'1259',
'1277',
'1279',
'1283',
'1289',
'1291',
'1297',
'1301',
'1303',
'1307',
'1319',
'1321',
'1327',
'1361',
'1367',
'1373',
'1381',
'1399',
'1409',
'1423',
'1427',
'1429',
'1433',
'1439',
'1447',
'1451',
'1453',
'1459',
'1471',
'1481',
'1483',
'1487',
'1489',
'1493',
'1499',
'1511',
'1523',
'1531',
'1543',
'1549',
'1553',
'1559',
'1567',
'1571',
'1579',
'1583',
'1597',
'1601',
'1607',
'1609',
'1613',
'1619',
'1621',
'1627',
'1637',
'1657',
'1663',
'1667',
'1669',
'1693',
'1697',
'1699',
'1709',
'1721',
'1723',
'1733',
'1741',
'1747',
'1753',
'1759',
'1777',
'1783',
'1787',
'1789',
'1801',
'1811',
'1823',
'1831',
'1847',
'1861',
'1867',
'1871',
'1873',
'1877',
'1879',
'1889',
'1901',
'1907',
'1913',
'1931',
'1933',
'1949',
'1951',
'1973',
'1979',
'1987',
'1993',
'1997',
'1999',
'2003',
'2011',
'2017',
'2027',
'2029',
'2039',
'2053',
'2063',
'2069',
'2081',
'2083',
'2087',
'2089',
'2099',
'2111',
'2113',
'2129',
'2131',
'2137',
'2141',
'2143',
'2153',
'2161',
'2179',
'2203',
'2207',
'2213',
'2221',
'2237',
'2239',
'2243',
'2251',
'2267',
'2269',
'2273',
'2281',
'2287',
'2293',
'2297',
'2309',
'2311',
'2333',
'2339',
'2341',
'2347',
'2351',
'2357',
'2371',
'2377',
'2381',
'2383',
'2389',
'2393',
'2399',
'2411',
'2417',
'2423',
'2437',
'2441',
'2447',
'2459',
'2467',
'2473',
'2477',
'2503',
'2521',
'2531',
'2539',
'2543',
'2549',
'2551',
'2557',
'2579',
'2591',
'2593',
'2609',
'2617',
'2621',
'2633',
'2647',
'2657',
'2659',
'2663',
'2671',
'2677',
'2683',
'2687',
'2689',
'2693',
'2699',
'2707',
'2711',
'2713',
'2719',
'2729',
'2731',
'2741',
'2749',
'2753',
'2767',
'2777',
'2789',
'2791',
'2797',
'2801',
'2803',
'2819',
'2833',
'2837',
'2843',
'2851',
'2857',
'2861',
'2879',
'2887',
'2897',
'2903',
'2909',
'2917',
'2927',
'2939',
'2953',
'2957',
'2963',
'2969',
'2971',
'2999',
'3001',
'3011',
'3019',
'3023',
'3037',
'3041',
'3049',
'3061',
'3067',
'3079',
'3083',
'3089',
'3109',
'3119',
'3121',
'3137',
'3163',
'3167',
'3169',
'3181',
'3187',
'3191',
'3203',
'3209',
'3217',
'3221',
'3229',
'3251',
'3253',
'3257',
'3259',
'3271',
'3299',
'3301',
'3307',
'3313',
'3319',
'3323',
'3329',
'3331',
'3343',
'3347',
'3359',
'3361',
'3371',
'3373',
'3389',
'3391',
'3407',
'3413',
'3433',
'3449',
'3457',
'3461',
'3463',
'3467',
'3469',
'3491',
'3499',
'3511',
'3517',
'3527',
'3529',
'3533',
'3539',
'3541',
'3547',
'3557',
'3559',
'3571',
'3581',
'3583',
'3593',
'3607',
'3613',
'3617',
'3623',
'3631',
'3637',
'3643',
'3659',
'3671',
'3673',
'3677',
'3691',
'3697',
'3701',
'3709',
'3719',
'3727',
'3733',
'3739',
'3761',
'3767',
'3769',
'3779',
'3793',
'3797',
'3803',
'3821',
'3823',
'3833',
'3847',
'3851',
'3853',
'3863',
'3877',
'3881',
'3889',
'3907',
'3911',
'3917',
'3919',
'3923',
'3929',
'3931',
'3943',
'3947',
'3967',
'3989',
'4001',
'4003',
'4007',
'4013',
'4019',
'4021',
'4027',
'4049',
'4051',
'4057',
'4073',
'4079',
'4091',
'4093',
'4099',
'4111',
'4127',
'4129',
'4133',
'4139',
'4153',
'4157',
'4159',
'4177',
'4201',
'4211',
'4217',
'4219',
'4229',
'4231',
'4241',
'4243',
'4253',
'4259',
'4261',
'4271',
'4273',
'4283',
'4289',
'4297',
'4327',
'4337',
'4339',
'4349',
'4357',
'4363',
'4373',
'4391',
'4397',
'4409',
'4421',
'4423',
'4441',
'4447',
'4451',
'4457',
'4463',
'4481',
'4483',
'4493',
'4507',
'4513',
'4517',
'4519',
'4523',
'4547',
'4549',
'4561',
'4567',
'4583',
'4591',
'4597',
'4603',
'4621',
'4637',
'4639',
'4643',
'4649',
'4651',
'4657',
'4663',
'4673',
'4679',
'4691',
'4703',
'4721',
'4723',
'4729',
'4733',
'4751',
'4759',
'4783',
'4787',
'4789',
'4793',
'4799',
'4801',
'4813',
'4817',
'4831',
'4861',
'4871',
'4877',
'4889',
'4903',
'4909',
'4919',
'4931',
'4933',
'4937',
'4943',
'4951',
'4957',
'4967',
'4969',
'4973',
'4987',
'4993',
'4999',
'5003',
'5009',
'5011',
'5021',
'5023',
'5039',
'5051',
'5059',
'5077',
'5081',
'5087',
'5099',
'5101',
'5107',
'5113',
'5119',
'5147',
'5153',
'5167',
'5171',
'5179',
'5189',
'5197',
'5209',
'5227',
'5231',
'5233',
'5237',
'5261',
'5273',
'5279',
'5281',
'5297',
'5303',
'5309',
'5323',
'5333',
'5347',
'5351',
'5381',
'5387',
'5393',
'5399',
'5407',
'5413',
'5417',
'5419',
'5431',
'5437',
'5441',
'5443',
'5449',
'5471',
'5477',
'5479',
'5483',
'5501',
'5503',
'5507',
'5519',
'5521',
'5527',
'5531',
'5557',
'5563',
'5569',
'5573',
'5581',
'5591',
'5623',
'5639',
'5641',
'5647',
'5651',
'5653',
'5657',
'5659',
'5669',
'5683',
'5689',
'5693',
'5701',
'5711',
'5717',
'5737',
'5741',
'5743',
'5749',
'5779',
'5783',
'5791',
'5801',
'5807',
'5813',
'5821',
'5827',
'5839',
'5843',
'5849',
'5851',
'5857',
'5861',
'5867',
'5869',
'5879',
'5881',
'5897',
'5903',
'5923',
'5927',
'5939',
'5953',
'5981',
'5987',
'6007',
'6011',
'6029',
'6037',
'6043',
'6047',
'6053',
'6067',
'6073',
'6079',
'6089',
'6091',
'6101',
'6113',
'6121',
'6131',
'6133',
'6143',
'6151',
'6163',
'6173',
'6197',
'6199',
'6203',
'6211',
'6217',
'6221',
'6229',
'6247',
'6257',
'6263',
'6269',
'6271',
'6277',
'6287',
'6299',
'6301',
'6311',
'6317',
'6323',
'6329',
'6337',
'6343',
'6353',
'6359',
'6361',
'6367',
'6373',
'6379',
'6389',
'6397',
'6421',
'6427',
'6449',
'6451',
'6469',
'6473',
'6481',
'6491',
'6521',
'6529',
'6547',
'6551',
'6553',
'6563',
'6569',
'6571',
'6577',
'6581',
'6599',
'6607',
'6619',
'6637',
'6653',
'6659',
'6661',
'6673',
'6679',
'6689',
'6691',
'6701',
'6703',
'6709',
'6719',
'6733',
'6737',
'6761',
'6763',
'6779',
'6781',
'6791',
'6793',
'6803',
'6823',
'6827',
'6829',
'6833',
'6841',
'6857',
'6863',
'6869',
'6871',
'6883',
'6899',
'6907',
'6911',
'6917',
'6947',
'6949',
'6959',
'6961',
'6967',
'6971',
'6977',
'6983',
'6991',
'6997',
'7001',
'7013',
'7019',
'7027',
'7039',
'7043',
'7057',
'7069',
'7079',
'7103',
'7109',
'7121',
'7127',
'7129',
'7151',
'7159',
'7177',
'7187',
'7193',
'7207',
'7211',
'7213',
'7219',
'7229',
'7237',
'7243',
'7247',
'7253',
'7283',
'7297',
'7307',
'7309',
'7321',
'7331',
'7333',
'7349',
'7351',
'7369',
'7393',
'7411',
'7417',
'7433',
'7451',
'7457',
'7459',
'7477',
'7481',
'7487',
'7489',
'7499',
'7507',
'7517',
'7523',
'7529',
'7537',
'7541',
'7547',
'7549',
'7559',
'7561',
'7573',
'7577',
'7583',
'7589',
'7591',
'7603',
'7607',
'7621',
'7639',
'7643',
'7649',
'7669',
'7673',
'7681',
'7687',
'7691',
'7699',
'7703',
'7717',
'7723',
'7727',
'7741',
'7753',
'7757',
'7759',
'7789',
'7793',
'7817',
'7823',
'7829',
'7841',
'7853',
'7867',
'7873',
'7877',
'7879',
'7883',
'7901',
'7907',
'7919',
'7927',
'7933',
'7937',
'7949',
'7951',
'7963',
'7993',
'8009',
'8011',
'8017',
'8039',
'8053',
'8059',
'8069',
'8081',
'8087',
'8089',
'8093',
'8101',
'8111',
'8117',
'8123',
'8147',
'8161',
'8167',
'8171',
'8179',
'8191',
'8209',
'8219',
'8221',
'8231',
'8233',
'8237',
'8243',
'8263',
'8269',
'8273',
'8287',
'8291',
'8293',
'8297',
'8311',
'8317',
'8329',
'8353',
'8363',
'8369',
'8377',
'8387',
'8389',
'8419',
'8423',
'8429',
'8431',
'8443',
'8447',
'8461',
'8467',
'8501',
'8513',
'8521',
'8527',
'8537',
'8539',
'8543',
'8563',
'8573',
'8581',
'8597',
'8599',
'8609',
'8623',
'8627',
'8629',
'8641',
'8647',
'8663',
'8669',
'8677',
'8681',
'8689',
'8693',
'8699',
'8707',
'8713',
'8719',
'8731',
'8737',
'8741',
'8747',
'8753',
'8761',
'8779',
'8783',
'8803',
'8807',
'8819',
'8821',
'8831',
'8837',
'8839',
'8849',
'8861',
'8863',
'8867',
'8887',
'8893',
'8923',
'8929',
'8933',
'8941',
'8951',
'8963',
'8969',
'8971',
'8999',
'9001',
'9007',
'9011',
'9013',
'9029',
'9041',
'9043',
'9049',
'9059',
'9067',
'9091',
'9103',
'9109',
'9127',
'9133',
'9137',
'9151',
'9157',
'9161',
'9173',
'9181',
'9187',
'9199',
'9203',
'9209',
'9221',
'9227',
'9239',
'9241',
'9257',
'9277',
'9281',
'9283',
'9293',
'9311',
'9319',
'9323',
'9337',
'9341',
'9343',
'9349',
'9371',
'9377',
'9391',
'9397',
'9403',
'9413',
'9419',
'9421',
'9431',
'9433',
'9437',
'9439',
'9461',
'9463',
'9467',
'9473',
'9479',
'9491',
'9497',
'9511',
'9521',
'9533',
'9539',
'9547',
'9551',
'9587',
'9601',
'9613',
'9619',
'9623',
'9629',
'9631',
'9643',
'9649',
'9661',
'9677',
'9679',
'9689',
'9697',
'9719',
'9721',
'9733',
'9739',
'9743',
'9749',
'9767',
'9769',
'9781',
'9787',
'9791',
'9803',
'9811',
'9817',
'9829',
'9833',
'9839',
'9851',
'9857',
'9859',
'9871',
'9883',
'9887',
'9901',
'9907',
'9923',
'9929',
'9931',
'9941',
'9949',
'9967',
'9973'];A list of rude words to use in conjuction with “testfor.js” below, which allows some auto-blocking/banning, or detecting where a block/ban is in order. As such, array name is “testFor”
variables: testFor
const testFor = [
'ugly',
'fat',
'stubborn',
'annoying',
'dumb',
'stupid',
'bossy',
'boring',
'bitchy',
'impatient',
'lazy',
'mean',
'nasty',
'jealous',
'rude',
'cringe',
'tired',
'mushy',
'ugle'
];[REMOVED] Previously contained various quotes by John Mulaney, out of context. Removed due to disuse/use of expletives. Current version warns anyone still using this array to find a different source.
variables: jm
/* eslint-disable no-trailing-spaces */
const jm = ['Quotes have been removed, sorry! Please find a different source'];creates a variable “gaus” with a normal distribution from (0,1) //originally made by joshuakcockrell on stackoverflow, adapted by gem
variables: gaus
let gaus = -1;
while (gaus > 1 || gaus < 0) {
let u = 0;
let v = 0;
while (u === 0) u = Math.random();
while (v === 0) v = Math.random();
gaus = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
gaus = gaus / 10.0 + 0.5;
}requires an input string “text” that will then be output with a random number of typos. Original iteration that swaps and duplicates some letters. No longer auto-sends message (returns “text” with typos)
variables: words, text
/* Tell ESLint that there will be the following global variables */
/* global text:true */
if (text.length === 0) {
text = 'You gotta enter a sentence to typo, silly!';
}
const words = text.split(' ');
for (let i = 0; i < words.length; i++) {
const ltrs = words[i].split('');
for (let j = 1; j < ltrs.length - 1; j++) {
if (Math.random() < 0.15) {
if (Math.random() < 0.7) {
const tmp = ltrs[j];
ltrs[j] = ltrs[j + 1];
ltrs[j + 1] = tmp;
j++;
} else {
ltrs[j] += ltrs[j];
}
}
}
words[i] = ltrs.join('');
}
text = words.join(' ');same as the typo algo above but allows some control of level of typos made if the sentence contains “typo[number]”, up to 10.
variables: text, words, iptNum, repeatNum
/* Tell ESLint that there will be the following global variables */
/* global text:true */
/* These ESLint errors should be handled, but for now I just want to get it to pass */
/* eslint-disable prefer-const */
let iptNum = 1;
if (text.length === 0) {
text = 'You gotta enter a sentence to typo, silly!';
} else if (/^help$|^\\?$|^info$/.test(text)) {
text = "Gem's typo v1! allows even more cursed typos if you start with typo[num], up to 10";
iptNum = 0;
} else {
const rgex = /typo(\d+)[\s,]/;
const fndwrd = text.match(rgex);
const pos = text.search(rgex);
if (fndwrd !== null) {
let last = fndwrd[0].substr(-1);
if (last !== ',') {
last = '';
}
iptNum = fndwrd[1];
text = text.substr(0, pos) + last + text.substr(pos + fndwrd[0].length);
}
}
let repeatNum = 0;
if (iptNum > 10 || iptNum < 0) {
repeatNum = 4;
} else if (iptNum > 6) {
repeatNum = iptNum - 6;
}
let words = text.split(' ');
for (let i = 0; i < words.length; i++) {
let ltrs = words[i].split('');
for (let j = 1; j < ltrs.length - 1; j++) {
if (Math.random() < (0.15 * iptNum)) {
if (Math.random() < 0.7) {
let tmp = ltrs[j];
ltrs[j] = ltrs[j + 1];
ltrs[j + 1] = tmp;
j++;
} else {
ltrs[j] += ltrs[j];
}
}
if (j > 1 && Math.random() < (0.025 * repeatNum)) {
j--;
}
}
words[i] = ltrs.join('');
}
text = words.join(' ');same as typo_1.js but with an improved function of also making typos with letters commonly mistyped on a QWERTY keyboard.
variables: text, words, iptNum, repeatNum
/* Tell ESLint that there will be the following global variables */
/* global text:true */
/* These ESLint errors should be handled, but for now I just want to get it to pass */
/* eslint-disable prefer-const, no-prototype-builtins */
let iptNum = 1;
if (text.length === 0) {
text = 'You gotta enter a sentence to typo, silly!';
} else if (/^help$|^\\?$|^info$/.test(text)) {
text = "Gem's typo v2! more jumbled typos if you start with typo[num], up to 10";
iptNum = 0;
} else {
const rgex = /typo(\d+)[\s,]/;
const fndwrd = text.match(rgex);
const pos = text.search(rgex);
if (fndwrd !== null) {
let last = fndwrd[0].substr(-1);
if (last !== ',') {
last = '';
}
iptNum = fndwrd[1];
text = text.substr(0, pos) + last + text.substr(pos + fndwrd[0].length);
}
}
let repeatNum = 0;
if (iptNum > 10 || iptNum < 0) {
repeatNum = 4;
} else if (iptNum > 6) {
repeatNum = iptNum - 6;
}
// loosely based on https://datagenetics.com/blog/november42012/index.html
const adjChars = {
a: ['s', 's', 'w', 'x'],
b: ['f', 'g', 'n', 'h'],
c: ['d', 'f', 's', 's'],
d: ['e', 'r', 's', 's'],
e: ['r', 'r', 's', 's'],
f: ['t', 'r', 'f', 'b'],
g: ['t', 'f', 'n', 'h'],
h: ['g', 'm', 'n', 'u'],
i: ['o', 'o', 'u', 'l'],
j: ['h', 'm', 'n', 'k'],
k: ['l', 'i', 'm', 'o'],
l: ['i', 'o', 'p', 'k'],
m: ['h', 'j', 'k', 'n'],
n: ['m', 'b', 'g', 'h'],
o: ['i', 'i', 'l', 'p'],
p: ['l', 'l', 'o', 'o'],
q: ['s', 's', 'a', 'w'],
r: ['e', 'd', 'g', 't'],
s: ['d', 'e', 'c', 'a'],
t: ['f', 'g', 'h', 'r'],
u: ['i', 'i', 'y', 'h'],
v: ['b', 'c', 'd', 'f'],
w: ['a', 'd', 'e', 's'],
x: ['a', 'c', 'd', 's'],
y: ['g', 'g', 'h', 'h'],
z: ['s', 's', 'a', 'x'],
',': ['m', '.', '.', '<'],
'.': [',', ',', '/', '>']
};
let words = text.split(' ');
for (let i = 0; i < words.length; i++) {
let ltrs = words[i].split('');
for (let j = 1; j < ltrs.length - 1; j++) {
if (Math.random() < (0.15 * iptNum)) {
if (Math.random() < 0.65) {
let tmp = ltrs[j];
ltrs[j] = ltrs[j + 1];
ltrs[j + 1] = tmp;
j++;
} else if (Math.random() < 0.5) {
ltrs[j] += ltrs[j];
} else {
if (adjChars.hasOwnProperty(ltrs[j])) {
ltrs[j] = adjChars[ltrs[j]][Math.floor(Math.random() * 4)];
}
}
}
if (j > 1 && Math.random() < (0.025 * repeatNum)) {
j--;
}
}
words[i] = ltrs.join('');
}
text = words.join(' ');requires an input string “text” and array “testFor” that “text” will be tested against. Outputs “trg” that is true if triggered. Uses regex, case insensitive.
variables: trg, text, testFor, regTest
/* Tell ESLint that there will be a global mutable `testFor` variable and a global `text` variable */
/* global testFor:true, text */
let trg = false;
/* original regex solution from jfriend00 on stackoverflow */
const regTest = new RegExp(testFor.join('|'), 'i');
if (regTest.test(text)) {
trg = true;
}Convert units to other units. Requires an input string ‘text’ in the form ‘[number] [inputUnit] [outputUnit]’. See the Reference Sheet for more details.
variables: text, msg, val, helpTrg, cvrtvals, temperature, length, volume, massweight, area, time
/* global text:true */
/* whitespace issues */
/* eslint-disable no-tabs, indent, no-unused-expressions, no-prototype-builtins */
// a 2 matrix row implementation of Levenshtein
function Levenshtein (string1, string2) {
const len = string2.length;
let test1 = Array(len + 1).fill(null);
// initialise row 0
for (let i = 0; i <= len; i++) {
test1[i] = i;
}
for (let i = 0; i < string1.length; i++) {
const test2 = Array(len + 1).fill(null);
test2[0] = i + 1;
for (let j = 0; j < len; j++) {
const change = string1[i] === string2[j] ? 0 : 1;
test2[j + 1] = Math.min(test1[j + 1] + 1, test2[j] + 1, test1[j] + change);
}
test1 = test2;
}
return test1[len];
}
// returns an array of weighted minimum distances and their associated attribute
// will do a case insensitive search (utilising .toLowerCase())
function closestObjectAttribute (inputString, inputObject) {
let maxMatch = [];
for (const attribute in inputObject) {
let lDist = Levenshtein(inputString.toLowerCase(), attribute.toLowerCase());
// weighting for longer attributes
if (attribute.length > inputString.length) {
lDist = lDist - Math.floor((attribute.length - inputString.length) * 0.75);
}
if (maxMatch.length === 0) {
maxMatch = [
[lDist, attribute]
];
} else if (lDist < maxMatch[0][0]) {
maxMatch = [
[lDist, attribute]
];
} else if (lDist === maxMatch[0][0]) {
maxMatch.push([lDist, attribute]);
}
}
return maxMatch;
}
let msg;
let helpTrg = 0;
if (/\bhelp\b/i.test(text) || text.length === 0) {
helpTrg = 1;
if (/\btemp/i.test(text)) {
helpTrg = 3;
} else if (/\blen/i.test(text)) {
helpTrg = 4;
} else if (/\bvol/i.test(text)) {
helpTrg = 5;
} else if (/\bmass|\bwei/i.test(text)) {
helpTrg = 6;
} else if (/\barea/i.test(text)) {
helpTrg = 7;
} else if (/\btime/i.test(text)) {
helpTrg = 8;
}
} else if (/\bdebug\b/.test(text)) {
helpTrg = -2;
text = text.replace(/\bdebug\b/, '');
text = text.replace(/\s\s+/g, ' ');
if (text.charAt(0) === ' ') {
text = text.substr(1);
}
if (text.charAt(-1) === ' ') {
text = text.slice(0, -1);
}
}
text = text.replace(/\s+to\s+/i, ' ');
text = text.replace(/\bcubic\s+/ig, 'cubic');
text = text.replace(/\bsquare\s+/ig, 'square');
const cvrtvals = text.split(' ');
if (cvrtvals.length < 2 && helpTrg === 0) {
helpTrg = 2;
} else if (cvrtvals.length > 2) {
cvrtvals[0] += cvrtvals[1];
cvrtvals[1] = cvrtvals[2];
}
let val = parseFloat(cvrtvals[0]);
const getUnitRegex = /^[\d.-]*/;
if (isNaN(val) && (helpTrg === 0 || helpTrg === -2)) {
val = 1;
}
if (/^format_time$|^time$|^f_t$/.test(cvrtvals[0])) {
helpTrg = -1;
}
const gaboVal = 1.8288 * 73 / 72;
const conversions = (function () {
const factor = i => ({
from: j => j * i,
to: j => j / i
});
return {
temperature: {
C: factor(1),
F: {
from: val => (val - 32) * 5 / 9,
to: val => val * 1.8 + 32
},
K: {
from: val => val - 273.15,
to: val => val + 273.15
},
Celsius: 'C',
celsius: 'C',
Fahrenheit: 'F',
fahrenheit: 'F',
Kelvin: 'K',
kelvin: 'K'
},
length: {
m: factor(1),
cm: factor(1 / 100),
mm: factor(1 / 1000),
µm: factor(1 / 1000000),
km: factor(1000),
yd: factor(0.9144),
ft: factor(0.3048),
in: factor(0.0254),
mi: factor(1609.344),
twip: { suffix: ' twips (typographical)', ...factor(0.0254 / 1440) },
point: { suffix: ' point (typographical)', ...factor(0.0254 / 72) },
line: { suffix: ' ln (using 1/12 inch definition, obsolete)', ...factor(0.0254 / 12) },
poppyseed: { suffix: ' poppyseeds (using 1/4 barleycorn definition, obsolete)', ...factor(0.0254 / 12) },
pica: { suffix: ' picas (typographical)', ...factor(0.0254 / 6) },
barleycorn: { suffix: ' barleycorns', ...factor(0.0254 / 3) },
digit: { suffix: ' digits (English, obsolete)', ...factor(0.01905) },
finger: { suffix: ' finger (obsolete)', ...factor(0.022225) },
nail: { suffix: ' nails (used for cloth)', ...factor(0.05715) },
palm: { suffix: ' palms (obsolete)', ...factor(0.0762) },
hand: { suffix: ' hands (used for horses)', ...factor(0.1016) },
shaftment: { suffix: ' shaftments (obsolete)', ...factor(0.1524) },
link: { suffix: ' links (1/100 of a chain)', ...factor(0.201168) },
span: { suffix: ' spans', ...factor(0.2286) },
cubit: { suffix: ' cubits (obsolete)', ...factor(0.4572) },
ell: { suffix: ' ells (english, tailoring, obsolete)', ...factor(1.143) },
fathom: { suffix: ' fathoms', ...factor(1.8288) },
rod: { suffix: ' rod/perch/pole (surveying, obsolete)', ...factor(19800 / 3937) },
chain: { suffix: ' chains (Gunter\'s)', ...factor(20.1168) },
furlong: { suffix: ' furlongs', ...factor(201.168) },
nau_mile: { suffix: ' nautical miles', ...factor(1852) },
league: { suffix: ' nautical leagues', ...factor(5556) },
surveyfoot: { suffix: ' US survey feet', ...factor(1200 / 3937) },
ligne: { suffix: ' Paris line (watchmaking)', ...factor(0.002255829062297) },
'light-seconds': { suffix: ' light-seconds', ...factor(299792458) },
micron: { suffix: ' microns', ...factor(1 / 1000000) },
AWG: {
suffix: ' American Wire Gauge',
from: val => 0.000127 * 92 ** ((36 - val) / 39),
to: val => -39 * Math.log(val / 0.000127) / Math.log(92) + 36
},
au: { suffix: ' astronomical units', ...factor(149597870700) },
gabo: { suffix: ' gabos', ...factor(gaboVal) },
smoot: { suffix: ' smoots', ...factor(1.7018) },
metre: 'm',
metres: 'm',
meter: 'm',
meters: 'm',
centimetre: 'cm',
centimetres: 'cm',
centimeter: 'cm',
centimeters: 'cm',
millimetre: 'mm',
millimetres: 'mm',
millimeter: 'mm',
millimeters: 'mm',
micrometre: 'µm',
micrometres: 'µm',
micrometer: 'µm',
micrometers: 'µm',
um: 'µm',
kilometre: 'km',
kilometres: 'km',
kilometer: 'km',
kilometers: 'km',
yard: 'yd',
yards: 'yd',
foot: 'ft',
feet: 'ft',
inch: 'in',
inches: 'in',
mile: 'mi',
miles: 'mi',
twips: 'twip',
DTPpoint: 'point',
lines: 'line',
poppyseeds: 'poppyseed',
picas: 'pica',
barleycorns: 'barleycorn',
hands: 'hand',
spans: 'span',
fathoms: 'fathom',
perch: 'rod',
pole: 'rod',
furlongs: 'furlong',
nauticalmile: 'nau_mile',
nauticalmiles: 'nau_mile',
leagues: 'league',
µ: 'micron',
microns: 'micron',
gauge: 'AWG',
gaugewire: 'AWG',
astronomicalunits: 'au',
gabos: 'gabo',
smoots: 'smoot'
},
volume: {
L: factor(1),
mL: factor(0.001),
'm^3': { suffix: ' cubic metres', ...factor(1000) },
'cm^3': { suffix: ' cubic centimetres', ...factor(0.001) },
imp_gal: { suffix: ' gallons (imperial)', ...factor(4.54609) },
gal: { suffix: ' gallons (US)', ...factor(3.785411784) },
pottle: { suffix: ' pottle (US, obsolete)', ...factor(1.892705892) },
qt: { suffix: ' quarts (US)', ...factor(0.946352946) },
pt: { suffix: ' pints (US)', ...factor(0.473176473) },
c: { suffix: ' cups (US)', ...factor(0.2365882365) },
gill: { suffix: ' gill (US)', ...factor(0.11829411825) },
floz: { suffix: ' fluid ounces (US)', ...factor(0.0295735295625) },
tsp: { suffix: ' teaspoons (US)', ...factor(0.00492892159375) },
Tbsp: { suffix: ' Tablespoons (US)', ...factor(0.01478676478125) },
fldram: { suffix: ' fluid drams (US)', ...factor(0.0036966911953125) },
minim: { suffix: ' min', ...factor(0.000061611519921875) },
firkin: { suffix: ' firkins (imperial)', ...factor(40.91481) },
bushel: { suffix: ' bushels', ...factor(35.23907) },
stick_of_butter: { suffix: ' US sticks of butter', ...factor(0.11829411825) },
cord: { suffix: ' cords (firewood)', ...factor(3624.556363776) },
bdft: { suffix: ' board feet (lumber)', ...factor(2.359737216) },
'gabo^3': {
suffix: ' cubic gabos',
from: val => val * (gaboVal ** 3) * 1000,
to: val => (val / 1000) / (gaboVal ** 3)
},
litre: 'L',
litres: 'L',
liter: 'L',
liters: 'L',
mil: 'mL',
ml: 'mL',
millilitre: 'mL',
millilitres: 'mL',
milliliter: 'mL',
milliliters: 'mL',
cubicmetre: 'm^3',
cubicmetres: 'm^3',
cubicmeter: 'm^3',
cubicmeters: 'm^3',
cubicm: 'm^3',
cc: 'cm^3',
cubiccentimetre: 'cm^3',
cubiccentimetres: 'cm^3',
cubiccentimeter: 'cm^3',
cubiccentimeters: 'cm^3',
cubiccm: 'cm^3',
imperialgal: 'imp_gal',
impgal: 'imp_gal',
gallon: 'gal',
gallons: 'gal',
quart: 'qt',
quarts: 'qt',
pint: 'pt',
pints: 'pt',
cup: 'c',
cups: 'c',
fluidounce: 'floz',
fluidounces: 'floz',
fl_oz: 'floz',
teaspoon: 'tsp',
teaspoons: 'tsp',
tablespoon: 'Tbsp',
tablespoons: 'Tbsp',
fldrachm: 'fldram',
fl_dram: 'fldram',
bu: 'bushel',
bushels: 'bushel',
butter: 'stick_of_butter',
butterstick: 'stick_of_butter',
buttersticks: 'stick_of_butter',
cords: 'cord',
boardfoot: 'bdft',
boardfeet: 'bdft',
cubicgabo: 'gabo^3',
cubicgabos: 'gabo^3'
},
massweight: {
kg: factor(1),
g: factor(1 / 1000),
metric_ton: { suffix: ' tonnes (metric tons)', ...factor(1000) },
ton: { suffix: ' tons (US)', ...factor(2000 / 2.20462262) },
lbs: factor(1 / 2.20462262),
oz: { suffix: ' ounces', ...factor(1 / 35.27396195) },
ct: { suffix: ' carats', ...factor(0.0002) },
stone: { suffix: ' stone', ...factor(1 / 0.15747) },
grain: { suffix: ' grain', ...factor(0.00006479891) },
dwt: { suffix: ' pennyweights (troy)', ...factor(0.00155517384) },
troy_oz: { suffix: ' ounces (troy)', ...factor(0.0311034768) },
troy_pound: { suffix: ' pounds (troy)', ...factor(0.37324172) },
amu: { suffix: ' atomic mass units', ...factor(1 / 6.02217364335e+26) },
Jupiter: { suffix: ' Jupiters', ...factor(1.898e+27) },
solar_mass: { suffix: ' solar masses', ...factor(1.989e+30) },
kgs: 'kg',
kilogram: 'kg',
kilograms: 'kg',
kilogramme: 'kg',
kilogrammes: 'kg',
gram: 'g',
grams: 'g',
gramme: 'g',
grammes: 'g',
tons: 'ton',
metric_tons: 'metric_ton',
tonne: 'metric_ton',
tonnes: 'metric_ton',
lb: 'lbs',
pound: 'lbs',
pounds: 'lbs',
ozs: 'oz',
ounce: 'oz',
ounces: 'oz',
carat: 'ct',
carats: 'ct',
pennyweight: 'dwt',
pennyweights: 'dwt',
oz_t: 'troy_oz',
troy_ounce: 'troy_oz',
lb_t: 'troy_pound',
troy_lb: 'troy_pound',
Jupiters: 'Jupiter',
sun_mass: 'solar_mass'
},
area: {
'm^2': {
suffix: ' square metres',
...factor(1)
},
'cm^2': { suffix: ' square centimetres', ...factor(0.0001) },
'km^2': { suffix: ' square kilometres', ...factor(1000000) },
'ft^2': { suffix: ' square feet', ...factor(0.09290304) },
'in^2': { suffix: ' square inches', ...factor(0.00064516) },
square_rod: { suffix: ' square rod/perch/pole (obsolete)', ...factor(25.29285264) },
ro: { suffix: ' roods (obsolete)', ...factor(1011.7141056) },
acre: { suffix: ' acres', ...factor(4046.8564224) },
hectare: { suffix: ' hectares', ...factor(10000) },
bovate: { suffix: ' oxgangs (approx, obsolete)', ...factor(60000) },
virgate: { suffix: ' virgates (approx, obsolete)', ...factor(120000) },
carucate: { suffix: ' carucates (approx, obsolete)', ...factor(490000) },
'gabo^2': {
suffix: ' square gabos',
from: val => val * (gaboVal ** 2),
to: val => val / (gaboVal ** 2)
},
squaremetre: 'm^2',
squaremetres: 'm^2',
squaremeter: 'm^2',
squaremeters: 'm^2',
sqmetre: 'm^2',
sqmeter: 'm^2',
squarem: 'm^2',
squarecentimetre: 'cm^2',
squarecentimetres: 'cm^2',
squarecentimeter: 'cm^2',
squarecentimeters: 'cm^2',
sqcm: 'cm^2',
squarecm: 'cm^2',
squarefoot: 'ft^2',
squarefeet: 'ft^2',
sqft: 'ft^2',
squareft: 'ft^2',
squareinch: 'in^2',
squareinches: 'in^2',
sqin: 'in^2',
squarein: 'in^2',
rood: 'ro',
roods: 'ro',
acres: 'acre',
ha: 'hectare',
hectares: 'hectare',
oxgang: 'bovate',
squaregabo: 'gabo^2',
squaregabos: 'gabo^2',
sqgabo: 'gabo^2'
},
time: {
years: { suffix: ' non-leap years', ...factor(31536000) },
weeks: { suffix: ' weeks', ...factor(604800) },
days: { suffix: ' days', ...factor(86400) },
hours: { suffix: ' hours', ...factor(3600) },
minutes: { suffix: ' minutes', ...factor(60) },
seconds: { suffix: ' seconds', ...factor(1) },
sol: { suffix: ' sols (martian days)', ...factor(88775.24409) },
fortnight: { suffix: ' fortnights', ...factor(1209600) },
format_time: {
suffix: '',
to: val => Math.floor(val / 31536000) + 'y ' + Math.floor((val / 86400) % 365) + 'd ' + Math.floor((val / 3600) % 24) + 'h ' + Math.floor((val / 60) % 60) + 'm ' + (val % 60) + 's'
},
y: 'years',
yr: 'years',
yrs: 'years',
year: 'years',
w: 'weeks',
wk: 'weeks',
wks: 'weeks',
week: 'weeks',
d: 'days',
dy: 'days',
day: 'days',
h: 'hours',
hr: 'hours',
hrs: 'hours',
hour: 'hours',
m: 'minutes',
min: 'minutes',
mins: 'minutes',
minute: 'minutes',
s: 'seconds',
sec: 'seconds',
secs: 'seconds',
second: 'seconds',
sols: 'sol',
fortnights: 'fortnight',
time: 'format_time',
f_t: 'format_time'
}
};
})();
// returns all available units for a certain category
function dispOptions (measureType) {
let msgAdd = '';
for (const attribute in measureType) {
if (typeof measureType[attribute] !== 'string') {
msgAdd += (attribute + ', ');
}
}
msgAdd = msgAdd.substr(0, msgAdd.length - 2);
return msgAdd;
}
if (helpTrg !== 0) {
/* error handling, basically */
switch (helpTrg) {
case -2: {
const dUnit1 = cvrtvals[0].replace(getUnitRegex, '');
const dUnit2 = cvrtvals[1].replace(getUnitRegex, '');
msg = 'debug: text- ' + text + ' | in0- ' + cvrtvals[0] + ' | in1- ' + cvrtvals[1] + ' | val- ' + val + ' | unit1- ' + dUnit1 + ' | unit2- ' + dUnit2;
break;
}
case -1:
msg = '\'format_time\' cannot be used as input here abbybaPensive ';
break;
case 2:
msg = 'input format: "[val] [inputUnit] [outputUnit]" with spaces.';
break;
case 3:
msg = 'current accepted units for temperature: ' + dispOptions(conversions.temperature);
break;
case 4:
msg = 'current accepted units for length: ' + dispOptions(conversions.length);
break;
case 5:
msg = 'current accepted units for volume: ' + dispOptions(conversions.volume);
break;
case 6:
msg = 'current accepted units for mass/earth-relative weight: ' + dispOptions(conversions.massweight);
break;
case 7:
msg = 'current accepted units for area: ' + dispOptions(conversions.area);
break;
case 8:
msg = 'current accepted units for time: ' + dispOptions(conversions.time) + ' *format_time can only be used as output';
break;
default:
msg = 'convert function by Gem. Input format: "[number] [inputUnit] [outputUnit]" or "help [unittype]" -> ' + dispOptions(conversions);
break;
}
} else {
let unit1 = cvrtvals[0].replace(getUnitRegex, '');
let unit2 = cvrtvals[1].replace(getUnitRegex, '');
let calc = false;
const origVal = val;
for (const attribute in conversions) {
if (conversions[attribute].hasOwnProperty(unit1) && conversions[attribute].hasOwnProperty(unit2)) {
if (typeof (conversions[attribute][unit1]) === 'string') { unit1 = conversions[attribute][unit1]; }
if (typeof (conversions[attribute][unit2]) === 'string') { unit2 = conversions[attribute][unit2]; }
val = conversions[attribute][unit1].from(val);
if (conversions[attribute][unit1].suffix !== undefined) {
unit1 = conversions[attribute][unit1].suffix;
}
val = conversions[attribute][unit2].to(val);
if (conversions[attribute][unit2].suffix !== undefined) {
unit2 = conversions[attribute][unit2].suffix;
}
calc = true;
break;
}
}
if (!calc) {
// assuming the second unit is the issue
for (const attribute in conversions) {
if (conversions[attribute].hasOwnProperty(unit1)) {
unit2 = closestObjectAttribute(unit2, conversions[attribute])[0][1];
if (typeof (conversions[attribute][unit1]) === 'string') { unit1 = conversions[attribute][unit1]; }
if (typeof (conversions[attribute][unit2]) === 'string') { unit2 = conversions[attribute][unit2]; }
val = conversions[attribute][unit1].from(val);
if (conversions[attribute][unit1].suffix !== undefined) {
unit1 = conversions[attribute][unit1].suffix;
}
val = conversions[attribute][unit2].to(val);
if (conversions[attribute][unit2].suffix !== undefined) {
unit2 = conversions[attribute][unit2].suffix;
}
calc = true;
break;
}
}
}
if (!calc) {
msg = 'Unknown unit \'' + unit1 + '\' ...did you check your capitalisations?';
}
if (calc) {
if (typeof val === 'number') {
val = (val.toPrecision(6)).replace(/\.0+\b/, '');
}
msg = origVal + unit1 + ' = ' + val + unit2;
}
}
msg;Convert to and from morse code. Requires input string ‘text’. Morse code to word conversions must start with periods, dashes, or underscores. Spaces in morse should use _ or |.
variables: text
/* global text:true */
/* eslint-disable no-unused-expressions, no-prototype-builtins */
if (text === '') {
text = 'we\'re going to need something to translate...';
} else if (text === 'help') {
text = 'use plain text or \'.\', \'-\', and \'_\' (for spaces) as a query!';
} else {
if (['.', '-', '_'].includes(text[0])) {
// probably a morse to word
// handle when underscores aren't space seperated
text.replace(/_/g, ' _ ');
text.replace(/\s+/g, ' ');
const toWord = {
'.-': 'A',
'-...': 'B',
'-.-.': 'C',
'-..': 'D',
'.': 'E',
'..-.': 'F',
'--.': 'G',
'....': 'H',
'..': 'I',
'.---': 'J',
'-.-': 'K',
'.-..': 'L',
'--': 'M',
'-.': 'N',
'---': 'O',
'.--.': 'P',
'--.-': 'Q',
'.-.': 'R',
'...': 'S',
'-': 'T',
'..-': 'U',
'...-': 'V',
'.--': 'W',
'-..-': 'X',
'-.--': 'Y',
'--..': 'Z',
'.----': '1',
'..---': '2',
'...--': '3',
'....-': '4',
'.....': '5',
'-....': '6',
'--...': '7',
'---..': '8',
'----.': '9',
'-----': '0',
_: ' ',
'|': ' '
};
text = text.split(' ');
for (let i = 0; i < text.length; i++) {
if (toWord.hasOwnProperty(text[i])) {
text[i] = toWord[text[i]];
}
}
text = 'text: ' + text.join('');
} else {
// probably a word to morse
text = text.toUpperCase();
const toMorse = {
A: '.-',
B: '-...',
C: '-.-.',
D: '-..',
E: '.',
F: '..-.',
G: '--.',
H: '....',
I: '..',
J: '.---',
K: '-.-',
L: '.-..',
M: '--',
N: '-.',
O: '---',
P: '.--.',
Q: '--.-',
R: '.-.',
S: '...',
T: '-',
U: '..-',
V: '...-',
W: '.--',
X: '-..-',
Y: '-.--',
Z: '--..',
1: '.----',
2: '..---',
3: '...--',
4: '....-',
5: '.....',
6: '-....',
7: '--...',
8: '---..',
9: '----.',
0: '-----',
' ': '|'
};
text = text.split('');
for (let i = 0; i < text.length; i++) {
if (toMorse.hasOwnProperty(text[i])) {
text[i] = toMorse[text[i]];
}
}
text = 'morse: ' + text.join(' ');
if (text.length > 500) {
text = text.slice(0, 470);
text += '[exceeds char limit]';
}
}
}
text;The original fish code! (with some added functionality to work with the current command) just change fish_1.js to fish_0.js to use the legacy code
variables: fsh, msg, sz, fishoutput
/* Tell ESLint that there will be a global `user` variable */
/* global user */
let fsh = 5 + Math.random() * 95;
const msg = ['Teeny fish! 🐟 ',
'Not bad! lycelYes ',
'What a catch! lycelYay ',
"That's a big 'un lycelCool "
];
let sz = 0;
let fishoutput = ' ';
if ((Math.random() + fsh / 300) < 0.9) {
if (fsh > 75) {
sz = 3;
} else if (fsh > 50) {
sz = 2;
} else if (fsh > 25) {
sz = 1;
}
fsh = fsh / 10;
fishoutput = user + ' caught a fish of ' + fsh.toFixed(2) + 'kg! (' + (fsh * 2.20462).toFixed(2) + 'lbs) ' + msg[sz];
} else {
fishoutput = 'Oh no! The fish escaped!! smolPanic ';
}2021, Feb 08 update: fish are now generated based on a normal distribution. Use this as the contents of the nightbot command
variables: gaus, fsh, msg, sz, fishoutput
/* Tell ESLint that there will be a global `user` variable */
/* global user */
let gaus = -5;
while (gaus > 25 || gaus < -4.5) {
let u = 0;
let v = 0;
while (u === 0) u = Math.random();
while (v === 0) v = Math.random();
gaus = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
gaus = gaus * 2.5;
}
const fsh = 5 + gaus;
const msg = ['Teeny fish! lycelGib ',
'Oh, I caught one lycelWhatif ',
'Okay lycelIdk ',
'Not bad! lycelYes ',
'Pretty good! lycelCool ',
'What a catch! lycelYay ',
"That's a big 'un lycelAAA ",
'Those are rare! lycelBlush ',
'lycelW lycelW lycelW '];
let sz = 0;
let fishoutput = ' ';
if ((Math.random()) < 0.9) {
if (fsh > 20.0) {
sz = 8;
} else if (fsh > 10.0) {
sz = 7;
} else if (fsh > 7.5) {
sz = 6;
} else if (fsh > 6.25) {
sz = 5;
} else if (fsh > 5.25) {
sz = 4;
} else if (fsh > 4.75) {
sz = 3;
} else if (fsh > 3.75) {
sz = 2;
} else if (fsh > 2.5) {
sz = 1;
}
fishoutput = user + ' caught a fish of ' + fsh.toFixed(2) + 'kg! (' + (fsh * 2.20462).toFixed(2) + 'lbs) ' + msg[sz];
if (/6[.]*9/.test(fishoutput)) {
fishoutput += '- nice ';
}
} else {
fishoutput = 'Oh no! The fish escaped!! lycelHands ';
}change fish_[x].js (x being version number) to fish_off.js to disable fishing without deleting the command
variables: fishoutput
const fishoutput = '!fish is closed. Thanks for fishing with us!! kaestr1Hug';an alternative to fish_off.js based on Gabo’s code. Use fish_off_1.js to disable fishing with some quips.
variables: fishoutput
let fishoutput;
if (Math.random() <= 0.1) {
fishoutput = 'You caught a fish! Kappa';
} else {
const endEmote = [
'pcrowEyes',
'bryce4Eyes',
'cjyaEyes',
'lycelEyes',
'maizEyes',
'archit3Eyes',
'smolEyes',
'abbybaTea',
'lycelW',
'pcrowO',
'maizFlushed',
'pcrowW',
'kaestr1Eyes',
'abibeaLurk'
];
fishoutput = 'Go fish. ' + endEmote[Math.floor(Math.random() * endEmote.length)];
}this is just a js file with a const array “texttest”
variables: testtext
const testtext = ['test', 'testing'];a long array of emotes Gabo sent me. array’s name is “emotes”
variables: emotes
const emotes = ['kaestr1Cool',
'kaestr1Hug',
'maizCool',
'abbybaCool',
'smolCool',
'lycelCool',
'therea1896Cool',
'smolCheese',
'kaestr1Hug',
'abbybaHug',
'elizab34Uwu',
'pointcrowHug',
'linkusHug',
'kaestr1Cool',
'kaestr1Cool',
'kaestr1Cool',
'maizCool',
'abbybaCool',
'smolCool',
'lycelCool',
'kaestr1Cry',
'kaestr1Cry',
'kaestr1Cry',
'elizab34Hands',
'lycelHands',
'smolHands',
'tomshi1Cry',
'abbybaCry',
'archit3Cry',
'linkusCry',
'pcrowCry',
'smolCry',
'kaestr1Cool',
'kaestr1Hug',
'maizCool',
'abbybaCool',
'smolCool',
'lycelCool',
'lycelYes',
'therea1896Cool',
'smolCheese',
'abbybaHug',
'elizab34Uwu',
'pcrowHug',
'pcrowEyes',
'bryce4Eyes',
'hypoth7Eyes',
'cjyaEyes',
'lycelEyes',
'snazjdEyes',
'maizEyes',
'archit3Eyes',
'smolEyes',
'abbybaTea',
'lycelW',
'paintbNoScuff',
'pcrowO',
'maizFlushed',
'pcrowW',
'lycelGaze',
'pcrowEyes',
'bryce4Eyes',
'cjyaEyes',
'lycelEyes',
'maizEyes',
'archit3Eyes',
'smolEyes',
'abbybaTea',
'lycelW',
'paintbNoScuff',
'pcrowO',
'maizFlushed',
'pcrowW',
'lycelGaze',
'abibeaLurk'];